def _generate_1edge_frequent_subgraphs(self): vlb_counter = collections.Counter() vevlb_counter = collections.Counter() vlb_counted = set() vevlb_counted = set() for g in self.graphs.values(): for v in g.vertices.values(): if (g.gid, v.vlb) not in vlb_counted: vlb_counter[v.vlb] += 1 vlb_counted.add((g.gid, v.vlb)) for to, e in v.edges.items(): vlb1, vlb2 = v.vlb, g.vertices[to].vlb if self._is_undirected and vlb1 > vlb2: vlb1, vlb2 = vlb2, vlb1 if (g.gid, (vlb1, e.elb, vlb2)) not in vevlb_counter: vevlb_counter[(vlb1, e.elb, vlb2)] += 1 vevlb_counted.add((g.gid, (vlb1, e.elb, vlb2))) # add frequent vertices. for vlb, cnt in vlb_counter.items(): if cnt >= self._min_support: g = Graph(gid=next(self._counter), is_undirected=self._is_undirected) g.add_vertex(0, vlb) self._frequent_size1_subgraphs.append(g) if self._min_num_vertices <= 1: self._report_size1(g, support=cnt) else: continue if self._min_num_vertices > 1: self._counter = itertools.count()
def create_graph(doc): G = Graph() for node in doc['network']['networkStructure']['nodes']['node']: G.add_node(node['@id'], lat=node['coordinates']['x'], lon=node['coordinates']['y']) for edge in doc['network']['networkStructure']['links']['link']: modules = [] try: for _,v in edge['additionalModules'].iteritems(): if isinstance(v,list): for e in v: m = {'capacity': e['capacity'], 'cost': e['cost']} modules.append(m) else: m = {'capacity': v['capacity'], 'cost': v['cost']} modules.append(m) except KeyError: modules = [] try: preInstalled=edge['preInstalledModule'] except KeyError: preInstalled='' G.add_edge(edge['source'], edge['target'], preInstalledModule=preInstalled, additionalModules=modules) return G
def check_if_eulerian(G: Graph): old_representation_type = G.representation_type G.change_graph_representation_to(GraphRepresentationType.ADJACENCY_LIST) old_graph_representation = copy.deepcopy(G.graph_representation) starting_vertex = 0 path = [] if(len(G.graph_representation) == 1): # graf składa się z jednego wierzchołka return True, path else: for key, l in G.graph_representation.items(): # jezeli jakis wierzcholek jest odosobniony if(len(l) == 0): return False, path last_vertex = choose_edge_and_delete(G, starting_vertex, path) is_eulerian_graph = last_vertex == starting_vertex and check_if_graph_has_no_edges(G) G.graph_representation = old_graph_representation G.change_graph_representation_to(old_representation_type) return is_eulerian_graph, path
def setUp(self): self._possible_cell_values = {1, 2, 3, 4} self._size = 4 self.graph = Graph(size=self._size, possible_values=self._possible_cell_values) self.expected_neighbours_for_0_0 = {(1, 0), (1, 1), (0, 1), (0, 2), (0, 3), (2, 0), (3, 0)}
def test_create3(): G = Graph() G.add_node(Node("test1")) G.add_node(Node('test2')) G.add_edge(Edge('test1', 'test2')) G.add_edge(Edge('test1', Node('test3'))) assert [node.name for node in G.dfs()] == ['test1', 'test2', 'test3'] assert not G.verify_edges()
def create_graph(filepath): g=Graph() with open(filepath) as csvfile: reader = csv.DictReader(csvfile) #print reader.fieldnames for row in reader: g.add_edge(row['fromNode'],row['toNode']) return g
def get_unlinked_graph(self): graph = Graph(size=self._size) graph.vertexes = {} for vertex_id in itertools.product(range(self._size), range(self._size)): graph.vertexes[vertex_id] = Vertex(self._possible_cell_values, vertex_id=vertex_id, graph=graph) return graph
def _get_samples(self): samples_map = {} derived_from_graph = Graph() project = self.manifest.get_project() for biomaterial in self.manifest.get_biomaterials(): archive_entity = ArchiveEntity() archive_entity.manifest_id = self.manifest.manifest_id archive_type = "sample" archive_entity.archive_entity_type = archive_type archive_entity.id = self.generate_archive_entity_id( archive_type, biomaterial.data) archive_entity.data = { 'biomaterial': biomaterial.data, 'project': project } archive_entity.metadata_uuids = [ biomaterial.data['uuid']['uuid'], project['uuid']['uuid'] ] archive_entity.accessioned_metadata_uuids = [ biomaterial.data['uuid']['uuid'] ] if biomaterial.derived_by_process: # TODO protocols will be needed for samples conversion # archive_entity.data.update(biomaterial.derived_with_protocols) sample_links = [] for derived_from in biomaterial.derived_from_biomaterials: derived_from_alias = self.generate_archive_entity_id( 'sample', derived_from) derived_from_graph.add_edge(derived_from_alias, archive_entity.id) sample_links.append({ 'alias': derived_from_alias, 'relationshipNature': 'derived from' }) links = {'sampleRelationships': sample_links} archive_entity.links = links samples_map[archive_entity.id] = archive_entity sorted_samples = derived_from_graph.topological_sort() priority_samples = [ samples_map.get(sample) for sample in sorted_samples if samples_map.get(sample) ] orphan_samples = [ samples_map.get(sample) for sample in samples_map.keys() if sample not in priority_samples ] return priority_samples + orphan_samples
def __init__(self, puzzle, init_graph=True): self._puzzle_array = puzzle self._size = self._puzzle_array.shape[0] self._graph = None if init_graph: self._graph = Graph( self._size, possible_values={i for i in range(1, self._size + 1)}) self._init_values()
def test_reverse_dfs1(): G = Graph() G.add_node(Node("test1")) G.add_node(Node('test2')) G.add_edge(Edge('test1', 'test2')) G.add_edge(Edge('test1', Node('test3'))) expect = ['test1', 'test2', 'test3'] assert [node.name for node in G.dfs()] == expect expect.reverse() assert [node.name for node in G.dfs(reverse=True)] == expect
def __init__(self, seed): self.rand = random.Random(seed) self.num_boxes = 4 self.boxes_on_target = 0 self.max_steps_per_episode = SOKOBAN_MAX_STEPS * SOKOBAN_BOXES_REQUIRED / self.num_boxes # Penalties and Rewards self.penalty_for_step = SOKOBAN_REWARD_PER_STEP self.penalty_box_off_target = -1 self.reward_box_on_target = 1 self.reward_finished = SOKOBAN_REWARD_SUCCESS * SOKOBAN_BOXES_REQUIRED / self.num_boxes self.reward_last = 0 # Other Settings self.action_space = 5 if SOKOBAN_OBSERVATION_FORMAT == 'grid': self.observation_space = 400 self.observation = np.zeros((10, 10, 4), dtype=np.uint8) elif SOKOBAN_OBSERVATION_FORMAT == 'factored': self.observation = Graph() self.num_factor_positions = 15 self.factor_position_offset = (self.num_factor_positions - 1) // 2 self.cell_factor_size = 0 self.cell_factor_size += 2 * (self.num_factor_positions + 1 ) # Cell position. self.cell_factor_size += 3 # Cell identity. self.cell_factor_size += 4 self.core_obs_size = self.action_space + 1 self.core_obs_size += 1 + 4 # On target, four walls. self.observation.entity_type_sizes.append(self.core_obs_size) self.observation.entity_type_sizes.append(self.cell_factor_size) self.observation_space = self.observation self.use_display = False self.num_cols_or_rows = PUZZLE_SIZE self.pix_per_cell = PUZZLE_SCALE self.wid = self.num_cols_or_rows self.x_orig = -self.wid * self.pix_per_cell / 2 self.y_orig = self.wid * self.pix_per_cell / 2 self.agent_col = None self.agent_row = None self.reset_online_test_sums() self.score = 0. self.reward = 0. self.action = None # Cell channel encodings. self.encodings = np.array( ((1, 0, 0, 0), (0, 0, 0, 0), (0, 1, 0, 0), (0, 1, 1, 0), (0, 0, 1, 0), (0, 0, 0, 1), (0, 1, 0, 1)), dtype=np.uint8) self.total_steps = 0 self.total_reward = 0. self.total_episodes = 0 self.total_episodes_won = 0.
def test_indirect_cyclic_dependency_error(self): g = Graph() g.add_edge(5, 2) g.add_edge(5, 0) g.add_edge(4, 0) g.add_edge(4, 1) g.add_edge(2, 3) g.add_edge(3, 1) with self.assertRaises(CyclicDependencyError): g.add_edge(1, 2)
def test_indirect_cyclic_dependency_error_5_levels(self): g = Graph() g.add_edge(0, 1) g.add_edge(1, 2) g.add_edge(2, 3) g.add_edge(3, 4) g.add_edge(4, 5) with self.assertRaises(CyclicDependencyError) as context: g.add_edge(5, 0) self.assertEqual([5, 0, 1, 2, 3, 4], context.exception.cycle)
def create_graph(filepath): g = Graph() with open(filepath) as csvfile: for line in csvfile: line = line.split() if line == []: continue if line[0] == '%': continue else: g.add_edge(line[0], line[1]) return g
def main(): ''' main entrance ''' start = time.time() parser = argparse.ArgumentParser( description='Find Solutions for CARP Problem\nCoded by Edward FANG') parser.add_argument('instance', type=argparse.FileType('r'), help='filename for CARP instance') parser.add_argument('-t', metavar='termination', type=int, help='termination time limit', required=True) parser.add_argument('-s', metavar='random seed', help='random seed for stochastic algorithm') args = parser.parse_args() time_limit = args.t seed = args.s instance_file = args.instance # print(time_limit, seed) spec, data = read_instance_file(instance_file) network = Graph() network.load_from_data(data.tolist()) solvers = list() solution_receiver = Queue() best_solution = bestSolution() thread1 = solution_updater(solution_receiver, best_solution) thread1.start() # multi processors processing for idx in range(N_PROCESSORS): if seed: unique_seed = seed + str(idx) else: unique_seed = None proc = Process(target=start_solver, args=(network, spec, unique_seed, solution_receiver)) solvers.append(proc) proc.start() # run_time = (time.time() - start) # start a thread for timing thread2 = Thread(target=time_up_sig, args=(time_limit, start, solvers)) thread2.daemon = True thread2.start() # exit for proc in solvers: proc.join() thread1.stop() print(str(best_solution))
def get_graph_object(graph_input): adjacency_matrix = [[0] * len(graph_input) for i in range(len(graph_input))] weights_matrix = [[0] * len(graph_input) for i in range(len(graph_input))] for vertex, neighborhood in graph_input.items(): for neighbour_vertex in neighborhood: adjacency_matrix[vertex][neighbour_vertex[0]] = 1 weights_matrix[vertex][neighbour_vertex[0]] = neighbour_vertex[1] graph = Graph(GraphRepresentationType.ADJACENCY_MATRIX, adjacency_matrix) graph.add_connection_weights_from_matrix(weights_matrix) return graph
def test_topological_sort(self): g = Graph() g.add_edge(5, 2) g.add_edge(5, 0) g.add_edge(4, 0) g.add_edge(4, 1) g.add_edge(2, 3) g.add_edge(3, 1) sorted_list = g.topological_sort() self.assertEqual([4, 5, 0, 2, 3, 1], sorted_list)
def dag_from_string2(self, raw_execplan): raw_dag = ast.literal_eval(raw_execplan) nodes = raw_dag['nodes'] n_nodes = len(nodes) g = Graph(n_nodes) g.dag_id = raw_dag['id'] g.nodes = nodes for src in raw_dag['edges']: dests = raw_dag['edges'][src] for dst in dests: g.add_edge(src, dst, 0) g.inputs = raw_dag['inputs'] g.inputSize = raw_dag['size'] g.timeValue = raw_dag['original_runtime'] g.cachedtimeValue = raw_dag['cached_runtime'] self.initialize_mrdtable(g) self.graphs[g.dag_id] = g
def _get_samples(self): samples_map = {} derived_from_graph = Graph() for biomaterial in self.manifest.get_biomaterials(): archive_entity = ArchiveEntity() archive_entity.manifest_id = self.manifest.manifest_id archive_type = "sample" archive_entity.archive_entity_type = archive_type archive_entity.id = self.generate_archive_entity_id( archive_type, biomaterial.data) archive_entity.data = {'biomaterial': biomaterial.data} if biomaterial.derived_by_process: # TODO protocols will be needed for samples conversion # archive_entity.data.update(biomaterial.derived_with_protocols) derived_from_alias = self.generate_archive_entity_id( 'sample', biomaterial.derived_from) derived_from_graph.add_edge(derived_from_alias, archive_entity.id) links = { 'sampleRelationships': [{ 'alias': derived_from_alias, 'relationshipNature': 'derived from' }] } archive_entity.links = links samples_map[archive_entity.id] = archive_entity sorted_samples = derived_from_graph.topological_sort() priority_samples = [ samples_map.get(sample) for sample in sorted_samples if samples_map.get(sample) ] orphan_samples = [ samples_map.get(sample) for sample in samples_map.keys() if sample not in priority_samples ] return priority_samples + orphan_samples
def test_topological_sort_for_strings(self): g = Graph() g.add_edge('donor', 'specimen') g.add_edge('specimen', 'cell_suspension') sorted_list = g.topological_sort() self.assertEqual(['donor', 'specimen', 'cell_suspension'], sorted_list)
def to_graph(self, gid=VACANT_GRAPH_ID, is_undirected=True): """Construct a graph according to the dfs code.""" g = Graph(gid, is_undirected=is_undirected, eid_auto_increment=True) for dfsedge in self: frm, to, (vlb1, elb, vlb2) = dfsedge.frm, dfsedge.to, dfsedge.vevlb if vlb1 != VACANT_VERTEX_LABEL: g.add_vertex(frm, vlb1) if vlb2 != VACANT_VERTEX_LABEL: g.add_vertex(to, vlb2) g.add_edge(AUTO_EDGE_ID, frm, to, elb) return g
def _process_data(self, data): for key, _data in data.items(): file_name = _data["image_file"] # image = Image.open(file_name).convert('L') image = Image.open(file_name) width, height = image.size labels = [] vertexes = [] for text, bbox_for_train, key_type, formal_key in zip( _data["texts"], _data["bboxes"], _data["keys_type"], _data["formal_keys"]): # construct the label = [] if formal_key in self.key_index: label.append(self.key_index[formal_key]) if key_type == 'key': label.append(self.key_index[formal_key] * 2 - 1) elif key_type == 'value': label.append(self.key_index[formal_key] * 2) else: label.append(0) else: label.append(0) label.append(0) labels.append(label) # resize the bounding box bbox_for_train[0] = bbox_for_train[0] / width bbox_for_train[1] = bbox_for_train[1] / height bbox_for_train[2] = bbox_for_train[2] / width bbox_for_train[3] = bbox_for_train[3] / height bag_of_words = to_bag_of_words(text, 0, self.tok_to_id, self.blank_idx) vertexes.append(np.hstack((bbox_for_train, bag_of_words))) # construct the graph input_bboxs = _data["input_bboxes"] graph = Graph(input_bboxs) N = len(input_bboxs) A = graph.adj[:N, :, :N] _data["A"] = A _data["labels"] = np.array(labels) _data["image"] = 0 _data["image_size"] = (width, height) _data["vertexes"] = np.array(vertexes)
def _define_graph(self, residual_connections=[]): self.layers[0].input_edges[INPUTS_NAME] = None self.layers[-1].output_edges[GRADIENTS_NAME] = None node_connections = [(self.layers[idx], self.layers[idx + 1], (INPUTS_NAME, GRADIENTS_NAME)) for idx in range(0, len(self.layers) - 1)] node_connections += residual_connections self._graph = Graph(node_connections)
def create_graph(self) -> None: ''' Metoda tworząca graf pełny z przypisanymi wagami. Lista krawędzi tego grafu jest odrazu posortowana rosnąco. ''' vertices = self.create_vertices_dict() edges = self.create_edges() edges = sorted(edges, key=lambda edge: edge.weight) self.graph = Graph(vertices, edges)
def generate_Gnp_graph(number_of_vertexes: int, probability: float): matrix = [[0 for i in range(number_of_vertexes)] for j in range(number_of_vertexes)] for i in range(number_of_vertexes): for j in range(number_of_vertexes): if j < i and randint(0, 100) < probability * 100: matrix[i][j] = 1 matrix[j][i] = matrix[i][j] graph = Graph(GraphRepresentationType.ADJACENCY_MATRIX, matrix) return graph
def _read_graphs(self): self.graphs = dict() with codecs.open(self._database_file_name, 'r', 'utf-8') as f: lines = [line.strip() for line in f.readlines()] tgraph, graph_cnt = None, 0 for i, line in enumerate(lines): cols = line.split(' ') if cols[0] == 't': if tgraph is not None: self.graphs[graph_cnt] = tgraph graph_cnt += 1 tgraph = None if cols[-1] == '-1' or graph_cnt >= self._max_ngraphs: break tgraph = Graph(graph_cnt, is_undirected=self._is_undirected, eid_auto_increment=True) elif cols[0] == 'v': tgraph.add_vertex(cols[1], cols[2]) elif cols[0] == 'e': tgraph.add_edge(AUTO_EDGE_ID, cols[1], cols[2], cols[3]) # adapt to input files that do not end with 't # -1' if tgraph is not None: self.graphs[graph_cnt] = tgraph return self
def print_dijkstra(G: Graph, s): old_representation = G.representation_type graph.change_graph_representation_to( GraphRepresentationType.ADJACENCY_MATRIX) p_s, d_s = dijkstra(G, s) w = G.graph_weights G.print_graph_representation() G.print_weights() print("\nSTART: s =", s) for v in range(len(p_s)): path = [] print('d({}) = {:>4} ===> '.format(v, d_s[v]), end='') currNode = v path.append(currNode) while p_s[currNode] != None: currNode = p_s[currNode] path.append(currNode) path = path[::-1] # reversing print(path) plot_graph(graph) G.change_graph_representation_to(old_representation)
def debug_graph(self, node_types=None): g = Graph() if node_types is None: node_types = self.gndef.node_types for nt in node_types: for i, data in enumerate(self.inits[nt]): n = g.node((nt, i)) n.color = nt.color n.label = "{}\n{}\n{}".format(nt.name, i, data) n.shape = "box" for at, values in self.arcs.items(): if at.source_nt not in node_types or at.target_nt not in node_types: continue for s, t in values: sn = g.node_get((at.source_nt, s)) tn = g.node_get((at.target_nt, t)) a = sn.add_arc(tn) return g
def generate_Gnl_graph(number_of_vertexes: int, number_of_edges: int): possible_edges = list(itertools.combinations(range(number_of_vertexes), 2)) count_of_possible_edges = len(possible_edges) if count_of_possible_edges > number_of_edges: return Graph( GraphRepresentationType.ADJACENCY_MATRIX, create_adjacency_matrix_from_edges_list(possible_edges, number_of_vertexes, number_of_edges)) else: raise Exception( "{} of edges is too large with this number of vertexes - max = {}". format(number_of_edges, count_of_possible_edges))
def test_direct_cyclic_dependency_error_for_strings(self): g = Graph() g.add_edge('donor', 'specimen') with self.assertRaises(CyclicDependencyError) as context: g.add_edge('specimen', 'donor') self.assertEqual(['specimen', 'donor'], context.exception.cycle)
def find_cell_color(g, cells): """ Color the cells depending on the cell connections. Each group of cells that are connected (either directly by a shared face or through a series of shared faces of many cells) is are given different colors. c_1-c_3 c_4 / c_7 | | \ c_2 c_5 In this case, cells c_1, c_2, c_3 and c_7 will be given color 0, while cells c_4 and c_5 will be given color 1. Parameters: ---------- g - Grid for which the cells belong cells - indecies of cells (=np.array([1,2,3,4,5,7]) for case above) """ c = np.sort(cells) # Local cell-face and face-node maps. cf_sub, _ = __extract_submatrix(g.cell_faces, c) child_cell_ind = np.array([-1] * g.num_cells, dtype=np.int) child_cell_ind[c] = np.arange(cf_sub.shape[1]) # Create a copy of the cell-face relation, so that we can modify it at # will cell_faces = cf_sub.copy() # Direction of normal vector does not matter here, only 0s and 1s cell_faces.data = np.abs(cell_faces.data) # Find connection between cells via the cell-face map c2c = cell_faces.transpose() * cell_faces # Only care about absolute values c2c.data = np.clip(c2c.data, 0, 1).astype('bool') graph = Graph(c2c) graph.color_nodes() return graph.color[child_cell_ind[cells]]