def __init__(self, data_loader, dose_loader=None):
"""
Prepare the class for evaluating dose distributions
:param data_loader: a data loader object that loads data from the reference dataset
:param dose_loader: a data loader object that loads a dose tensor from any dataset (e.g., predictions)
"""
# Initialize objects
self.data_loader = data_loader # Loads data related to ground truth patient information
self.dose_loader = dose_loader # Loads the data for a benchmark dose
# Initialize objects for later
self.patient_list = None
self.roi_mask = None
self.new_dose = None
self.reference_dose = None
self.voxel_size = None
self.possible_dose_mask = None
# Set metrics to be evaluated
self.oar_eval_metrics = ['D_0.1_cc', 'mean']
self.tar_eval_metrics = ['D_99', 'D_95', 'D_1']
# Name metrics for data frame
oar_metrics = list(
it_product(self.oar_eval_metrics, self.data_loader.rois['oars']))
target_metrics = list(
it_product(self.tar_eval_metrics,
self.data_loader.rois['targets']))
# Make data frame to store dose metrics and the difference data frame
self.metric_difference_df = pd.DataFrame(
index=self.data_loader.patient_id_list,
columns=[*oar_metrics, *target_metrics])
self.reference_dose_metric_df = self.metric_difference_df.copy()
self.new_dose_metric_df = self.metric_difference_df.copy()
def combine_transitions(ctrl):
""" Combine parallell transitions when they are independent of environment actions
Parameters
----------
ctrl: mealy machine
"""
ctrl_copy = ctrl.copy()
for c_state in ctrl_copy.nodes():
for post_s in ctrl_copy.states.post(c_state):
logger.info('(' + str(c_state) + ')' + '(' + str(post_s) + ')')
labels = [
set(label.items())
for (x, y,
label) in ctrl_copy.transitions.find({c_state}, {post_s})
]
min_set = set.intersection(*labels)
labels_mins = [lab - min_set for lab in labels]
if set.union(*labels_mins) == set():
continue
list_in = [
set(it_product({key}, values))
for (key, values) in ctrl_copy.inputs.items()
if (not values == {0, 1})
& (set(it_product({key}, values)) <= set.union(*labels_mins))
] + [
set(it_product({key}, {True, False}))
for (key, values) in ctrl_copy.inputs.items() if
((values == {0, 1})
& (set(it_product({key}, values)) <= set.union(*labels_mins)))
]
labels_updated = labels.copy()
for list_el in list_in:
for label in labels_updated:
label_gen = [(label - list_el) | {el_set}
for el_set in list_el]
if all([
any([
label_gen_el == labels_el
for labels_el in labels_updated
]) for label_gen_el in label_gen
]):
labels_updated = set(
frozenset(labels_el)
for labels_el in labels_updated if not any([
label_gen_el == labels_el
for label_gen_el in label_gen
]))
labels_updated |= {frozenset((label - list_el))}
ctrl_copy.transitions.remove_from(
ctrl_copy.transitions.find({c_state}, {post_s}))
for labels_updated_el in labels_updated:
ctrl_copy.transitions.add(c_state, post_s,
dict(set(labels_updated_el)))
return ctrl_copy
def pdq_maker(order_limit=2, s_order_limit=1, period=12):
"""generate all possible SARIMA orders for range"""
p = d = q = range(0, order_limit)
P = D = Q = range(0, s_order_limit)
# Generate all different combinations of pdq/PDQ triplets
pdq = list(it_product(p, d, q))
seasonal_PDQ = [(x[0], x[1], x[2], period)
for x in list(it_product(p, d, q))]
return (pdq, seasonal_PDQ)
def build(self, build_data):
self.rects.clear()
self.rects.append(
Rect(1, 1, build_data.map.width - 2, build_data.map.height - 2))
first_room = self.rects[0]
self.add_subrects(first_room)
rooms = list()
rooms_copy = copy.deepcopy(self.rects)
'''
for room in rooms_copy:
rooms.append(room)
for y in range(room.y1, room.y2):
for x in range(room.x1, room.x2):
idx = build_data.map.xy_idx(x, y)
if 0 < idx < ((build_data.map.width * build_data.map.height) - 1):
build_data.map.tiles[idx] = TileType.FLOOR
build_data.take_snapshot()
'''
for room in rooms_copy:
rooms.append(room)
for x, y in it_product(range(room.x1, room.x2),
range(room.y1, room.y2)):
idx = build_data.map.xy_idx(x, y)
if 0 < idx < (
(build_data.map.width * build_data.map.height) - 1):
build_data.map.tiles[idx] = TileType.FLOOR
build_data.take_snapshot()
build_data.rooms = rooms
def trials(self, period: int = 1) -> Iterator[ActionsTrial]:
"""
Generate a sequence of ActionsTrial objects, representing all the
different combinations of Action that could be tried, given the
constraints of `allow_no_action` and `allow_multiple_actions`.
:param period: The period in which the action is being tried.
"""
for try_each_action in it_product(*[[False, True]
for _ in range(self.num_actions)]):
# dont allow zero-action trials if not allowed
if not self.allow_no_action and all(
[try_action is False for try_action in try_each_action]):
continue
# don't allow multi-action trials if not allowed
if not self.allow_multiple_actions and sum(
[try_action is True for try_action in try_each_action]) > 1:
continue
if (
# all actions can be tried
self.can_try_action is None
# or all actions we want to try can be tried
or all(
self.can_try_action(action, period) is True
or try_action is False for action, try_action in zip(
self.actions, try_each_action))):
yield ActionsTrial(
*(AvailableAction(action=action, try_action=try_action)
for action, try_action in zip(self.actions,
try_each_action)))
else:
continue
def is_possible(self, rect, gmap, rooms):
expanded = copy.deepcopy(rect)
expanded.x1 -= 2
expanded.x2 += 2
expanded.y1 -= 2
expanded.y2 += 2
can_build = True
for room in rooms:
if room.intersect(rect):
can_build = False
'''
for y in range(expanded.y1, expanded.y2):
for x in range(expanded.x1, expanded.x2):
if x > gmap.width - 2 or y > gmap.height - 2 or x < 1 or y < 1:
can_build = False
if can_build:
idx = gmap.xy_idx(x, y)
if gmap.tiles[idx] != TileType.WALL:
can_build = False
'''
for x, y in it_product(range(expanded.x1, expanded.x2),
range(expanded.y1, expanded.y2)):
if x > gmap.width - 2 or y > gmap.height - 2 or x < 1 or y < 1:
can_build = False
if can_build:
idx = gmap.xy_idx(x, y)
if gmap.tiles[idx] != TileType.WALL:
can_build = False
return can_build
def build_initial_map(self, build_data):
'''
for y in range(1, build_data.map.height - 2):
for x in range(1, build_data.map.width - 2):
rand = randint(1, 100)
idx = build_data.map.xy_idx(x, y)
if rand > 55:
build_data.map.tiles[idx] = TileType.FLOOR
else:
build_data.map.tiles[idx] = TileType.WALL
'''
for x, y in it_product(range(1, build_data.map.width - 2),
range(1, build_data.map.height - 2)):
rand = randint(1, 100)
idx = build_data.map.xy_idx(x, y)
if rand > 55:
build_data.map.tiles[idx] = TileType.FLOOR
else:
build_data.map.tiles[idx] = TileType.WALL
build_data.take_snapshot()
for _i in range(0, 15):
self.apply_iteration(build_data)
def remove_aux_inputs(ctrl, inputs):
#1. check whether you are allowed to remove the aux inputs. <= not done
#2. remove aux. inputs.
ctrl_new = transys.MealyMachine()
ctrl_new.add_outputs(ctrl.outputs)
# this needs to be changed to be a limited set
inputs_dict = dict()
for i in inputs:
inputs_dict[i] = ctrl.inputs[i]
ctrl_new.add_inputs(inputs_dict)
# add nodes from original mealy
ctrl_new.add_nodes_from(ctrl.nodes())
block_pairs = it_product(ctrl, ctrl)
for (b, c) in block_pairs:
labels = {
frozenset([(key, label[key]) for key in ctrl_new.inputs.keys()] +
[(output, label[output])
for output in ctrl_new.outputs.keys()])
for (x, y, label) in ctrl.transitions.find(b, c)
}
for q in labels:
ctrl_new.transitions.add(b, c, **dict(q))
ctrl_new.states.initial.add_from(ctrl.states.initial)
return ctrl_new
def _add_tests():
_pair = ['mem', 'dsk']
_template = '''
def test_{1}_{2}_to_{3}{0}(self):
Rd = {0}(self.{1}A, self.{2}B)
self.assert_(isinstance(Rd, blaze.Array))
self.assert_(Rd._data.deferred)
p = _store('{3}Rd') if '{3}' == 'dsk' else None
try:
Rc = blaze.eval(Rd, storage=p)
self.assert_(isinstance(Rc, blaze.Array))
assert_allclose(np.array(dd_as_py(Rc._data)), self.npy{4})
self.assert_(Rc._data.persistent if '{3}' == 'dsk'
else not Rc._data.persistent)
finally:
if p is not None:
blaze.drop(p)
'''
frame = sys._getframe(1)
for expr, ltr in zip(['_addition', '_expression'], ['R', 'Q']):
for i in it_product(_pair, _pair, _pair):
args = i + (ltr,)
exec_(_template.format(expr,*args),
frame.f_globals,
frame.f_locals)
def iterate_equiv(q_blocks, ctrl, outputs={'loc'}):
""" Iterate the equivalence classes
Parameters
----------
q_blocks : equivalence classes
ctrl : mealy machine
outputs : Tells which outputs are critical and should be kept. Given as a set of strings.
"""
dict__r = dict(
sum([
list(it_product(block, {i})) for (i, block) in enumerate(q_blocks)
], []))
blocks = []
# Determine the equivalence class for each element of the iterable.
for y in ctrl.states():
# Each element y must be in *exactly one* equivalence class.
#
# Each block is guaranteed to be non-empty
if y in ctrl.states.initial:
blocks.append(
[y]
) # We don't want to group in the initial state. Because that will give issues witht he autocoding.
else:
for block in blocks:
x = next(iter(block))
if len(ctrl[x]) != len(ctrl[y]):
# print('unequal number')
continue
# compute set of labels:
labels_x = {
frozenset([(key, label[key])
for key in ctrl.inputs.keys()] +
[(output, label[output]) for output in outputs] +
[('Relx', dict__r[_x])] +
[('Rely', dict__r[_y])])
for (_x, _y, label) in ctrl.transitions.find({x})
}
labels_y = {
frozenset([(key, label[key])
for key in ctrl.inputs.keys()] +
[(output, label[output]) for output in outputs] +
[('Relx', dict__r[_x])] +
[('Rely', dict__r[_y])])
for (_x, _y, label) in ctrl.transitions.find({y})
}
if labels_x == labels_y:
block.append(y)
break
else:
# If the element y is not part of any known equivalence class, it
# must be in its own, so we create a new singleton equivalence
# class for it.
blocks.append([y])
return {frozenset(block) for block in blocks}
def _add_tests():
_pair = ['mem', 'dsk']
frame = sys._getframe(1)
for expr, ltr in zip([_addition, _expression], ['R', 'Q']):
for i in it_product(_pair, _pair, _pair):
args = i + (ltr, )
f = _build_tst(expr, *args)
f.__name__ = 'test_{1}_{2}_to_{3}{0}'.format(f.__name__, *args)
frame.f_locals[f.__name__] = f
def _add_tests():
_pair = ['mem', 'dsk']
frame = sys._getframe(1)
for expr, ltr in zip([_addition, _expression], ['R', 'Q']):
for i in it_product(_pair, _pair, _pair):
args = i + (ltr,)
f = _build_tst(expr, *args)
f.__name__ = 'test_{1}_{2}_to_{3}{0}'.format(f.__name__, *args)
frame.f_locals[f.__name__] = f
def spawn_room(room, current_map, spawn_list):
possible_targets = []
for x, y in it_product(range(room.x1, room.x2 + 1),
range(room.y1, room.y2 + 1)):
idx = current_map.xy_idx(x, y)
if current_map.tiles[idx] == TileType.FLOOR:
possible_targets.append(idx)
spawn_region(possible_targets, current_map, spawn_list)
def _chunk_split(dims, chunk_size):
# returns for each chunk its "index" as well as its actual chunk size.
if len(dims) > 0:
helper_it = it_product(*([xrange(x) for x in dims[:-1]] +
[_chunk_size_gen(dims[-1], chunk_size)]))
for i in helper_it:
yield i[:-1]+(i[-1][0],), i[-1][1]
else:
yield tuple(), 1
def check_for_greetings(sentence):
greeting_words = self.bot_data.get_greetings()
greeting_response = self.bot_data.get_greet_resp()
for word, greet in it_product(
str(sentence).split(" ")[:2], greeting_words):
if word.startswith(greet):
if len(str(sentence).split(" ")) < 2:
return 1.0, random.choice(greeting_response)
else:
return 0.6, random.choice(greeting_response)
return 0.0, None
def run_write(self, dd, chunk_size=1):
f = self.cfunc
arg_s = self.arg_structs
r = self.readers
dst = dd.element_writer(len(self.outer_dims))
for element in it_product(*[xrange(x) for x in self.outer_dims]):
for struct, reader, typ in izip(arg_s[:-1], r, self.c_types[:-1]):
self._patch(struct,
reader.read_single(element, chunk_size), typ)
with dst.buffered_ptr(element, chunk_size) as dst_buf:
self._patch(arg_s[-1], dst_buf, self.c_types[-1])
f(*arg_s)
def draw_rectangle(self, gmap, room):
'''
for y in range(room.y1, room.y2):
for x in range(room.x1, room.x2):
idx = gmap.xy_idx(x, y)
if 0 < idx < ((gmap.width * gmap.height) - 1):
gmap.tiles[idx] = TileType.FLOOR
'''
for x, y in it_product(range(room.x1, room.x2),
range(room.y1, room.y2)):
idx = gmap.xy_idx(x, y)
if 0 < idx < ((gmap.width * gmap.height) - 1):
gmap.tiles[idx] = TileType.FLOOR
def run_write(self, dd):
f = self.cfunc
arg_s = self.arg_structs
r = self.readers
dst = dd.element_writer(len(self.outer_dims))
for element in it_product(*[xrange(x) for x in self.outer_dims]):
for struct, reader in izip(arg_s[:-1], r):
struct.e0 = ctypes.cast(reader.read_single(element),
ctypes.POINTER(struct.e0._type_))
with dst.buffered_ptr(element) as buf:
arg_s[-1].e0 = ctypes.cast(buf,
ctypes.POINTER(arg_s[-1].e0._type_))
f(*arg_s)
def apply_sectionnal(self, build_data):
# New section coords
chunk_x = 0
if type(self.template.placement[0]) is not HorizontalPlacement:
print(
f'placement should be a tuple, with Horizontal as first option'
)
raise SyntaxError
elif self.template.placement[0] == HorizontalPlacement.LEFT:
chunk_x = 0
elif self.template.placement[0] == HorizontalPlacement.CENTER:
chunk_x = (build_data.map.width // 2) - (self.template.width // 2)
elif self.template.placement[0] == HorizontalPlacement.RIGHT:
chunk_x = (build_data.map.width - 1) - self.template.width
chunk_y = 0
if type(self.template.placement[1]) is not VerticalPlacement:
print(
f'placement should be a tuple, with Horizontal as first option'
)
raise SyntaxError
elif self.template.placement[1] == VerticalPlacement.TOP:
chunk_y = 0
elif self.template.placement[1] == VerticalPlacement.CENTER:
chunk_y = (build_data.map.height // 2) - (self.template.height //
2)
elif self.template.placement[1] == VerticalPlacement.BOTTOM:
chunk_y = (build_data.map.height - 1) - self.template.height
self.apply_previous_iteration(chunk_x, chunk_y, build_data)
string_vec = self.template.template
string_vec = string_vec.replace('\n', '').replace('\r', '')
'''
i = 0
for y in range(0, self.template.height):
for x in range(0, self.template.width):
if x < build_data.map.width and y < build_data.map.height:
idx = build_data.map.xy_idx(x + chunk_x, y + chunk_y)
self.char_to_map(string_vec[i], idx, build_data)
i += 1
build_data.take_snapshot()
'''
i = 0
for x, y in it_product(range(0, self.template.width),
range(0, self.template.height)):
if x < build_data.map.width and y < build_data.map.height:
idx = build_data.map.xy_idx(x + chunk_x, y + chunk_y)
self.char_to_map(string_vec[i], idx, build_data)
i += 1
build_data.take_snapshot()
def prune_init(ctrl, init_event=None):
ctrl_s = synth.determinize_machine_init(ctrl)
if init_event is not None:
try:
keys = list(set(key for (key, val) in list(init_event)))
inputsb = {env_var: ctrl.inputs[env_var] for env_var in keys}
# this allows you to give a subset of the inputs
set_in = set.union(*[
set(it_product({key}, values))
for (key, values) in inputsb.items() if not values == {0, 1}
] + [
set(it_product({key}, {True, False}))
for (key, values) in inputsb.items() if values == {0, 1}
])
if not init_event <= set_in:
raise ValueError(
'The set of initial environment values does not'
' belong to the set of inputs of the mealy machine')
for s, to, label in ctrl_s.transitions.find({'Sinit'}):
if not (set.intersection(set(label.items()),
set_in)) <= init_event:
ctrl_s.transitions.remove(s, to, attr_dict=label)
if ctrl_s['Sinit'] is None:
raise ValueError(
'The set of initial environment values does not'
' belong to the set of inputs of the mealy machine.\n'
' All initial transitions were removed.')
except ValueError as inst:
print(inst.args)
print('Determinized Mealy machine,'
' initial transitions have not been pruned.(WARNING)')
return synth.determinize_machine_init(ctrl)
return ctrl_s
def get_aoe_tiles(target, aoe_radius):
blast_tiles_idx = list()
current_map = World.fetch('current_map')
target_x, target_y = target
# idx = current_map.xy_idx(target_x, target_y)
radius = aoe_radius // 2
for x, y in it_product(range(-radius, radius + 1),
range(-radius, radius + 1)):
radius_x = target_x + x
radius_y = target_y + y
new_idx = current_map.xy_idx(radius_x, radius_y)
if not current_map.out_of_bound(new_idx):
blast_tiles_idx.append(new_idx)
return blast_tiles_idx
def draw_circle(self, gmap, room):
radius = min(room.x2 - room.x1, room.y2 - room.y1) / 2.0
center_x, center_y = room.center()
'''
for y in range(room.y1, room.y2):
for x in range(room.x1, room.x2):
idx = gmap.xy_idx(x, y)
distance = distance_to(x, y, center_x, center_y)
if 0 < idx < (gmap.width * gmap.height) - 1 and distance < radius:
gmap.tiles[idx] = TileType.FLOOR
'''
for x, y in it_product(range(room.x1, room.x2),
range(room.y1, room.y2)):
idx = gmap.xy_idx(x, y)
distance = distance_to(x, y, center_x, center_y)
if 0 < idx < (gmap.width * gmap.height) - 1 and distance < radius:
gmap.tiles[idx] = TileType.FLOOR
def build_meta_map(self, build_data):
noise = tcod.noise.Noise(
dimensions=2,
algorithm=tcod.NOISE_SIMPLEX,
implementation=tcod.noise.TURBULENCE,
hurst=0.5,
lacunarity=2.0,
octaves=4,
seed=None
)
'''
noise_areas = dict()
for y in range(0, build_data.map.height):
for x in range(0, build_data.map.width):
if build_data.map.tiles[build_data.map.xy_idx(x, y)] == TileType.FLOOR:
# score between 0.99 & 0.5 : 550 at >0.9, 1200 at >8, 0 at > 6 and 200 at < 6.
cell_value = noise.get_point(x, y)
cell_value_int = int(cell_value * 10) # so we have enought for 10 areas.
if cell_value_int not in noise_areas:
noise_areas[cell_value_int] = list()
noise_areas[cell_value_int].append(build_data.map.xy_idx(x, y))
'''
noise_areas = dict()
for x, y in it_product(range(0, build_data.map.width), range(0, build_data.map.height)):
if build_data.map.tiles[build_data.map.xy_idx(x, y)] == TileType.FLOOR:
# score between 0.99 & 0.5 : 550 at >0.9, 1200 at >8, 0 at > 6 and 200 at < 6.
cell_value = noise.get_point(x, y)
cell_value_int = int(cell_value * 10) # so we have enought for 10 areas.
if cell_value_int not in noise_areas:
noise_areas[cell_value_int] = list()
noise_areas[cell_value_int].append(build_data.map.xy_idx(x, y))
count = 0
for key, value in noise_areas.items():
print(f'area {key} - nb of points : {len(value)} idx')
count += 1
print(f'number of areas : {count}')
for area in noise_areas:
spawn_region(noise_areas[area], build_data.map, build_data.spawn_list)
def load_ascii_map(self, build_data):
string_vec = self.template.template
string_vec = string_vec.replace('\n', '').replace('\r', '')
'''
i = 0
for y in range(0, self.template.height):
for x in range(0, self.template.width):
if x < build_data.map.width and y < build_data.map.height:
idx = build_data.map.xy_idx(x, y)
self.char_to_map(string_vec[i], idx, build_data)
i += 1
if randint(1, 10) == 1:
build_data.take_snapshot()
'''
i = 0
for x, y in it_product(range(0, self.template.width),
range(0, self.template.height)):
if x < build_data.map.width and y < build_data.map.height:
idx = build_data.map.xy_idx(x, y)
self.char_to_map(string_vec[i], idx, build_data)
i += 1
if randint(1, 10) == 1:
build_data.take_snapshot()
def apply_room_vaults(self, build_data):
x = y = 0
self.apply_previous_iteration(x, y, build_data)
vault_roll = randint(1, 6)
if vault_roll < 4:
return
# placeholders
master_vault_list = [
PrefabRoom(TOTALY_NOT_A_TRAP, 5, 5, 0, 100),
PrefabRoom(SILLY_SMILE_MAP, 6, 6, 0, 100),
PrefabRoom(CHECKERBOARD_MAP, 6, 6, 0, 100)
]
# looking for a valid available vault
possible_vaults = list()
for vault in master_vault_list:
if vault.first_depth < build_data.map.depth < vault.last_depth:
possible_vaults.append(vault)
used_tiles = dict(
) # to add the tiles we overlap with one room, so we dont add another on it.
nb_vaults = randint(1, 3)
for j in range(0, nb_vaults):
if not possible_vaults:
return
if len(possible_vaults) == 1:
vault_index = 0
else:
vault_index = randint(1, len(possible_vaults)) - 1
vault = possible_vaults[vault_index]
# looking for places to put the vault.
vault_positions = list()
idx = 0
while True:
x, y = build_data.map.index_to_point2d(idx)
# in the map?
if x > 1 and (
x +
vault.width) < build_data.map.width - 2 and y > 1 and (
y + vault.height) < build_data.map.height - 2:
possible = True
for vy in range(0, vault.height):
for vx in range(0, vault.width):
idx = build_data.map.xy_idx(vx + x, vy + y)
if build_data.map.tiles[idx] is not TileType.FLOOR:
possible = False
if used_tiles.get(idx):
possible = False
if possible:
vault_positions.append((x, y))
idx += 1
if idx >= len(build_data.map.tiles) - 1:
break
# si des positions ont été trouvées
if vault_positions:
if len(vault_positions) == 1:
pos_index = 0
else:
pos_index = randint(0, len(vault_positions)) - 1
position = vault_positions[pos_index]
chunk_x, chunk_y = position
# char to map incoming
if self.template.template:
print(f'prefab vault : {self.template}')
print(
f'prefab vault : template : {self.template.template}')
string_vec = self.template.template
string_vec = string_vec.replace('\n', '').replace('\r', '')
else:
return
'''
i = 0
for y in range(0, vault.height - 1):
for x in range(0, vault.width - 1):
idx = build_data.map.xy_idx(x + chunk_x, y + chunk_y)
self.char_to_map(string_vec[i], idx, build_data)
# print(f'string vec is {string_vec} and i - 1 is : {string_vec[i - 1]}')
used_tiles[idx] = True
i += 1
build_data.take_snapshot()
'''
i = 0
for x, y in it_product(range(0, vault.width - 1),
range(0, vault.width - 1)):
idx = build_data.map.xy_idx(x + chunk_x, y + chunk_y)
self.char_to_map(string_vec[i], idx, build_data)
# print(f'string vec is {string_vec} and i - 1 is : {string_vec[i - 1]}')
used_tiles[idx] = True
i += 1
build_data.take_snapshot()
# remove spawn in spawn list where spawn in our vault
spawn_list_to_keep = deepcopy(build_data.spawn_list)
for i, (spawn_idx,
spawn_name) in enumerate(build_data.spawn_list):
x, y = build_data.map.index_to_point2d(spawn_idx)
# if x and y in vault
if chunk_x < x < chunk_x + vault.width and chunk_y < y < chunk_y + vault.height:
spawn_list_to_keep.remove(build_data.spawn_list[i])
build_data.spawn_list = spawn_list_to_keep
build_data.take_snapshot()
possible_vaults.remove(vault)
def __init__(self, config, net, data_loader, dose_loader=None, TTA_shift_by=4, offset_lists=[np.arange(-3,4)], conv=True, load_cache=True, store_cache=True, cache_dir='', evalbs=128):
"""
Prepare the class for evaluating dose distributions
:param data_loader: a data loader object that loads data from the reference dataset
:param dose_loader: a data loader object that loads a dose tensor from any dataset (e.g., predictions)
"""
# Initialize objects
self.config = config
self.data_loader = data_loader # Loads data related to ground truth patient information
self.dose_loader = dose_loader # Loads the data for a benchmark dose
self.TTA_shift_by = TTA_shift_by
# Initialize objects for later
self.patient_list = None
self.roi_mask = None
self.new_dose = None
self.reference_dose = None
self.voxel_size = None
self.possible_dose_mask = None
# Set metrics to be evaluated
self.oar_eval_metrics = ['D_0.1_cc', 'mean']
self.tar_eval_metrics = ['D_99', 'D_95', 'D_1']
# Name metrics for data frame
oar_metrics = list(it_product(self.oar_eval_metrics, self.data_loader.dataset.defdataset.rois['oars']))
target_metrics = list(it_product(self.tar_eval_metrics, self.data_loader.dataset.defdataset.rois['targets']))
# Make data frame to store dose metrics and the difference data frame
self.metric_difference_df = pd.DataFrame(index=self.data_loader.dataset.defdataset.patient_id_list,
columns=[*oar_metrics, *target_metrics])
self.reference_dose_metric_df = self.metric_difference_df.copy()
self.new_dose_metric_df = self.metric_difference_df.copy()
if net is not None:
net.eval()
with torch.no_grad():
self.preds = [np.zeros((1, 128, 128, 128)) for i in range(len(data_loader))]
for off in offset_lists:
print("Offset list: ", off)
off_id = make_offset_id(off)
CACHE_PATH = './preds/{}/{}{}'.format(config.exp_name, cache_dir, off_id)
if store_cache and not os.path.exists(CACHE_PATH):
os.makedirs(CACHE_PATH)
loaded = False
if load_cache:
if len(glob.glob(os.path.join(CACHE_PATH, '*.npy'))) != len(data_loader):
print(CACHE_PATH)
print('Not found sufficient files for loading offset {}, predicting...'.format(off_id))
else:
print('Loading offset {} from cache...'.format(off_id))
for i in range(len(data_loader)):
pat_id = os.path.basename(data_loader.dataset.data_df.loc[i, 'Id'])
curpred = np.load(os.path.join(CACHE_PATH, '{}.npy'.format(pat_id))).astype('float32')
self.preds[i] += curpred/len(offset_lists)
loaded = True
if not loaded:
evalds = EvalDataset(dose_loader.dataset, off)
evaldl = DataLoader(evalds, batch_size=1, shuffle=False, num_workers=2)
print('Making predictions from network...')
for i, img in enumerate(tqdm(evaldl)):
curpred = TTAflip(net, img[0], axis=self.config.axis, shift_by=self.TTA_shift_by, conv=conv, evalbs=evalbs)
if type(curpred) == torch.Tensor:
curpred = curpred.numpy()
curpred = np.moveaxis(curpred, 0, config.axis) # (1, 128, 128, 128)
if conv:
print('conv...')
curpred = convolve(curpred[0], gau_filter3, mode='same')[None, :]
if config.resample is not None:
voxel_sz = evaldl.dataset.ds.originalvoxelsz[i]
resampled_sz = config.resample.copy()
resampled_sz[2] = voxel_sz[0,2]
curpred = resample(curpred, np.array(resampled_sz)[None], voxel_sz[0])
if store_cache:
curpredhalf = curpred.astype('float16')
pat_id = os.path.basename(dose_loader.dataset.data_df.loc[i, 'Id'])
np.save(os.path.join(CACHE_PATH, '{}.npy'.format(pat_id)), curpredhalf)
self.preds[i] += curpred/len(offset_lists)
print('Done inference! Making metrics...')
def apply_iteration(self, build_data):
newtiles = deepcopy(build_data.map.tiles)
'''
for y in range(1, build_data.map.height - 2):
for x in range(1, build_data.map.width - 2):
idx = build_data.map.xy_idx(x, y)
neighbors = 0
if build_data.map.tiles[idx - 1] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + 1] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx - build_data.map.width] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + build_data.map.width] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx - (build_data.map.width + 1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx - (build_data.map.width - 1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + (build_data.map.width + 1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + (build_data.map.width - 1)] == TileType.WALL:
neighbors += 1
if neighbors > 4 or neighbors == 0:
newtiles[idx] = TileType.WALL
else:
newtiles[idx] = TileType.FLOOR
'''
for x, y in it_product(range(1, build_data.map.width - 2),
range(1, build_data.map.height - 2)):
idx = build_data.map.xy_idx(x, y)
neighbors = 0
if build_data.map.tiles[idx - 1] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + 1] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx -
build_data.map.width] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx +
build_data.map.width] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx - (build_data.map.width +
1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx - (build_data.map.width -
1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + (build_data.map.width +
1)] == TileType.WALL:
neighbors += 1
if build_data.map.tiles[idx + (build_data.map.width -
1)] == TileType.WALL:
neighbors += 1
if neighbors > 4 or neighbors == 0:
newtiles[idx] = TileType.WALL
else:
newtiles[idx] = TileType.FLOOR
build_data.map.tiles = deepcopy(newtiles)
build_data.take_snapshot()
def quotient_mealy(mealy, node_relation=None, relabel=False, outputs={'loc'}):
"""Returns the quotient graph of ``G`` under the specified equivalence
relation on nodes.
Parameters
----------
mealy : NetworkX graph
The graph for which to return the quotient graph with the specified node
relation.
node_relation : Boolean function with two arguments
This function must represent an equivalence relation on the nodes of
``G``. It must take two arguments *u* and *v* and return ``True``
exactly when *u* and *v* are in the same equivalence class. The
equivalence classes form the nodes in the returned graph.
unlike the original networkx.quotient_graph selfloops are maintained
relabel : Boolean
if true relabel nodes in the graph
outputs : Tells which outputs are critical and should be kept. Given as a set of strings.
"""
if node_relation is None:
node_relation = lambda u, v: mealy.states.post(u) == mealy.states.post(
v)
q_mealy = transys.MealyMachine()
q_mealy.add_inputs(mealy.inputs)
q_mealy.add_outputs(mealy.outputs)
# Compute the blocks of the partition on the nodes of G induced by the
# equivalence relation R.
if relabel:
mapping = dict(
(n, i)
for (i, n) in enumerate(equivalence_classes(mealy, node_relation)))
for (n, i) in mapping.items():
if {'Sinit'} <= set(n):
mapping[n] = 'Sinit'
q_mealy.add_nodes_from({n for (i, n) in mapping.items()})
else:
q_mealy.add_nodes_from(equivalence_classes(mealy, node_relation))
if relabel:
block_pairs = it_product(mapping.keys(), mapping.keys())
for (b, c) in block_pairs:
labels = {
frozenset([(key, label[key]) for key in mealy.inputs.keys()] +
[(output, label[output]) for output in outputs])
for (x, y, label) in mealy.transitions.find(b, c)
}
for q in labels:
q_mealy.transitions.add(mapping[b], mapping[c], **dict(q))
else:
block_pairs = it_product(q_mealy, q_mealy)
for (b, c) in block_pairs:
labels = {
frozenset([(key, label[key]) for key in mealy.inputs.keys()] +
[(output, label[output]) for output in outputs])
for (x, y, label) in mealy.transitions.find(b, c)
}
for q in labels:
q_mealy.transitions.add(b, c, **dict(q))
if relabel:
for node_eq in mapping.keys():
if any(init in node_eq for init in mealy.states.initial):
q_mealy.states.initial.add(mapping[node_eq])
else: # only initializing after relabel
for node_eq in q_mealy.nodes():
if any(init in node_eq for init in mealy.states.initial):
q_mealy.states.initial.add(node_eq)
return q_mealy
def reduce_mealy(ctrl,
outputs={'ctrl'},
relabel=False,
prune_set=None,
full=True,
combine_trans=False,
verbose=True):
""" reduce mealy machines by computing the quotient system of the maximal equivalence class
Parameters
----------
ctrl: mealy machine
outputs : Tells which outputs are critical and should be kept. Given as a set of strings.
relabel : True/False = Relabels nodes (especially needed when ctrl comes with hash like names)
prune_init : if set => try 'prune' => remove all transitions that do not belong to the set of allowed initialisations
Else determinize
"""
assert isinstance(prune_set,
set) or prune_set is None, 'prune_set is not a set'
ctrl_s = prune_init(ctrl, init_event=prune_set)
if verbose:
print('Original number of states = ' + str(len(ctrl)) + '\n' +
' number of transitions = ' +
str(len(ctrl.transitions.find())))
it_beh = True
len_last = len(ctrl_s)
while it_beh:
equiv_classes = equiv_alpha(ctrl_s, outputs)
if verbose: print('Start iterating for maximally coarse bisimulation')
it = True
# now you should iterate for maximally coarse
while it:
if verbose: print('Number of states = ' + str(len(equiv_classes)))
equiv_classes_new = iterate_equiv(equiv_classes,
ctrl_s,
outputs=outputs)
it = (len(equiv_classes_new) != len(equiv_classes))
equiv_classes = equiv_classes_new
if verbose: print('Found equivalence classes')
# now compute quotient system
equiv_dict = dict(
sum([
list(it_product(block, {i}))
for (i, block) in enumerate(equiv_classes)
], []))
node_rel = lambda u, v: equiv_dict[u] == equiv_dict[
v] # the initial relation
ctrl_s = quotient_mealy(ctrl_s,
node_relation=node_rel,
relabel=relabel,
outputs=outputs)
if full:
equiv_classes = reduce_guar_beh(ctrl_s, outputs=outputs)
equiv_dict = dict(
sum([
list(it_product(block, {i}))
for (i, block) in enumerate(equiv_classes)
], []))
node_rel = lambda u, v: equiv_dict[u] == equiv_dict[
v] # the initial relation => groups of nodes that can
# have equal next nodes
ctrl_s = quotient_mealy(ctrl_s,
node_relation=node_rel,
relabel=relabel,
outputs=outputs)
if verbose:
print('Behavioural equivalence reductions \n' +
'- number of states = ' + str(len(ctrl_s)) + '\n' +
'- number of transitions = ' +
str(len(ctrl_s.transitions.find())))
it_beh = ((len(ctrl_s) != len_last) and full)
len_last = len(ctrl_s)
if combine_trans:
ctrl_s = combine_transitions(ctrl_s)
if verbose:
print('Combine transitions \n' + '- number of states = ' +
str(len(ctrl_s)) + '\n' + '- number of transitions = ' +
str(len(ctrl_s.transitions.find())))
return ctrl_s
def transform2control(trans_sys1,
statevar='loc',
fullmodel=False,
noreach=True):
"""Transform a finite state transition system with labelled nodes to a Transition system whose nodes represent
the old edges.
Specifically the function translates TransSys1 to TransSys2:
TransSys1
* Nodes = represent locations or states, owned by environment
* Edges = control actions by system ending in a new state
TransSys2:
* Nodes = Represents a move towards a specific state (owned by environment)
* Edges = contains Arrival at state (dictated by environment) + decision to move to new state
@param trans_sys1: FiniteTransitionSystem()
@param statevar: string name of locations in trans_sys1
@param fullmodel: give two models, the transformed and simplified and the full model
"""
# - - - - Check incoming arguments - - - - - - - -
# 1 Check whether the given transition system is actually a transition system
assert isinstance(trans_sys1, transys.FiniteTransitionSystem)
from tulip.synth import _sprint_aps as print_aps
# - - - - - Function Body - - - - - - - - - - - - -
trans_sys2 = transys.FiniteTransitionSystem(
) # Define empty transition system
if trans_sys1.name is None:
trans_sys2.name = "FTS*"
else:
trans_sys2.name = trans_sys1.name + "*"
trans_sys2.atomic_propositions.add_from({'env_s'})
# trans_sys2.atomic_propositions.add_from({'env_s', 'ctrl_m'})
# tagging to who nodes in the graph belong
try: # state names are integers
for s in trans_sys1.states:
trans_sys2.states.add('%d' % s, ap={'env_s'})
if s in trans_sys1.states.initial:
trans_sys2.states.initial |= {'%d' % s}
except TypeError:
try: # state names are strings
for s in trans_sys1.states:
trans_sys2.states.add('%s' % s, ap={'env_s'})
if s in trans_sys1.states.initial:
trans_sys2.states.initial |= {'%s' % s}
except Exception:
raise logger.debug('State naming gave a failure.')
# create nodes for the existing transitions in original FTS
# and add transitions in the new FTS
for (s1, s2) in trans_sys1.transitions():
tr12 = 'm%s_%s' % (str(s1), str(s2))
trans_sys2.states.add(tr12)
trans_sys2.transitions.add('%s' % str(s1), tr12)
trans_sys2.transitions.add(tr12, '%s' % str(s2))
if s1 in trans_sys1.states.initial:
trans_sys2.states.initial |= {tr12}
# simplify the obtained two player game (sys= env_s; input =ctrl_m)
for (s_state,
label_) in trans_sys2.states.find(with_attr_dict={'ap': {'env_s'}}):
if trans_sys2.states.post(trans_sys2.states.pre(s_state)) == {s_state}:
# check whether all states with transitions that enter s_state have only transitions to s_state
logger.info('Contracting incoming transitions of state %s ' %
s_state)
trans_sys2.states.add('m%s' %
s_state) # to replace all 'm%s_%s' states
for node in trans_sys2.states.pre(s_state):
# print('transition from %s to %s' % (str(trans_sys2.states.pre(node)), s_state))
trans_sys2.transitions.add_comb(trans_sys2.states.pre(node),
{'m%s' % s_state})
if node in trans_sys2.states.initial:
trans_sys2.states.initial |= {'m%s' % s_state}
trans_sys2.states.remove(node)
# TODO : above block can be written more efficient
trans_sys2.transitions.add('m%s' % s_state, s_state)
# now the resulting FTS has
# - states owned by the control system (ctrl_m)
# whose outgoing transitions are selected by the system in the environment
# - states owned by the system(= environment system) (env_s)
# whose outgoing transitions are selected by the control system
# ---------------------------------- Reduce ----------------------------------
# for reduced Transitions system create new copy (we do this to later on
# have the option to use the original 2 play FTS)
# This only works if the original transition were deterministic
# We can check this as
assert all([(len(trans_sys2.states.pre(str(s_state))) == 1)
for s_state in trans_sys1.states()])
if noreach:
trans_red = trans_sys2.copy()
sys_safe = list(
) # list of transitions to be added to the GR(1) specification
sys_init = list()
for s_state in trans_sys1.states():
logger.info('removing state :' + str(s_state))
labels = trans_sys1.states[s_state]
_tmp = print_aps(labels, trans_sys1.ap)
for (tr_state1,
tr_state2) in it_product(trans_red.states.pre(str(s_state)),
trans_red.states.post(str(s_state))):
trans_red.transitions.add(tr_state1, tr_state2)
for tr_state in trans_red.states.pre(str(s_state)):
sys_safe += [
'((' + statevar + ' = "' + tr_state + '") -> X (' + _tmp +
'))'
]
if s_state in trans_sys1.states.initial:
_goto = ' || '.join([
'(' + statevar + ' = "' + str(x) + '" )'
for x in trans_red.states.post(str(s_state))
])
sys_init += [_tmp + ' && ' + ' ( ' + _goto + ' ) ']
trans_red.states.remove(str(s_state))
# Remove unneeded labels
trans_red.ap.remove('env_s')
# Create needed additional specifications
# - Environment variables and assumptions
env_vars = list()
env_init = list()
env_safe = list()
env_prog = list() # ['(env_actions= "' + reach + '")']
# - System variables and requirements
sys_vars = [x for x in trans_sys1.ap] # we assign the labels
# to the control system (otherwise the GR1 synthesis will blow up the control synthesis)
sys_prog = list()
gr_sys = synth.sys_to_spec(trans_red, True, statevar)
add_specs = gr_sys | spec.GRSpec(env_vars, sys_vars, env_init,
sys_init, env_safe, sys_safe,
env_prog, sys_prog)
else:
trans_red = trans_sys2.copy()
reach = 'reach'
stay = 'stay'
sys_safe = list(
) # list of transitions to be added to the GR(1) specification
sys_init = list()
trans_red.actions['env_actions'] |= {
reach, stay
} # these are the action of the environment
for s_state in trans_sys1.states():
logger.info('removing state :' + str(s_state))
labels = trans_sys1.states[s_state]
_tmp = print_aps(labels, trans_sys1.ap)
for (tr_state1,
tr_state2) in it_product(trans_red.states.pre(str(s_state)),
trans_red.states.post(str(s_state))):
trans_red.transitions.add(tr_state1,
tr_state2,
env_actions=reach)
for tr_state in trans_red.states.pre(str(s_state)):
trans_red.transitions.add(tr_state, tr_state, env_actions=stay)
sys_safe += [
'(((' + statevar + ' = "' + tr_state +
'") && X ( env_actions = "' + reach + '")) -> X (' + _tmp +
'))'
]
if s_state in trans_sys1.states.initial:
_goto = ' || '.join([
'(' + statevar + ' = "' + str(x) + '" )'
for x in trans_red.states.post(str(s_state))
])
sys_init += [_tmp + ' && ' + ' ( ' + _goto + ' ) ']
trans_red.states.remove(str(s_state))
for x in trans_sys1.ap:
sys_safe += [
'( !' + str(x) + ' & X ( env_actions = "stay")) -> ( X !' +
str(x) + ')'
]
sys_safe += [
'( ' + str(x) + ' & X ( env_actions = "stay")) -> ( X ' +
str(x) + ')'
]
# Remove unneeded labels
trans_red.ap.remove('env_s')
# Create needed additional specifications
# - Environment variables and assumptions
env_vars = list()
env_init = list()
env_safe = list()
env_prog = list() # ['(env_actions= "' + reach + '")']
# - System variables and requirements
sys_vars = [x for x in trans_sys1.ap] # we assign the labels
# to the control system (otherwise the GR1 synthesis will blow up the control synthesis)
sys_prog = list()
add_specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init,
env_safe, sys_safe, env_prog, sys_prog)
if fullmodel:
return trans_red, add_specs, trans_sys2
return trans_red, add_specs
if __name__ == '__main__':
root = logging.getLogger()
root.setLevel(logging.DEBUG)
operand_datashape = blaze.dshape('10, 10, 10, float64')
op0 = blaze.empty(operand_datashape)
op1 = blaze.empty(operand_datashape)
shape = (a.val for a in operand_datashape.shape)
from operator import add
t = time.time()
for el in it_product(*[xrange(i) for i in shape]):
val = random.uniform(-math.pi, math.pi)
factor = math.sqrt(reduce(add, [j * 10**i for i, j in enumerate(reversed(el))]))
op0[el] = math.sin(val) * factor
op1[el] = math.cos(val) * factor
logging.info("initialization took %f seconds", (time.time()-t))
expr = op0*op0 + op1*op1
eval_in_mem(expr, 0, dump_result=True)
eval_in_mem(expr, 0, dump_result=True)
eval_in_mem(expr, iter_dims=1, dump_result=True)
eval_in_mem(expr, iter_dims=1, chunk=3, dump_result=True)
eval_in_mem(expr, iter_dims=1, chunk=4, dump_result=True)
