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)
