def plot_start_config(g, ref, v_searchers: list, v_target: list):
"""Plot my graph and show me where the searchers started"""
g.vs["color"] = "green"
start_searcher = ext.get_python_idx(v_searchers)
start_target = ext.get_python_idx(v_target)
for st in start_searcher:
g.vs[st]["color"] = "blue"
for st in start_target:
g.vs[st]["color"] = "red"
layout = g.layout("kk")
name_file = "G" + ref + ".pdf"
plot(g, name_file, layout=layout, bbox=(300, 300), margin=20)
def get_level_color(self, my_level):
idx = None
if isinstance(my_level, int):
idx = ext.get_python_idx(my_level)
elif isinstance(my_level, str):
id_aux = self.get_level_value(my_level)
idx = ext.get_python_idx(id_aux)
else:
return idx
my_color = self.level_color[idx]
return my_color
def set_v0_danger(self):
my_eta = [1, 0, 0, 0, 0]
my_z = 1
my_H = [1, 1, 1, 1, 1]
for v in self.v0:
vidx = ext.get_python_idx(v)
# true value
self.eta[vidx] = my_eta
self.z[vidx] = my_z
self.H[vidx] = my_H
# a priori
self.eta0_0[vidx] = my_eta
self.z0_0[vidx] = my_z
self.H0_0[vidx] = my_H
# look up
self.lookup_eta_hat[vidx] = my_eta
self.lookup_z_hat[vidx] = my_z
self.lookup_H_hat[vidx] = my_H
# estimate at t = 0
if len(self.eta_hat) > 0:
self.eta_hat[vidx] = my_eta
self.z_hat[vidx] = my_z
self.H_hat[vidx] = my_H
else:
pass
if len(self.eta_hat) == 0:
self.set_hat_0()
return
def test_conditional_table():
g, deadline, d_list = get_param()
danger = MyDanger(g, deadline)
value = dict([((1, 1), []), ((3, 3), []), ((5, 3), [])])
value[(1, 1)] = [0.96, 0.01, 0.01, 0.01, 0.01]
value[(3, 3)] = [0.01, 0.25, 0.49, 0.24, 0.01]
value[(5, 3)] = [0.01, 0.01, 0.01, 0.35, 0.62]
for i in [1, 3, 5]:
if i == 5:
j = 3
else:
j = i
my_row = danger.get_row_eta(i, j)
for k in [1, 2, 3, 4, 5]:
k_idx = ext.get_python_idx(k)
my_prob = value[(i, j)][k_idx]
# check get_eta function
assert danger.get_eta(i, j, k) == my_prob
# check get_list_eta function
assert my_row[k] == my_prob
# check p_zf
assert danger.p_zf[(i, j)][k_idx] == my_prob
# check p_zfd
assert danger.p_zfd[(i, j, k)] == my_prob
def adjust_threshold(self, specs):
""""List of threshold of alive searchers"""
kappa = []
alpha = []
# not adjusted for team size
self.kappa_original = specs.kappa
self.alpha_original = specs.alpha
for s_original in self.S_original:
idx = ext.get_python_idx(s_original)
if self.is_alive(s_original, self.alive):
kappa.append(self.kappa_original[idx])
alpha.append(self.alpha_original[idx])
self.kappa = kappa
self.alpha = alpha
# set thresholds of only of those alive
specs.set_threshold(self.kappa, 'kappa')
specs.set_threshold(self.alpha, 'alpha')
return specs
def adjust_team(self):
"""adjust lists based on current positions"""
# list of alive searchers
alive = []
# list of killed searchers (either danger or stuck)
killed = []
# alive searchers current positions
current_pos = []
for s in self.S_original:
s_idx = ext.get_python_idx(s)
v = self.input_pos[s_idx]
# if it already died (v = -1 or v = -2), don't count with it
if v < 0:
killed.append(s)
self.id_map.append((s, -1))
else:
alive.append(s)
current_pos.append(v)
# new id
s_new = len(current_pos)
self.id_map.append((s, s_new))
# for new ids, assemble dict current_pos = {s: v}
self.dict_pos[s_new] = v
return alive, killed, current_pos
def get_true(self, v: int):
"""Return true danger values for that vertex"""
v_idx = ext.get_python_idx(v)
eta_hat = self.lookup_eta_hat[v_idx]
z_hat = self.lookup_z_hat[v_idx]
return eta_hat, z_hat
def get_priori(self, v: int):
v_idx = ext.get_python_idx(v)
z0 = self.z0_0[v_idx]
eta0 = self.eta0_0[v_idx]
H0_0 = self.H0_0[v_idx]
return eta0, z0, H0_0
def get_from_lookup(self, v: int):
# get level for that vertex (eta_hat)
v_idx = ext.get_python_idx(v)
eta_hat = self.lookup_eta_hat[v_idx]
z_hat = self.lookup_z_hat[v_idx]
H_hat = self.lookup_H_hat[v_idx]
return eta_hat, z_hat, H_hat
def list_to_dict(data: list):
n = len(data)
V = ext.get_set_vertices(n)[0]
data_dict = {}
for v in V:
vidx = ext.get_python_idx(v)
data_dict[v] = data[vidx]
return data_dict
def init_hazard(self, h0):
"""Assign level value for each v at t = 0"""
for v in self.V:
# h is an integer
if isinstance(h0, int):
h = h0
# h is a list with values for each vertex
else:
v_idx = ext.get_python_idx(v)
h = h0[v_idx]
self.set_v_value(v, h, 0)
def set_thresholds(self, kappa: list, alpha: list):
"""Set danger threshold for all searchers"""
self.kappa = kappa
self.alpha = alpha
for s_id in self.S:
s_idx = ext.get_python_idx(s_id)
k = kappa[s_idx]
a = alpha[s_idx]
s = self.searchers[s_id]
s.set_kappa(k)
s.set_alpha(a)
def get_vertex_hat(self, v: int):
"""Retrieve estimated danger for that vertex
if perception point -- retrieve z
if perception prob -- retrieve eta"""
v_idx = ext.get_python_idx(v)
if self.perception == self.options[0]:
# point
my_hat = self.lookup_z_hat[v_idx]
else:
# probabilistic
my_hat = self.lookup_eta_hat[v_idx]
return my_hat
def compute_frequentist(xi: dict, op=1):
"""P(L=l) = sum_{I, C} xi/sum{L,I,C}
xi[v] = [i1, i2,...], i1 = [l1, l2, l3, l4, l5]"""
n_l = 5
V = [v for v in xi.keys()]
L = list(range(1, n_l + 1))
# pt estimate
z_hat = []
# probabilities
eta_hat = []
for v in V:
# scores for this node
level_points = [0 for i in range(5)]
all_points = 0.0
# for each image data
for img in xi[v]:
# sum of all level points
sum_all = 0
for level in L:
l_idx = ext.get_python_idx(level)
# points for that level
xi_level = img[l_idx]
# for that vertex
level_points[l_idx] += xi_level
sum_all += xi_level
all_points += sum_all
# normalize for all points
eta_v = [round(el * (1 / all_points), 4) for el in level_points]
z_v = MyDanger.z_from_eta(eta_v, op)
# estimates
eta_hat.append(eta_v)
# point estimate
z_hat.append(z_v)
return eta_hat, z_hat
def plot_graph(self, z_t: dict, t: int):
"""z_t: dict z[v] v= 1,...n"""
# get graph layout
g = self.g
my_layout = g.layout("grid")
folder_path = self.whole_path
for v in self.V:
v_idx = ext.get_python_idx(v)
my_color = self.get_level_color(z_t[v])
# assign color
g.vs[v_idx]["color"] = my_color
name_file = folder_path + "/" + self.type + "_t" + str(t) + ".png"
# name_fig = self.type + "_t" + str(t) + ".png"
plot(g, name_file, layout=my_layout, figsize=(3, 3), bbox=(400, 400), margin=15, dpi=400)
return name_file
def set_param_vertices(self):
"""Set evolution parameters for each v, u
Call this after setting xi_mu, xi_sigma , lbda_mu, lbda_sigma"""
# number of vertices
n = self.n
my_samples = ext.get_sample_normal(n, self.xi_mu, self.xi_sigma)
for v in self.V:
v_idx = ext.get_python_idx(v)
# coefficient of cell evolution
self.xi[v] = my_samples[v_idx]
# coefficient of spread
for u in self.V:
# check to see if its not filled already
if self.lbda[v][u] is None:
my_lambda = ext.get_sample_normal(1, self.lbda_mu, self.lbda_sigma)
self.lbda[v][u] = my_lambda[0]
self.lbda[u][v] = my_lambda[0]
def organize_table(self):
"""Build matrix structure ijk
i -> smoke levels
j -> fire levels
k -> danger levels"""
# smoke (hazard 1)
for i in self.z.levels:
# fire (hazard 2)
for j in self.f.levels:
# check if it's empty
if self.no_eta(i, j):
continue
else:
# danger levels
for k in self.levels:
k_idx = ext.get_python_idx(k)
self.p_zfd[(i, j, k)] = self.p_zf[(i, j)][k_idx]
# dictionary (i, j, k)
return self.p_zfd
def plot_graph(self, d_t: dict, t: int, var='danger'):
"""z_t: dict z[v] v= 1,...n"""
folder_path = self.whole_path
# if var == 'danger':
# d = self.get_H_t(t)
# print(d)
# print('name_file t_' + str(t))
for v in self.V:
v_idx = ext.get_python_idx(v)
my_level = d_t[v]
my_color = rpf.match_level_color(my_level)
# if v == 1:
#
# print('t = ' + str(t))
# print('color: ' + str(my_color))
# print('level = ' + str(d_t[v]))
# assign color
self.g.vs[v_idx]["color"] = my_color
name_file = folder_path + "/" + var + "_t" + str(t) + ".png"
time.sleep(0.1)
plot(self.g,
name_file,
layout='grid',
figsize=(5, 5),
bbox=(600, 600),
margin=20,
dpi=400,
vertex_size=40)
return name_file
def create_graph(n: int, edges: list, base_name: str):
"""Create iGraph based on
:param n : number of vertices
:param edges : list of connections, python index: [(0, 1), (1,2)...]
:param base_name : """
# create new graph
g = Graph(directed=False)
g.add_vertices(n)
# make sure it's indexed right
v1 = [e[0] for e in edges]
v2 = [e[1] for e in edges]
if min(v1) > 0 or min(v2) > 0:
edges = [(e[0] - 1, e[1] - 1) for e in edges]
g.add_edges(edges)
V = ext.get_set_vertices(g)[0]
# label starting at 1
g.vs["label"] = V
# find shortest path length between any two vertices
short_paths = g.shortest_paths_dijkstra()
g["path_len"] = short_paths
# find neighbors to each vertex
for v in V:
vidx = ext.get_python_idx(v)
nei = g.neighbors(vidx)
g.vs[vidx]["neighbors"] = nei
# name graph
g["name"] = base_name
return g
def get_z(self, v: int):
# get level for that vertex (z_true)
v_idx = ext.get_python_idx(v)
true_level = self.z[v_idx]
return true_level
def get_eta(self, v: int):
# get level for that vertex (z_true)
v_idx = ext.get_python_idx(v)
eta = self.eta[v_idx]
return eta
def get_H(self, v: int):
v_idx = ext.get_python_idx(v)
true_H = self.H[v_idx]
return true_H
def get_zhat(self, v: int):
# get level for that vertex (z_hat)
v_idx = ext.get_python_idx(v)
level_hat = self.z_hat[v_idx]
return level_hat
def get_H_for_level(H_v, level):
level_idx = ext.get_python_idx(level)
H_l = H_v[level_idx]
return H_l
def get_etahat(self, v: int):
# get level for that vertex (eta_hat)
v_idx = ext.get_python_idx(v)
eta_hat = self.eta_hat[v_idx]
return eta_hat
def get_Hhat(self, v: int):
# get H for that vertex (H_hat)
v_idx = ext.get_python_idx(v)
H_hat = self.H_hat[v_idx]
return H_hat
