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