def setUp(self): self.START = 1 self.graph = Graph(self.START) self.graph.add_edge(4, 2) self.graph.add_edge(1, 2) self.graph.add_edge(1, 3) return super().setUp()
def test_predecesors(): dist, pred = Forest_apsp_PRED(graph, dist_before.copy(), prev_before.copy()) np.testing.assert_equal(True, Graph.testDistPred(dist, pred)) dist2, pred2 = ABM_Update_PRED(graph, dist_before.copy(), prev_before.copy()) np.testing.assert_equal(True, Graph.testDistPred(dist2, pred2))
def __init__(self, source=[], target=[], weight=[], directed=True): Graph.__init__(self, source, target, weight, directed) self.last_vertex_modified = np.array([]) self.node_incremental = { "node": None, "source": np.array([]), "target": np.array([]), }
def setUp(self): self.START = 2 self.graph = Graph(self.START) self.graph.add_edge(7, 4) self.graph.add_edge(1, 2) self.graph.add_edge(1, 3) self.graph.add_edge(3, 4) self.graph.add_edge(2, 5) return super().setUp()
def setUp(self): self.START = 3 self.graph = Graph(self.START) self.graph.add_edge(10, 6) self.graph.add_edge(3, 1) self.graph.add_edge(10, 1) self.graph.add_edge(3, 1) self.graph.add_edge(1, 8) self.graph.add_edge(5, 2) return super().setUp()
def generate_graph(num) -> Graph: graph = Graph(f'Graph_{num}') # product_count = random.randint(2, 10) product_count = 1000 for n in range(product_count): price = random.randint(5, 500) product_node = graph.add_node({ 'type': 'PRODUCT', 'price': price }, f'Product_{n}', node_type='PRODUCT') if with_probability(0.04): new_price_rate = rand_float(0.65, 0.8) change_node = graph.add_node( { 'type': 'CHANGE', 'old_price': price, 'new_price': price * new_price_rate, 'is_fraud': True }, f'Change_of_Prod_{n}', node_type='CHANGE', node_color='red') change_node.add_neighbor(product_node) elif with_probability(0.45): new_price_rate = rand_float(0.8, 1) change_node = graph.add_node( { 'type': 'CHANGE', 'old_price': price, 'new_price': price * new_price_rate, 'is_fraud': False }, f'Change_of_Prod_{n}', node_type='CHANGE', node_color='green') change_node.add_neighbor(product_node) # for node in graph._nodes: # link_count = random.randint(0, min(8, int(node_count / 4))) # # for _ in range(link_count): # node.add_neighbor(graph.get_random_node()) return graph
def predict(self, graph, bProba=False): """ predict the class of each node of the graph return a numpy array, which is a 1-dim array of size the number of nodes of the graph. """ [X] = self.get_lX([graph]) bConstraint = graph.getPageConstraint() traceln("\t\t #nodes=%d #edges=%d " % Graph.getNodeEdgeTotalNumber([graph])) self._computeModelCaracteristics( [X] ) #we discover here dynamically the number of features of nodes and edges traceln("\t\t %s" % self._getNbFeatureAsText()) n_jobs = self.ssvm.n_jobs self.ssvm.n_jobs = 1 if bConstraint: [Y] = self._ssvm_ad3plus_predict( [X], [graph.instanciatePageConstraints()]) else: [Y] = self.ssvm.predict([X]) self.ssvm.n_jobs = n_jobs if bProba: # do like if we return some proba. 0 or 1 actually... # similar to 1-hot encoding n = Y.shape[0] Y_proba = np.zeros((n, 2), dtype=Y.dtype) Y_proba[np.arange(n), Y] = 1.0 return Y_proba else: return Y
def create_graph_and_insert_worst_edge(self, num_nodes, directed): graph = Graph.creategraph_for_worst_escenary_edge_insert( num_nodes, directed=directed) dist = Floyd_Warshall(graph) graph.dynamic_incremental_edge_middle() return {"graph": self.export(graph), "dist": self.export_matrix(dist)}
def run_algorithm_dijkstra_apsp(self, values): graph = Graph.import_values(values) t = time() dist = Dijkstra_apsp(graph) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def run_algorithm_dijkstra(self, values, source): graph = Graph.import_values(values) t = time() dist = Dijkstra(int(source), graph) time_seconds = time() - t return self.export_algorithm([dist], time_seconds)
def run_algorithm_floyd_warshall(self, values): graph = Graph.import_values(values) t = time() dist = Floyd_Warshall(graph) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def test_three_edge(): o = Graph() # 2 nodes linked by 1 edge nf = np.array([[0, 0], [1, 11], [2, 22]]) e = np.array([[0, 1], [1, 2], [2, 0]]) ef = np.array([[-0], [-1], [-2]]) X = (nf, e, ef) Xd = o.convert_X_to_LineDual(X) nfd, ed, efd = Xd assert (nfd == ef).all() assert (ed == np.array([[0, 1], [0, 2], [1, 2]])).all(), ed assert (efd == np.array([[1, 11], [0, 0], [2, 22]])).all(), efd
def create_graph(self, num_nodes, probability_edges, directed): print("Generate. Nodes[" + str(num_nodes) + "] Edges[" + str(probability_edges) + "] Direc[" + str(directed) + "]") graph = Graph.creategraph(num_nodes, probability_edges, directed=directed) return self.export(graph)
def __init__(self, mat = [], unconn = 0): vnum = len(mat) for x in mat: if len(x) != vnum: raise ValueError("Argument for 'GraphAL'.") self._mat = [Graph._out_edges(mat[i], unconn) for i in range(vnum)] self._vnum = vnum self._unconn = unconn
def RingPerception(self): # ---------- 從 Molecule (Graph) 結構中尋找 "環(Ring)" ---------- # 其中被找到的 Ring System,被分成 Ring 與 Fused Ring, 並分別儲存 subgraphlist, ringSystem, sub_edges = [], [], [] subgraphlist = SearchBiconnectedSubgraph( self.molecule.outputAdjmatrix()) # ----------- search rings sysytem and not ring edges for subgraph in subgraphlist: if len(subgraph) > 1: ringSystem.append(subgraph) else: sub_edges.append(subgraph) # ringSystem 參數以"邊"的形式儲存 Graph 結構 # 後續演算法之建立, 皆於 Sequence 序列的形式, 故使用時需要轉換 # Ex : [[6, 3, 10, 5, 7], [6, 7, 2, 9, 4, 8]] # 轉換的方式, 使用 module 中 Graph class # ---------- ring perception ------------------ temp = [] for rings in ringSystem: # 先把 ring 轉成 Graph, 再轉成 adjacency matrix # 接著使用 adjacency matrix 來尋找最小單位元 # 注意: 此時的 output 為 index, 故需要與原本資料(ring)進行對照,並轉成ring資料中的labe g = Graph(rings) adjmx = g.output_AdjacentMatrix() temp = molCycleSearch(adjmx) # 把 index 換成 ring的資料 # temp 可能的格式如下 : # +-- 單一 ring : [ [0, 2, 3, 4, 5, 1] ] # +-- Fused Rings : [ [0, 2, 3, 4, 5, 6], [6, 5, 7, 8, 9] ] if len(temp) > 1: # ----- 為 Fused Rings 的情況 ----- for i in range(len(temp)): for j in range(len(temp[i])): temp[i][j] = list(g._graph.keys())[temp[i][j]] self.fused_rings.append(FusedRing(temp)) elif len(temp) == 1: # ----- 為單一Ring 的情況 ----- temp = temp[0] # 2D list 轉成 1D list for i in range(len(temp)): temp[i] = list(g._graph.keys())[temp[i]] self.rings.append(Ring(temp)) else: # len(temp) == 0, empty的情況, 意味著 molCycleSearch 函式找不到Cycle pass
def get_DOF_graph(self): if self.DOF_graph is None: numVertex = self.get_num_DOF_groups() graphStorage = {} self.DOF_graph = Graph(graphStorage) # create a vertex for each dof DOFs = self.get_DOFs() for tag in DOFs: dof = DOFs[tag] id1 = dof.get_ID() size = len(id1) for i in range(0, size): dofTag = id1[i] if dofTag >= AnalysisModel.START_EQN_NUM: vertex = self.DOF_graph.get_vertex(dofTag) if vertex is None: vertex = Vertex(dofTag, dofTag) if self.DOF_graph.add_vertex(vertex, False) == False: print( 'WARNING AnalysisModel::get_DOF_graph - error adding vertex.\n' ) return self.DOF_graph # now add the edges, by looping over the FE_elements, getting their IDs and adding edges between DOFs for equation numbers >= START_EQN_NUM FEs = self.get_FEs() cnt = 0 for tag in FEs: ele = FEs[tag] id1 = ele.get_ID() cnt += 1 size = len(id1) for i in range(0, size): eqn1 = id1[i] # if eqnNum of DOF is a valid eqn number add an edge to all other DOFs with valid eqn numbers. if eqn1 >= AnalysisModel.START_EQN_NUM: for j in range(i + 1, size): eqn2 = id1[j] if eqn2 >= AnalysisModel.START_EQN_NUM: self.DOF_graph.add_edge( eqn1 - AnalysisModel.START_EQN_NUM + AnalysisModel.START_VERTEX_NUM, eqn2 - AnalysisModel.START_EQN_NUM + AnalysisModel.START_VERTEX_NUM) return self.DOF_graph
def create_graph_and_decrease_random_weight(self, num_nodes, probability_edges, directed): graph = Graph.creategraph(num_nodes, probability_edges, directed=directed) dist = Floyd_Warshall(graph) graph.decrease_random_weight() return { "graph": self.export(graph), "dist": self.export_matrix(dist) }
def generate_graph() -> Tuple[Graph, pd.Series]: graph = Graph(f'Graph Node Level') node_count = 25_000 nodes_gt = pd.Series() for n in range(node_count): type = random.choice(['type-1', 'type-2', 'type-3']) node = graph.add_node({}, f'Node_{n}', node_type=type) nodes_gt._set_value(node.get_id(), type) for node in graph._nodes: link_count = random.randint(0, 2) #random.randint(0, min(7, int(node_count / 4))) for _ in range(link_count): node.add_neighbor(graph.get_random_node()) return graph, nodes_gt
def run_algorithm_forest(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = Forest_apsp(graph, np.array(matrix_distances)) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def run_algorithm_quinca(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = Quinca(graph, matrix_distances) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def run_algorithm_knnb_node_incremental(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = KNNB_Node_Incremental(graph, matrix_distances) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def run_algorithm_rr_bfs_truncated(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = Bfs_Truncated_With_Sources(graph, matrix_distances) time_seconds = time() - t return self.export_algorithm(dist, time_seconds)
def create_graph_and_incremental_edge(self, num_nodes, probability_edges, directed): graph = Graph.creategraph(num_nodes, probability_edges, directed=directed) dist = Floyd_Warshall(graph) graph.dynamic_incremental_random_edge() return {"graph": self.export(graph), "dist": self.export_matrix(dist)}
def calculate_action_incremental(self, graph: Graph, incremental: str): # graph.print_r() print(f'Action incremental {incremental} ... ') data_update = graph.action_incremental(incremental, set_action_to_graph=False) print("Added ", data_update) return data_update
def __excute_for_get_DB(self): self.connect = Connect() self.tables = self.connect.get_data() self.__get_all_data_from_table() self.graph = Graph(self.connect, self.tables) # path 구하는 class 생성 path_data = self.graph.find_path() print(path_data) result_for_stairs = self.graph.find_stair_path(path_data) send_stair_data = self.__stair_path(result_for_stairs['stair_path'], result_for_stairs['top_floor_stair_path']) print(send_stair_data) send_data = self.__result_pi_direction(path_data, result_for_stairs['floor_path_for_stair'], result_for_stairs['top_floor_path']) print(send_data) # send_data : 각각의 라즈베리파이에 대한 정보가 저장 되어있는것
def __init__(self, graph: Graph): self._graph = graph self._colors = dict() self._marked = dict() self._flage = True for v in graph.vertexes(): if self._marked.get(v) is not True: self._colors[v] = True self._search(v)
def create_graph_and_insert_worst_edge(self, num_nodes, probability_edges=0.5, directed): graph = Graph.creategraph(num_nodes, probability_edges, directed=directed) dist = Floyd_Warshall(graph) graph.insert_random_edge() return { "graph": self.export(graph), "dist": self.export_matrix(dist) }
def run_algorithm_abm(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = ABM_Update(graph, np.array(matrix_distances)) time_seconds = time() - t print("TIME ABM: ", time_seconds * 1000) return self.export_algorithm(dist, time_seconds)
def create_graph(file_stream): sources = [] targets = [] for line in file_stream: points = line.split() sources.append(int(points[0])) targets.append(int(points[1])) return Graph(sources, targets)
def run_algorithm_quinca(self, values, dist): graph = Graph.import_values(values) matrix_distances = self.import_matrix(dist) t = time() dist = Quinca(graph, np.array(matrix_distances)) time_seconds = time() - t print("TIME QUINCA: ", time_seconds * 1000) return self.export_algorithm(dist, time_seconds)
def test_weighted_chain(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,5)) self.graph.add(WeightedEdge(2,3,3)) self.graph.add(WeightedEdge(3,4,7)) self.graph.add(WeightedEdge(2,5,6)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 15) self.assertEqual(search.lp[2], 10) self.assertEqual(search.lp[3], 9) self.assertEqual(search.lp[4], 16) self.assertEqual(search.lp[5], 16)
def test_unweighted_chain(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(3,4,1)) self.graph.add(WeightedEdge(4,5,1)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 4) self.assertEqual(search.lp[2], 3) self.assertEqual(search.lp[3], 2) self.assertEqual(search.lp[4], 3) self.assertEqual(search.lp[5], 4)
def test_unweighted_basic_tree_2(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(2,4,1)) self.graph.add(WeightedEdge(2,5,1)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 2) self.assertEqual(search.lp[2], 1) self.assertEqual(search.lp[3], 2) self.assertEqual(search.lp[4], 2) self.assertEqual(search.lp[5], 2)
def test_unweighted_tree_1(self): self.graph = Graph(17) self.graph.add(WeightedEdge(1,2,2)) self.graph.add(WeightedEdge(2,3,2)) self.graph.add(WeightedEdge(2,4,2)) self.graph.add(WeightedEdge(3,12,1)) self.graph.add(WeightedEdge(12,13,1)) self.graph.add(WeightedEdge(12,14,1)) self.graph.add(WeightedEdge(12,15,1)) self.graph.add(WeightedEdge(15,16,1)) self.graph.add(WeightedEdge(15,17,2)) self.graph.add(WeightedEdge(4,5,1)) self.graph.add(WeightedEdge(4,6,1)) self.graph.add(WeightedEdge(5,7,1)) self.graph.add(WeightedEdge(5,8,2)) self.graph.add(WeightedEdge(5,9,1)) self.graph.add(WeightedEdge(6,10,2)) self.graph.add(WeightedEdge(10,11,1)) search = LongestPath(self.graph, 11, lambda x: x.cost) self.assertEqual(search.lp[1], 8) self.assertEqual(search.lp[2], 6) self.assertEqual(search.lp[3], 8) self.assertEqual(search.lp[4], 8) self.assertEqual(search.lp[5], 9) self.assertEqual(search.lp[6], 9) self.assertEqual(search.lp[7], 10) self.assertEqual(search.lp[8], 11) self.assertEqual(search.lp[9], 10) self.assertEqual(search.lp[10], 11) self.assertEqual(search.lp[11], 12) self.assertEqual(search.lp[12], 9) self.assertEqual(search.lp[13], 10) self.assertEqual(search.lp[14], 10) self.assertEqual(search.lp[15], 10) self.assertEqual(search.lp[16], 11) self.assertEqual(search.lp[17], 12)
class TestLongestPath(unittest.TestCase): def setUp(self): self.graph = Graph(5) def test_unweighted_chain(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(3,4,1)) self.graph.add(WeightedEdge(4,5,1)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 4) self.assertEqual(search.lp[2], 3) self.assertEqual(search.lp[3], 2) self.assertEqual(search.lp[4], 3) self.assertEqual(search.lp[5], 4) def test_unweighted_basic_tree_1(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(3,4,1)) self.graph.add(WeightedEdge(2,5,1)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 3) self.assertEqual(search.lp[2], 2) self.assertEqual(search.lp[3], 2) self.assertEqual(search.lp[4], 3) self.assertEqual(search.lp[5], 3) def test_unweighted_basic_tree_2(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(2,4,1)) self.graph.add(WeightedEdge(2,5,1)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 2) self.assertEqual(search.lp[2], 1) self.assertEqual(search.lp[3], 2) self.assertEqual(search.lp[4], 2) self.assertEqual(search.lp[5], 2) def test_unweighted_tree_1(self): self.graph = Graph(17) self.graph.add(WeightedEdge(1,2,1)) self.graph.add(WeightedEdge(2,3,1)) self.graph.add(WeightedEdge(2,4,1)) self.graph.add(WeightedEdge(3,12,1)) self.graph.add(WeightedEdge(12,13,1)) self.graph.add(WeightedEdge(12,14,1)) self.graph.add(WeightedEdge(12,15,1)) self.graph.add(WeightedEdge(15,16,1)) self.graph.add(WeightedEdge(15,17,1)) self.graph.add(WeightedEdge(4,5,1)) self.graph.add(WeightedEdge(4,6,1)) self.graph.add(WeightedEdge(5,7,1)) self.graph.add(WeightedEdge(5,8,1)) self.graph.add(WeightedEdge(5,9,1)) self.graph.add(WeightedEdge(6,10,1)) self.graph.add(WeightedEdge(10,11,1)) search = LongestPath(self.graph, 12, lambda x: x.cost) self.assertEqual(search.lp[1], 5) self.assertEqual(search.lp[2], 4) self.assertEqual(search.lp[3], 5) self.assertEqual(search.lp[4], 5) self.assertEqual(search.lp[5], 6) self.assertEqual(search.lp[6], 6) self.assertEqual(search.lp[7], 7) self.assertEqual(search.lp[8], 7) self.assertEqual(search.lp[9], 7) self.assertEqual(search.lp[10], 7) self.assertEqual(search.lp[11], 8) self.assertEqual(search.lp[12], 6) self.assertEqual(search.lp[13], 7) self.assertEqual(search.lp[14], 7) self.assertEqual(search.lp[15], 7) self.assertEqual(search.lp[16], 8) self.assertEqual(search.lp[17], 8) def test_unweighted_tree_1(self): self.graph = Graph(17) self.graph.add(WeightedEdge(1,2,2)) self.graph.add(WeightedEdge(2,3,2)) self.graph.add(WeightedEdge(2,4,2)) self.graph.add(WeightedEdge(3,12,1)) self.graph.add(WeightedEdge(12,13,1)) self.graph.add(WeightedEdge(12,14,1)) self.graph.add(WeightedEdge(12,15,1)) self.graph.add(WeightedEdge(15,16,1)) self.graph.add(WeightedEdge(15,17,2)) self.graph.add(WeightedEdge(4,5,1)) self.graph.add(WeightedEdge(4,6,1)) self.graph.add(WeightedEdge(5,7,1)) self.graph.add(WeightedEdge(5,8,2)) self.graph.add(WeightedEdge(5,9,1)) self.graph.add(WeightedEdge(6,10,2)) self.graph.add(WeightedEdge(10,11,1)) search = LongestPath(self.graph, 11, lambda x: x.cost) self.assertEqual(search.lp[1], 8) self.assertEqual(search.lp[2], 6) self.assertEqual(search.lp[3], 8) self.assertEqual(search.lp[4], 8) self.assertEqual(search.lp[5], 9) self.assertEqual(search.lp[6], 9) self.assertEqual(search.lp[7], 10) self.assertEqual(search.lp[8], 11) self.assertEqual(search.lp[9], 10) self.assertEqual(search.lp[10], 11) self.assertEqual(search.lp[11], 12) self.assertEqual(search.lp[12], 9) self.assertEqual(search.lp[13], 10) self.assertEqual(search.lp[14], 10) self.assertEqual(search.lp[15], 10) self.assertEqual(search.lp[16], 11) self.assertEqual(search.lp[17], 12) def test_weighted_chain(self): self.graph = Graph(5) self.graph.add(WeightedEdge(1,2,5)) self.graph.add(WeightedEdge(2,3,3)) self.graph.add(WeightedEdge(3,4,7)) self.graph.add(WeightedEdge(2,5,6)) search = LongestPath(self.graph, 1, lambda x: x.cost) self.assertEqual(search.lp[1], 15) self.assertEqual(search.lp[2], 10) self.assertEqual(search.lp[3], 9) self.assertEqual(search.lp[4], 16) self.assertEqual(search.lp[5], 16)
def setUp(self): self.graph = Graph(5)
def __init__(self, transform=None, component = None): self.component = component BaseGraph.__init__(self, transform=transform, component=component)
def __init__(self): BaseGraph.__init__(self)