def calculate_move_human(human, cat, net): try: matches = shortest_path(net, source=human.current_station, target=cat.current_station) except nx.NetworkXNoPath: # no path (ei. all destination station are closed) human.can_move = False return if len(matches) > 1: if net.node[matches[1]]['closed']: matches = list(all_shortest_paths(net, source=human.current_station, target=cat.current_station) ) paths = [] for path_id, sub_list in enumerate(matches): for c in sub_list: if net.node[c]['closed']: paths.append(False) break if len(paths) < path_id: paths.append(True) if True in paths: human.count_move += 1 human.current_station = matches[path_id][1] else: human.can_move = False else: human.count_move += 1 human.current_station = matches[1]
def get_shortest_paths(self, from_, to_): """get_shortest_paths :param from_ :param to """ from networkx.exception import NetworkXNoPath from networkx.algorithms import all_shortest_paths try: return self.to_json( list(all_shortest_paths(self.__graph, from_, to_, 'weight'))) except NetworkXNoPath: click.echo('No shortest paths between {} and {}'.format( from_, to_))
def generate_noisy_shortest_path_data(options): while True: num_nodes = options["num_entities"] min_path_len = options["min_path_len"] g = nx.random_graphs.connected_watts_strogatz_graph(num_nodes, 3, .5) source, target = np.random.randint(num_nodes, size=2) if source == target: continue # reject trivial paths paths = list(nxalg.all_shortest_paths(g, source=source, target=target)) if len(paths) > 1: continue # reject when more than one shortest path path = paths[0] if len(path) < min_path_len: continue # reject paths that's too short break edges = g.edges() num_confusing = options['num_confusing'] if num_confusing > 0: g_confusing = nx.random_graphs.connected_watts_strogatz_graph( num_confusing, 3, .5) for e in g_confusing.edges(): edges.append((e[0] + num_nodes, e[1] + num_nodes)) random.shuffle(edges) # randomize index idx = _generate_random_node_index(num_nodes + num_confusing) new_edges = _relabel_nodes_in_edges(edges, idx) new_path = _relabel_nodes_in_path(path, idx) for edge in new_edges: print "%s connected-to %s" % (edge[0], edge[1]) print "%s connected-to %s" % (edge[1], edge[0]) print "eval shortest-path %s %s\t%s" % (idx[source], idx[target], ",".join( [str(v) for v in new_path]))
def generate_noisy_shortest_path_data(options): while True: num_nodes = options["num_entities"] min_path_len = options["min_path_len"] g = nx.random_graphs.connected_watts_strogatz_graph(num_nodes, 3, .5) source, target = np.random.randint(num_nodes, size=2) if source == target: continue # reject trivial paths paths = list(nxalg.all_shortest_paths(g, source=source, target=target)) if len(paths) > 1: continue # reject when more than one shortest path path = paths[0] if len(path) < min_path_len: continue # reject paths that's too short break edges = g.edges() num_confusing = options['num_confusing'] if num_confusing > 0: g_confusing = nx.random_graphs.connected_watts_strogatz_graph(num_confusing, 3, .5) for e in g_confusing.edges(): edges.append((e[0] + num_nodes, e[1] + num_nodes)) random.shuffle(edges) # randomize index idx = _generate_random_node_index(num_nodes + num_confusing) new_edges = _relabel_nodes_in_edges(edges, idx) new_path = _relabel_nodes_in_path(path, idx) for edge in new_edges: print "%s connected-to %s" % (edge[0], edge[1]) print "%s connected-to %s" % (edge[1], edge[0]) print "eval shortest-path %s %s\t%s" % (idx[source], idx[target], ",".join([str(v) for v in new_path]))
def generate_shortest_path_data(options): while True: num_nodes = options["num_entities"] g = nx.random_graphs.connected_watts_strogatz_graph(num_nodes, 3, .5) source, target = np.random.randint(num_nodes, size=2) if source == target: continue # reject trivial paths paths = list(nxalg.all_shortest_paths(g, source=source, target=target)) if len(paths) > 1: continue # reject when more than one shortest path path = paths[0] break for edge in g.edges(): print "%s connected-to %s" % (edge[0], edge[1]) print "%s connected-to %s" % (edge[1], edge[0]) print "eval shortest-path %s %s\t%s" % (source, target, ",".join([str(v) for v in path]))
def generate_shortest_path_data(options): while True: num_nodes = options["num_entities"] g = nx.random_graphs.connected_watts_strogatz_graph(num_nodes, 3, .5) source, target = np.random.randint(num_nodes, size=2) if source == target: continue # reject trivial paths paths = list(nxalg.all_shortest_paths(g, source=source, target=target)) if len(paths) > 1: continue # reject when more than one shortest path path = paths[0] break for edge in g.edges(): print "%s connected-to %s" % (edge[0], edge[1]) print "%s connected-to %s" % (edge[1], edge[0]) print "eval shortest-path %s %s\t%s" % (source, target, ",".join( [str(v) for v in path]))
def find_complexSV(self): pool = [] nodes = self.graph.nodes() for n1 in nodes: for n2 in nodes: if n1 == n2: continue pre = has_path(self.graph, n1, n2) if pre: # do not consider edge weight paths = list(all_shortest_paths(self.graph, n1, n2, weight=None)) for p in paths: if not self._containloop(p): pool.append((len(p), p)) pool.sort(reverse=True) # so far, the candidate paths contain no self-loops, but are still redundant # check distance-decay for each pair of regions queue = [(self.clr, self._change_format(p[1]), self.span, self.balance_type, p[1], self.protocol) for p in pool] log.info('Filtering {0} redundant candidates ...'.format(len(queue))) jobs = Parallel(n_jobs=self.n_jobs, verbose=10)(delayed(filterAssembly)(*i) for i in queue) pre_alleles = [] for ck, p in jobs: if ck: pre_alleles.append(p) # these assembly should exist within the same allele alleles = [] for p in pre_alleles: for v in alleles: if self._issubset(p, v) or self._issubset(p, self._getreverse(v)): break else: alleles.append(p) self.alleles = alleles
def create_random_graph(type, filePath, numberOfCase, graph_scale): """ :param type: the graph type :param filePath: the output file path :param numberOfCase: the number of examples :return: """ with open(filePath, "w+") as f: degree = 0.0 for _ in range(numberOfCase): info = {} graph_node_size = graph_scale edge_prob = 0.3 while True: edge_count = 0.0 if type == "random": graph = nx.gnp_random_graph(graph_node_size, edge_prob, directed=True) for id in graph.edge: edge_count += len(graph.edge[id]) start = random.randint(0, graph_node_size - 1) adj = nx.shortest_path(graph, start) max_len = 0 path = [] paths = [] for neighbor in adj: if len(adj[neighbor]) > max_len and neighbor != start: paths = [] max_len = len(adj[neighbor]) path = adj[neighbor] end = neighbor for p in nx.all_shortest_paths(graph, start, end): paths.append(p) if len(path) > 0 and path[0] == start and len( path) == 3 and len(paths) == 1: degree += edge_count / graph_node_size break elif type == "no-cycle": graph = nx.DiGraph() for i in range(graph_node_size): nodes = graph.nodes() if len(nodes) == 0: graph.add_node(i) else: size = random.randint(1, min(i, 2)) fathers = random.sample(range(0, i), size) for father in fathers: graph.add_edge(father, i) for id in graph.edge: edge_count += len(graph.edge[id]) start = 0 end = graph_node_size - 1 path = nx.shortest_path(graph, 0, graph_node_size - 1) paths = [ p for p in nx.all_shortest_paths( graph, 0, graph_node_size - 1) ] if len(path) >= 4 and len(paths) == 1: degree += edge_count / graph_node_size break elif type == "baseline": num_nodes = graph_node_size graph = nx.random_graphs.connected_watts_strogatz_graph( num_nodes, 3, edge_prob) for id in graph.edge: edge_count += len(graph.edge[id]) start, end = np.random.randint(num_nodes, size=2) if start == end: continue # reject trivial paths paths = list( nxalg.all_shortest_paths(graph, source=start, target=end)) if len(paths) > 1: continue # reject when more than one shortest path path = paths[0] if len(path) != 4: continue degree += edge_count / graph_node_size break adj_list = graph.adjacency_list() g_ids = {} g_ids_features = {} g_adj = {} for i in range(graph_node_size): g_ids[i] = i if i == start: g_ids_features[i] = "START" elif i == end: g_ids_features[i] = "END" else: # g_ids_features[i] = str(i+10) g_ids_features[i] = str(random.randint(1, 15)) g_adj[i] = adj_list[i] # print start, end, path text = "" for id in path: text += g_ids_features[id] + " " info["seq"] = text.strip() info["g_ids"] = g_ids info['g_ids_features'] = g_ids_features info['g_adj'] = g_adj f.write(json.dumps(info) + "\n") print("average degree in the graph is :{}".format(degree / numberOfCase))