sp
1 year ago
3 changed files with 674 additions and 109 deletions
@ -0,0 +1,605 @@ |
|||||
|
import sys |
||||
|
import operator |
||||
|
from copy import deepcopy |
||||
|
from os import listdir, system |
||||
|
import subprocess |
||||
|
import re |
||||
|
from collections import defaultdict |
||||
|
|
||||
|
from random import randrange |
||||
|
from ale_py import ALEInterface, SDL_SUPPORT, Action |
||||
|
from PIL import Image |
||||
|
from matplotlib import pyplot as plt |
||||
|
import cv2 |
||||
|
import pickle |
||||
|
import queue |
||||
|
from dataclasses import dataclass, field |
||||
|
|
||||
|
from sklearn.cluster import KMeans, DBSCAN |
||||
|
|
||||
|
from enum import Enum |
||||
|
|
||||
|
from copy import deepcopy |
||||
|
|
||||
|
import numpy as np |
||||
|
|
||||
|
import logging |
||||
|
logger = logging.getLogger(__name__) |
||||
|
|
||||
|
#import readchar |
||||
|
|
||||
|
from sample_factory.algo.utils.tensor_dict import TensorDict |
||||
|
from query_sample_factory_checkpoint import SampleFactoryNNQueryWrapper |
||||
|
|
||||
|
import time |
||||
|
|
||||
|
tempest_binary = "/home/spranger/projects/tempest-devel/ranking_release/bin/storm" |
||||
|
rom_file = "/home/spranger/research/Skiing/env/lib/python3.10/site-packages/AutoROM/roms/skiing.bin" |
||||
|
|
||||
|
def tic(): |
||||
|
import time |
||||
|
global startTime_for_tictoc |
||||
|
startTime_for_tictoc = time.time() |
||||
|
|
||||
|
def toc(): |
||||
|
import time |
||||
|
if 'startTime_for_tictoc' in globals(): |
||||
|
return time.time() - startTime_for_tictoc |
||||
|
|
||||
|
class Verdict(Enum): |
||||
|
INCONCLUSIVE = 1 |
||||
|
GOOD = 2 |
||||
|
BAD = 3 |
||||
|
|
||||
|
verdict_to_color_map = {Verdict.BAD: "200,0,0", Verdict.INCONCLUSIVE: "40,40,200", Verdict.GOOD: "00,200,100"} |
||||
|
|
||||
|
def convert(tuples): |
||||
|
return dict(tuples) |
||||
|
|
||||
|
@dataclass(frozen=True) |
||||
|
class State: |
||||
|
x: int |
||||
|
y: int |
||||
|
ski_position: int |
||||
|
velocity: int |
||||
|
def default_value(): |
||||
|
return {'action' : None, 'choiceValue' : None} |
||||
|
|
||||
|
@dataclass(frozen=True) |
||||
|
class StateValue: |
||||
|
ranking: float |
||||
|
choices: dict = field(default_factory=default_value) |
||||
|
|
||||
|
@dataclass(frozen=False) |
||||
|
class TestResult: |
||||
|
init_check_pes_min: float |
||||
|
init_check_pes_max: float |
||||
|
init_check_pes_avg: float |
||||
|
init_check_opt_min: float |
||||
|
init_check_opt_max: float |
||||
|
init_check_opt_avg: float |
||||
|
safe_states: int |
||||
|
unsafe_states: int |
||||
|
safe_cluster: int |
||||
|
unsafe_cluster: int |
||||
|
good_verdicts: int |
||||
|
bad_verdicts: int |
||||
|
policy_queries: int |
||||
|
def __str__(self): |
||||
|
return f"""Test Result: |
||||
|
init_check_pes_min: {self.init_check_pes_min} |
||||
|
init_check_pes_max: {self.init_check_pes_max} |
||||
|
init_check_pes_avg: {self.init_check_pes_avg} |
||||
|
init_check_opt_min: {self.init_check_opt_min} |
||||
|
init_check_opt_max: {self.init_check_opt_max} |
||||
|
init_check_opt_avg: {self.init_check_opt_avg} |
||||
|
""" |
||||
|
@staticmethod |
||||
|
def csv_header(ws=" "): |
||||
|
string = f"pesmin{ws}pesmax{ws}pesavg{ws}" |
||||
|
string += f"optmin{ws}optmax{ws}optavg{ws}" |
||||
|
string += f"sState{ws}uState{ws}" |
||||
|
string += f"sClust{ws}uClust{ws}" |
||||
|
string += f"gVerd{ws}bVerd{ws}queries" |
||||
|
return string |
||||
|
|
||||
|
def csv(self): |
||||
|
ws = " " |
||||
|
string = f"{self.init_check_pes_min:0.04f}{ws}{self.init_check_pes_max:0.04f}{ws}{self.init_check_pes_avg:0.04f}{ws}" |
||||
|
string += f"{self.init_check_opt_min:0.04f}{ws}{self.init_check_opt_max:0.04f}{ws}{self.init_check_opt_avg:0.04f}{ws}" |
||||
|
ws = "\t" |
||||
|
string += f"{self.safe_states}{ws}{self.unsafe_states}{ws}" |
||||
|
string += f"{self.safe_cluster}{ws}{self.unsafe_cluster}{ws}" |
||||
|
string += f"{self.good_verdicts}{ws}{self.bad_verdicts}{ws}{self.policy_queries}" |
||||
|
return string |
||||
|
|
||||
|
|
||||
|
def exec(command,verbose=True): |
||||
|
if verbose: print(f"Executing {command}") |
||||
|
system(f"echo {command} >> list_of_exec") |
||||
|
return system(command) |
||||
|
|
||||
|
num_tests_per_cluster = 50 |
||||
|
#factor_tests_per_cluster = 0.2 |
||||
|
num_ski_positions = 8 |
||||
|
num_velocities = 5 |
||||
|
|
||||
|
def input_to_action(char): |
||||
|
if char == "0": |
||||
|
return Action.NOOP |
||||
|
if char == "1": |
||||
|
return Action.RIGHT |
||||
|
if char == "2": |
||||
|
return Action.LEFT |
||||
|
if char == "3": |
||||
|
return "reset" |
||||
|
if char == "4": |
||||
|
return "set_x" |
||||
|
if char == "5": |
||||
|
return "set_vel" |
||||
|
if char in ["w", "a", "s", "d"]: |
||||
|
return char |
||||
|
|
||||
|
def saveObservations(observations, verdict, testDir): |
||||
|
testDir = f"images/testing_{experiment_id}/{verdict.name}_{testDir}_{len(observations)}" |
||||
|
if len(observations) < 20: |
||||
|
logger.warn(f"Potentially spurious test case for {testDir}") |
||||
|
testDir = f"{testDir}_pot_spurious" |
||||
|
exec(f"mkdir {testDir}", verbose=False) |
||||
|
for i, obs in enumerate(observations): |
||||
|
img = Image.fromarray(obs) |
||||
|
img.save(f"{testDir}/{i:003}.png") |
||||
|
|
||||
|
ski_position_counter = {1: (Action.LEFT, 40), 2: (Action.LEFT, 35), 3: (Action.LEFT, 30), 4: (Action.LEFT, 10), 5: (Action.NOOP, 1), 6: (Action.RIGHT, 10), 7: (Action.RIGHT, 30), 8: (Action.RIGHT, 40) } |
||||
|
|
||||
|
def run_single_test(ale, nn_wrapper, x,y,ski_position, velocity, duration=50): |
||||
|
#print(f"Running Test from x: {x:04}, y: {y:04}, ski_position: {ski_position}", end="") |
||||
|
testDir = f"{x}_{y}_{ski_position}_{velocity}" |
||||
|
try: |
||||
|
for i, r in enumerate(ramDICT[y]): |
||||
|
ale.setRAM(i,r) |
||||
|
ski_position_setting = ski_position_counter[ski_position] |
||||
|
for i in range(0,ski_position_setting[1]): |
||||
|
ale.act(ski_position_setting[0]) |
||||
|
ale.setRAM(14,0) |
||||
|
ale.setRAM(25,x) |
||||
|
ale.setRAM(14,180) # TODO |
||||
|
except Exception as e: |
||||
|
print(e) |
||||
|
logger.warn(f"Could not run test for x: {x}, y: {y}, ski_position: {ski_position}, velocity: {velocity}") |
||||
|
return (Verdict.INCONCLUSIVE, 0) |
||||
|
|
||||
|
num_queries = 0 |
||||
|
all_obs = list() |
||||
|
speed_list = list() |
||||
|
resized_obs = cv2.resize(ale.getScreenGrayscale(), (84,84), interpolation=cv2.INTER_AREA) |
||||
|
for i in range(0,4): |
||||
|
all_obs.append(resized_obs) |
||||
|
for i in range(0,duration-4): |
||||
|
resized_obs = cv2.resize(ale.getScreenGrayscale(), (84,84), interpolation=cv2.INTER_AREA) |
||||
|
all_obs.append(resized_obs) |
||||
|
if i % 4 == 0: |
||||
|
stack_tensor = TensorDict({"obs": np.array(all_obs[-4:])}) |
||||
|
action = nn_wrapper.query(stack_tensor) |
||||
|
num_queries += 1 |
||||
|
ale.act(input_to_action(str(action))) |
||||
|
else: |
||||
|
ale.act(input_to_action(str(action))) |
||||
|
speed_list.append(ale.getRAM()[14]) |
||||
|
if len(speed_list) > 15 and sum(speed_list[-6:-1]) == 0: |
||||
|
#saveObservations(all_obs, Verdict.BAD, testDir) |
||||
|
return (Verdict.BAD, num_queries) |
||||
|
#saveObservations(all_obs, Verdict.GOOD, testDir) |
||||
|
return (Verdict.GOOD, num_queries) |
||||
|
|
||||
|
def skiPositionFormulaList(name): |
||||
|
formulas = list() |
||||
|
for i in range(1, num_ski_positions+1): |
||||
|
formulas.append(f"\"{name}_{i}\"") |
||||
|
return createBalancedDisjunction(formulas) |
||||
|
|
||||
|
|
||||
|
def computeStateRanking(mdp_file, iteration): |
||||
|
logger.info("Computing state ranking") |
||||
|
tic() |
||||
|
prop = f"filter(min, Pmin=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += f"filter(max, Pmin=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += f"filter(avg, Pmin=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += f"filter(min, Pmax=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += f"filter(max, Pmax=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += f"filter(avg, Pmax=? [ G !(\"Hit_Tree\" | \"Hit_Gate\" | {skiPositionFormulaList('Unsafe')}) ], (!\"S_Hit_Tree\" & !\"S_Hit_Gate\") | ({skiPositionFormulaList('Safe')} | {skiPositionFormulaList('Unsafe')}) );" |
||||
|
prop += 'Rmax=? [C <= 200]' |
||||
|
results = list() |
||||
|
try: |
||||
|
command = f"{tempest_binary} --prism {mdp_file} --buildchoicelab --buildstateval --build-all-labels --prop '{prop}'" |
||||
|
output = subprocess.check_output(command, shell=True).decode("utf-8").split('\n') |
||||
|
num_states = 0 |
||||
|
for line in output: |
||||
|
#print(line) |
||||
|
if "States:" in line: |
||||
|
num_states = int(line.split(" ")[-1]) |
||||
|
if "Result" in line and not len(results) >= 6: |
||||
|
range_value = re.search(r"(.*:).*\[(-?\d+\.?\d*), (-?\d+\.?\d*)\].*", line) |
||||
|
if range_value: |
||||
|
results.append(float(range_value.group(2))) |
||||
|
results.append(float(range_value.group(3))) |
||||
|
else: |
||||
|
value = re.search(r"(.*:)(.*)", line) |
||||
|
results.append(float(value.group(2))) |
||||
|
exec(f"mv action_ranking action_ranking_{iteration:03}") |
||||
|
except subprocess.CalledProcessError as e: |
||||
|
# todo die gracefully if ranking is uniform |
||||
|
print(e.output) |
||||
|
logger.info(f"Computing state ranking - DONE: took {toc()} seconds") |
||||
|
return TestResult(*tuple(results),0,0,0,0,0,0,0), num_states |
||||
|
|
||||
|
def fillStateRanking(file_name, match=""): |
||||
|
logger.info(f"Parsing state ranking, {file_name}") |
||||
|
tic() |
||||
|
state_ranking = dict() |
||||
|
try: |
||||
|
with open(file_name, "r") as f: |
||||
|
file_content = f.readlines() |
||||
|
for line in file_content: |
||||
|
if not "move=0" in line: continue |
||||
|
ranking_value = float(re.search(r"Value:([+-]?(\d*\.\d+)|\d+)", line)[0].replace("Value:","")) |
||||
|
if ranking_value <= 0.1: |
||||
|
continue |
||||
|
stateMapping = convert(re.findall(r"([a-zA-Z_]*[a-zA-Z])=(\d+)?", line)) |
||||
|
choices = convert(re.findall(r"[a-zA-Z_]*(left|right|noop)[a-zA-Z_]*:(-?\d+\.?\d*)", line)) |
||||
|
choices = {key:float(value) for (key,value) in choices.items()} |
||||
|
state = State(int(stateMapping["x"]), int(stateMapping["y"]), int(stateMapping["ski_position"]), int(stateMapping["velocity"])//2) |
||||
|
value = StateValue(ranking_value, choices) |
||||
|
state_ranking[state] = value |
||||
|
logger.info(f"Parsing state ranking - DONE: took {toc()} seconds") |
||||
|
return state_ranking |
||||
|
except EnvironmentError: |
||||
|
print("Ranking file not available. Exiting.") |
||||
|
toc() |
||||
|
sys.exit(-1) |
||||
|
except: |
||||
|
toc() |
||||
|
|
||||
|
def createDisjunction(formulas): |
||||
|
return " | ".join(formulas) |
||||
|
|
||||
|
def statesFormulaTrimmed(states, name): |
||||
|
#states = [(s[0].x,s[0].y, s[0].ski_position) for s in cluster] |
||||
|
skiPositionGroup = defaultdict(list) |
||||
|
for item in states: |
||||
|
skiPositionGroup[item[2]].append(item) |
||||
|
|
||||
|
formulas = list() |
||||
|
for skiPosition, skiPos_group in skiPositionGroup.items(): |
||||
|
formula = f"formula {name}_{skiPosition} = ( ski_position={skiPosition} & " |
||||
|
#print(f"{name} ski_pos:{skiPosition}") |
||||
|
velocityGroup = defaultdict(list) |
||||
|
velocityFormulas = list() |
||||
|
for item in skiPos_group: |
||||
|
velocityGroup[item[3]].append(item) |
||||
|
for velocity, velocity_group in velocityGroup.items(): |
||||
|
#print(f"\tvel:{velocity}") |
||||
|
formulasPerSkiPosition = list() |
||||
|
yPosGroup = defaultdict(list) |
||||
|
yFormulas = list() |
||||
|
for item in velocity_group: |
||||
|
yPosGroup[item[1]].append(item) |
||||
|
for y, y_group in yPosGroup.items(): |
||||
|
#print(f"\t\ty:{y}") |
||||
|
sorted_y_group = sorted(y_group, key=lambda s: s[0]) |
||||
|
current_x_min = sorted_y_group[0][0] |
||||
|
current_x = sorted_y_group[0][0] |
||||
|
x_ranges = list() |
||||
|
for state in sorted_y_group[1:-1]: |
||||
|
if state[0] - current_x == 1: |
||||
|
current_x = state[0] |
||||
|
else: |
||||
|
x_ranges.append(f" ({current_x_min}<=x&x<={current_x})") |
||||
|
current_x_min = state[0] |
||||
|
current_x = state[0] |
||||
|
x_ranges.append(f" {current_x_min}<=x&x<={sorted_y_group[-1][0]}") |
||||
|
yFormulas.append(f" (y={y} & {createBalancedDisjunction(x_ranges)})") |
||||
|
#x_ranges.clear() |
||||
|
|
||||
|
#velocityFormulas.append(f"(velocity={velocity} & {createBalancedDisjunction(yFormulas)})") |
||||
|
velocityFormulas.append(f"({createBalancedDisjunction(yFormulas)})") |
||||
|
#yFormulas.clear() |
||||
|
formula += createBalancedDisjunction(velocityFormulas) + ");" |
||||
|
#velocityFormulas.clear() |
||||
|
formulas.append(formula) |
||||
|
for i in range(1, num_ski_positions+1): |
||||
|
if i in skiPositionGroup: |
||||
|
continue |
||||
|
formulas.append(f"formula {name}_{i} = false;") |
||||
|
return "\n".join(formulas) + "\n" |
||||
|
|
||||
|
# https://stackoverflow.com/questions/5389507/iterating-over-every-two-elements-in-a-list |
||||
|
def pairwise(iterable): |
||||
|
"s -> (s0, s1), (s2, s3), (s4, s5), ..." |
||||
|
a = iter(iterable) |
||||
|
return zip(a, a) |
||||
|
|
||||
|
def createBalancedDisjunction(formulas): |
||||
|
if len(formulas) == 0: |
||||
|
return "false" |
||||
|
while len(formulas) > 1: |
||||
|
formulas_tmp = [f"({f} | {g})" for f,g in pairwise(formulas)] |
||||
|
if len(formulas) % 2 == 1: |
||||
|
formulas_tmp.append(formulas[-1]) |
||||
|
formulas = formulas_tmp |
||||
|
return " ".join(formulas) |
||||
|
|
||||
|
def updatePrismFile(newFile, iteration, safeStates, unsafeStates): |
||||
|
logger.info("Creating next prism file") |
||||
|
tic() |
||||
|
initFile = f"{newFile}_no_formulas.prism" |
||||
|
newFile = f"{newFile}_{iteration:03}.prism" |
||||
|
exec(f"cp {initFile} {newFile}", verbose=False) |
||||
|
with open(newFile, "a") as prism: |
||||
|
prism.write(statesFormulaTrimmed(safeStates, "Safe")) |
||||
|
prism.write(statesFormulaTrimmed(unsafeStates, "Unsafe")) |
||||
|
for i in range(1,num_ski_positions+1): |
||||
|
prism.write(f"label \"Safe_{i}\" = Safe_{i};\n") |
||||
|
prism.write(f"label \"Unsafe_{i}\" = Unsafe_{i};\n") |
||||
|
|
||||
|
logger.info(f"Creating next prism file - DONE: took {toc()} seconds") |
||||
|
|
||||
|
|
||||
|
ale = ALEInterface() |
||||
|
|
||||
|
|
||||
|
#if SDL_SUPPORT: |
||||
|
# ale.setBool("sound", True) |
||||
|
# ale.setBool("display_screen", True) |
||||
|
|
||||
|
# Load the ROM file |
||||
|
ale.loadROM(rom_file) |
||||
|
|
||||
|
with open('all_positions_v2.pickle', 'rb') as handle: |
||||
|
ramDICT = pickle.load(handle) |
||||
|
y_ram_setting = 60 |
||||
|
x = 70 |
||||
|
|
||||
|
|
||||
|
nn_wrapper = SampleFactoryNNQueryWrapper() |
||||
|
|
||||
|
experiment_id = int(time.time()) |
||||
|
init_mdp = "velocity_safety" |
||||
|
exec(f"mkdir -p images/testing_{experiment_id}", verbose=False) |
||||
|
|
||||
|
|
||||
|
imagesDir = f"images/testing_{experiment_id}" |
||||
|
|
||||
|
def drawOntoSkiPosImage(states, color, target_prefix="cluster_", alpha_factor=1.0, markerSize=1, drawCircle=False): |
||||
|
#markerList = {ski_position:list() for ski_position in range(1,num_ski_positions + 1)} |
||||
|
markerList = {(ski_position, velocity):list() for velocity in range(0, num_velocities) for ski_position in range(1,num_ski_positions + 1)} |
||||
|
images = dict() |
||||
|
mergedImages = dict() |
||||
|
for ski_position in range(1, num_ski_positions + 1): |
||||
|
for velocity in range(0,num_velocities): |
||||
|
images[(ski_position, velocity)] = cv2.imread(f"{imagesDir}/{target_prefix}_{ski_position:02}_{velocity:02}_individual.png") |
||||
|
mergedImages[ski_position] = cv2.imread(f"{imagesDir}/{target_prefix}_{ski_position:02}_individual.png") |
||||
|
for state in states: |
||||
|
s = state[0] |
||||
|
marker = [color, alpha_factor * state[1].ranking, (s.x-markerSize, s.y-markerSize), (s.x+markerSize, s.y+markerSize)] |
||||
|
markerList[(s.ski_position, s.velocity)].append(marker) |
||||
|
for (pos, vel), marker in markerList.items(): |
||||
|
if len(marker) == 0: continue |
||||
|
if drawCircle: |
||||
|
for m in marker: |
||||
|
images[(pos,vel)] = cv2.circle(images[(pos,vel)], m[2], 1, m[0], thickness=-1) |
||||
|
mergedImages[pos] = cv2.circle(mergedImages[pos], m[2], 1, m[0], thickness=-1) |
||||
|
else: |
||||
|
for m in marker: |
||||
|
images[(pos,vel)] = cv2.rectangle(images[(pos,vel)], m[2], m[3], m[0], cv2.FILLED) |
||||
|
mergedImages[pos] = cv2.rectangle(mergedImages[pos], m[2], m[3], m[0], cv2.FILLED) |
||||
|
for (ski_position, velocity), image in images.items(): |
||||
|
cv2.imwrite(f"{imagesDir}/{target_prefix}_{ski_position:02}_{velocity:02}_individual.png", image) |
||||
|
for ski_position, image in mergedImages.items(): |
||||
|
cv2.imwrite(f"{imagesDir}/{target_prefix}_{ski_position:02}_individual.png", image) |
||||
|
|
||||
|
|
||||
|
def concatImages(prefix, iteration): |
||||
|
logger.info(f"Concatenating images") |
||||
|
images = [f"{imagesDir}/{prefix}_{pos:02}_{vel:02}_individual.png" for vel in range(0,num_velocities) for pos in range(1,num_ski_positions+1)] |
||||
|
mergedImages = [f"{imagesDir}/{prefix}_{pos:02}_individual.png" for pos in range(1,num_ski_positions+1)] |
||||
|
for vel in range(0, num_velocities): |
||||
|
for pos in range(1, num_ski_positions + 1): |
||||
|
command = f"convert {imagesDir}/{prefix}_{pos:02}_{vel:02}_individual.png " |
||||
|
command += f"-pointsize 10 -gravity NorthEast -annotate +8+0 'p{pos:02}v{vel:02}' " |
||||
|
command += f"{imagesDir}/{prefix}_{pos:02}_{vel:02}_individual.png" |
||||
|
exec(command, verbose=False) |
||||
|
exec(f"montage {' '.join(images)} -geometry +0+0 -tile 8x9 {imagesDir}/{prefix}_{iteration:03}.png", verbose=False) |
||||
|
exec(f"montage {' '.join(mergedImages)} -geometry +0+0 -tile 8x9 {imagesDir}/{prefix}_{iteration:03}_merged.png", verbose=False) |
||||
|
#exec(f"sxiv {imagesDir}/{prefix}_{iteration}.png&", verbose=False) |
||||
|
logger.info(f"Concatenating images - DONE") |
||||
|
|
||||
|
def drawStatesOntoTiledImage(states, color, target, source="images/1_full_scaled_down.png", alpha_factor=1.0): |
||||
|
""" |
||||
|
Useful to draw a set of states, e.g. a single cluster |
||||
|
TODO |
||||
|
markerList = {1: list(), 2:list(), 3:list(), 4:list(), 5:list(), 6:list(), 7:list(), 8:list()} |
||||
|
logger.info(f"Drawing {len(states)} states onto {target}") |
||||
|
tic() |
||||
|
for state in states: |
||||
|
s = state[0] |
||||
|
marker = f"-fill 'rgba({color}, {alpha_factor * state[1].ranking})' -draw 'rectangle {s.x-markerSize},{s.y-markerSize} {s.x+markerSize},{s.y+markerSize} '" |
||||
|
markerList[s.ski_position].append(marker) |
||||
|
for pos, marker in markerList.items(): |
||||
|
command = f"convert {source} {' '.join(marker)} {imagesDir}/{target}_{pos:02}_individual.png" |
||||
|
exec(command, verbose=False) |
||||
|
exec(f"montage {imagesDir}/{target}_*_individual.png -geometry +0+0 -tile x1 {imagesDir}/{target}.png", verbose=False) |
||||
|
logger.info(f"Drawing {len(states)} states onto {target} - Done: took {toc()} seconds") |
||||
|
""" |
||||
|
|
||||
|
def drawClusters(clusterDict, target, iteration, alpha_factor=1.0): |
||||
|
logger.info(f"Drawing {len(clusterDict)} clusters") |
||||
|
tic() |
||||
|
for _, clusterStates in clusterDict.items(): |
||||
|
color = (np.random.choice(range(256)), np.random.choice(range(256)), np.random.choice(range(256))) |
||||
|
color = (int(color[0]), int(color[1]), int(color[2])) |
||||
|
drawOntoSkiPosImage(clusterStates, color, target, alpha_factor=alpha_factor) |
||||
|
concatImages(target, iteration) |
||||
|
logger.info(f"Drawing {len(clusterDict)} clusters - DONE: took {toc()} seconds") |
||||
|
|
||||
|
def drawResult(clusterDict, target, iteration, drawnCluster=set()): |
||||
|
logger.info(f"Drawing {len(clusterDict)} results") |
||||
|
tic() |
||||
|
for id, (clusterStates, result) in clusterDict.items(): |
||||
|
if id in drawnCluster: continue |
||||
|
# opencv wants BGR |
||||
|
color = (100,100,100) |
||||
|
if result == Verdict.GOOD: |
||||
|
color = (0,200,0) |
||||
|
elif result == Verdict.BAD: |
||||
|
color = (0,0,200) |
||||
|
drawOntoSkiPosImage(clusterStates, color, target, alpha_factor=0.7) |
||||
|
logger.info(f"Drawing {len(clusterDict)} results - DONE: took {toc()} seconds") |
||||
|
|
||||
|
def _init_logger(): |
||||
|
logger = logging.getLogger('main') |
||||
|
logger.setLevel(logging.INFO) |
||||
|
handler = logging.StreamHandler(sys.stdout) |
||||
|
formatter = logging.Formatter( '[%(levelname)s] %(module)s - %(message)s') |
||||
|
handler.setFormatter(formatter) |
||||
|
logger.addHandler(handler) |
||||
|
|
||||
|
def clusterImportantStates(ranking, iteration): |
||||
|
logger.info(f"Starting to cluster {len(ranking)} states into clusters") |
||||
|
tic() |
||||
|
states = [[s[0].x,s[0].y, s[0].ski_position * 20, s[0].velocity * 20, s[1].ranking] for s in ranking] |
||||
|
#states = [[s[0].x,s[0].y, s[0].ski_position * 30, s[1].ranking] for s in ranking] |
||||
|
kmeans = KMeans(len(states) // 15, random_state=0, n_init="auto").fit(states) |
||||
|
#dbscan = DBSCAN(eps=5).fit(states) |
||||
|
#labels = dbscan.labels_ |
||||
|
labels = kmeans.labels_ |
||||
|
n_clusters = len(set(labels)) - (1 if -1 in labels else 0) |
||||
|
logger.info(f"Starting to cluster {len(ranking)} states into clusters - DONE: took {toc()} seconds with {n_clusters} cluster") |
||||
|
clusterDict = {i : list() for i in range(0,n_clusters)} |
||||
|
strayStates = list() |
||||
|
for i, state in enumerate(ranking): |
||||
|
if labels[i] == -1: |
||||
|
clusterDict[n_clusters + len(strayStates) + 1] = list() |
||||
|
clusterDict[n_clusters + len(strayStates) + 1].append(state) |
||||
|
strayStates.append(state) |
||||
|
continue |
||||
|
clusterDict[labels[i]].append(state) |
||||
|
if len(strayStates) > 0: logger.warning(f"{len(strayStates)} stray states with label -1") |
||||
|
#drawClusters(clusterDict, f"clusters", iteration) |
||||
|
return clusterDict |
||||
|
|
||||
|
|
||||
|
def run_experiment(factor_tests_per_cluster): |
||||
|
logger.info("Starting") |
||||
|
num_queries = 0 |
||||
|
|
||||
|
source = "images/1_full_scaled_down.png" |
||||
|
for ski_position in range(1, num_ski_positions + 1): |
||||
|
for velocity in range(0,num_velocities): |
||||
|
exec(f"cp {source} {imagesDir}/clusters_{ski_position:02}_{velocity:02}_individual.png", verbose=False) |
||||
|
exec(f"cp {source} {imagesDir}/result_{ski_position:02}_{velocity:02}_individual.png", verbose=False) |
||||
|
exec(f"cp {source} {imagesDir}/clusters_{ski_position:02}_individual.png", verbose=False) |
||||
|
exec(f"cp {source} {imagesDir}/result_{ski_position:02}_individual.png", verbose=False) |
||||
|
|
||||
|
goodVerdicts = 0 |
||||
|
badVerdicts = 0 |
||||
|
goodVerdictTestCases = list() |
||||
|
badVerdictTestCases = list() |
||||
|
safeClusters = 0 |
||||
|
unsafeClusters = 0 |
||||
|
safeStates = set() |
||||
|
unsafeStates = set() |
||||
|
iteration = 0 |
||||
|
results = list() |
||||
|
|
||||
|
eps = 0.1 |
||||
|
updatePrismFile(init_mdp, iteration, set(), set()) |
||||
|
#modelCheckingResult, numStates = TestResult(0,0,0,0,0,0,0,0,0,0,0,0,0), 10 |
||||
|
modelCheckingResult, numStates = computeStateRanking(f"{init_mdp}_000.prism", iteration) |
||||
|
results.append(modelCheckingResult) |
||||
|
ranking = fillStateRanking(f"action_ranking_000") |
||||
|
|
||||
|
sorted_ranking = sorted( (x for x in ranking.items() if x[1].ranking > 0.1), key=lambda x: x[1].ranking) |
||||
|
try: |
||||
|
clusters = clusterImportantStates(sorted_ranking, iteration) |
||||
|
except Exception as e: |
||||
|
print(e) |
||||
|
sys.exit(-1) |
||||
|
|
||||
|
clusterResult = dict() |
||||
|
logger.info(f"Running tests") |
||||
|
tic() |
||||
|
num_cluster_tested = 0 |
||||
|
iteration = 0 |
||||
|
drawnCluster = set() |
||||
|
for id, cluster in clusters.items(): |
||||
|
num_tests = int(factor_tests_per_cluster * len(cluster)) |
||||
|
if num_tests == 0: num_tests = 1 |
||||
|
logger.info(f"Testing {num_tests} states (from {len(cluster)} states) from cluster {id}") |
||||
|
randomStates = np.random.choice(len(cluster), num_tests, replace=False) |
||||
|
randomStates = [cluster[i] for i in randomStates] |
||||
|
|
||||
|
verdictGood = True |
||||
|
for state in randomStates: |
||||
|
x = state[0].x |
||||
|
y = state[0].y |
||||
|
ski_pos = state[0].ski_position |
||||
|
velocity = state[0].velocity |
||||
|
result, num_queries_this_test_case = run_single_test(ale,nn_wrapper,x,y,ski_pos, velocity, duration=50) |
||||
|
num_queries += num_queries_this_test_case |
||||
|
if result == Verdict.BAD: |
||||
|
clusterResult[id] = (cluster, Verdict.BAD) |
||||
|
verdictGood = False |
||||
|
unsafeStates.update([(s[0].x,s[0].y, s[0].ski_position, s[0].velocity) for s in cluster]) |
||||
|
badVerdicts += 1 |
||||
|
badVerdictTestCases.append(state) |
||||
|
|
||||
|
elif result == Verdict.GOOD: |
||||
|
goodVerdicts += 1 |
||||
|
goodVerdictTestCases.append(state) |
||||
|
if verdictGood: |
||||
|
clusterResult[id] = (cluster, Verdict.GOOD) |
||||
|
safeClusters += 1 |
||||
|
safeStates.update([(s[0].x,s[0].y, s[0].ski_position, s[0].velocity) for s in cluster]) |
||||
|
else: |
||||
|
unsafeClusters += 1 |
||||
|
results[-1].safe_states = len(safeStates) |
||||
|
results[-1].unsafe_states = len(unsafeStates) |
||||
|
results[-1].policy_queries = num_queries |
||||
|
results[-1].safe_cluster = safeClusters |
||||
|
results[-1].unsafe_cluster = unsafeClusters |
||||
|
results[-1].good_verdicts = goodVerdicts |
||||
|
results[-1].bad_verdicts = badVerdicts |
||||
|
num_cluster_tested += 1 |
||||
|
if num_cluster_tested % (len(clusters)//20) == 0: |
||||
|
iteration += 1 |
||||
|
logger.info(f"Tested Cluster: {num_cluster_tested:03}\tSafe Cluster States : {len(safeStates)}({safeClusters}/{len(clusters)})\tUnsafe Cluster States:{len(unsafeStates)}({unsafeClusters}/{len(clusters)})\tGood Test Cases:{goodVerdicts}\tFailing Test Cases:{badVerdicts}\t{len(safeStates)/len(unsafeStates)} - {goodVerdicts/badVerdicts}") |
||||
|
drawResult(clusterResult, "result", iteration, drawnCluster) |
||||
|
drawOntoSkiPosImage(goodVerdictTestCases, (10,255,50), "result", alpha_factor=0.7, markerSize=0, drawCircle=True) |
||||
|
drawOntoSkiPosImage(badVerdictTestCases, (0,0,0), "result", alpha_factor=0.7, markerSize=0, drawCircle=True) |
||||
|
concatImages("result", iteration) |
||||
|
drawnCluster.update(clusterResult.keys()) |
||||
|
#updatePrismFile(init_mdp, iteration, safeStates, unsafeStates) |
||||
|
#modelCheckingResult, numStates = computeStateRanking(f"{init_mdp}_{iteration:03}.prism", iteration) |
||||
|
results.append(deepcopy(modelCheckingResult)) |
||||
|
logger.info(f"Model Checking Result: {modelCheckingResult}") |
||||
|
# Account for self-loop states after first iteration |
||||
|
if iteration > 0: |
||||
|
results[-1].init_check_pes_avg = 1/(numStates+len(safeStates)+len(unsafeStates)) * (results[-1].init_check_pes_avg*numStates + 1.0*results[-2].unsafe_states + 0.0*results[-2].safe_states) |
||||
|
results[-1].init_check_opt_avg = 1/(numStates+len(safeStates)+len(unsafeStates)) * (results[-1].init_check_opt_avg*numStates + 0.0*results[-2].unsafe_states + 1.0*results[-2].safe_states) |
||||
|
print(TestResult.csv_header()) |
||||
|
for result in results[:-1]: |
||||
|
print(result.csv()) |
||||
|
|
||||
|
|
||||
|
with open(f"data_new_method_{factor_tests_per_cluster}", "w") as f: |
||||
|
f.write(TestResult.csv_header() + "\n") |
||||
|
for result in results[:-1]: |
||||
|
f.write(result.csv() + "\n") |
||||
|
|
||||
|
|
||||
|
_init_logger() |
||||
|
logger = logging.getLogger('main') |
||||
|
if __name__ == '__main__': |
||||
|
for factor_tests_per_cluster in [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]: |
||||
|
run_experiment(factor_tests_per_cluster) |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue