def ring(num_vtx=100, k=2, p=0.0):
g = Graph(directed=False)
vtx = list(g.add_vertex(num_vtx))
# connect neighbors
for i in vtx:
for j in xrange(1, k + 1):
dest = g.vertex((g.vertex_index[i] - j) % num_vtx)
if g.edge(i, dest) is None:
g.add_edge(i, dest)
# redirect edges
# old_edges = list(g.edges())
old_edges = [(x.source(), x.target()) for x in g.edges()]
for i in old_edges:
n = random.random()
if n < p: # redirect edge; choose random vertex as new destination
vtx_tmp = vtx[:]
vtx_tmp.remove(i[1])
if i[0] in vtx_tmp:
vtx_tmp.remove(i[0])
dest = random.choice(vtx_tmp)
while g.edge(i[0], dest) is not None:
vtx_tmp.remove(dest)
dest = random.choice(vtx_tmp)
g.remove_edge(g.edge(i[0], i[1]))
g.add_edge(i[0], dest)
return g
class RoadMap(object):
def __init__(self, mapfile):
self._mapfile = mapfile
self.DIRECTION_index = 6
self.PATHCLASS_index = 20
self.g = Graph()
self.g.edge_properties["length"] = self.g.new_edge_property("double")
self.g.edge_properties["level"] = self.g.new_edge_property("int")
self.g.vertex_properties["pos"] = self.g.new_vertex_property("vector<double>")
self.cross_pos_index = {}
def load(self):
if self._mapfile[-3:] != 'shp':
self.g = load_graph(self._mapfile)
return
try:
sf = shapefile.Reader(self._mapfile)
except Exception as e:
print(str(e))
return False
roads_records = sf.shapeRecords() # 获取路段信息'
for road_record in roads_records:
cross_s_index = self.add_cross(road_record.shape.points[0])
cross_e_index = self.add_cross(road_record.shape.points[-1])
self.add_road_edge(cross_s_index, cross_e_index, road_record)
if int(road_record.record[self.DIRECTION_index]) == 0: # 若路段是双向车道
self.add_road_edge(cross_e_index, cross_s_index, road_record)
return True
def has_edge(self, s_vertex, e_vertex):
if self.g.num_vertices() >= max(s_vertex, e_vertex):
return self.g.edge(s_vertex, e_vertex)
else:
return None
def add_cross(self, cross_pos):
if cross_pos in self.cross_pos_index:
return self.cross_pos_index.get(cross_pos)
else:
cross_index = self.g.add_vertex()
self.g.vp.pos[cross_index] = cross_pos
self.cross_pos_index[cross_pos] = cross_index
return cross_index
def add_road_edge(self, s_vertex, e_vertex, road):
if self.has_edge(s_vertex, e_vertex):
return self.g.edge(s_vertex, e_vertex)
else:
edge = self.g.add_edge(s_vertex, e_vertex)
self.g.ep.level[edge] = int(road.record[self.PATHCLASS_index])
self.g.ep.length[edge] = self.road_length(road)
return edge
@staticmethod
def road_length(road):
length = 0
for sub_road in zip(road.shape.points[:-1], road.shape.points[1:]):
length += distance.euclidean(sub_road[0], sub_road[1])
return length
def shortest_path_cover_logn_apx(g: gt.Graph, weight: gt.EdgePropertyMap):
started_with_directed = g.is_directed()
if not g.is_directed():
reversed_edges = np.fliplr(g.get_edges())
g.set_directed(True)
g.add_edge_list(reversed_edges)
weight.a[-reversed_edges.shape[0]:] = weight.a[:reversed_edges.
shape[0]]
if weight.value_type() not in [
"bool", "int", "int16_t", "int32_t", "int64_t"
]:
#min = np.min(weight.a)
#min_second = np.min(weight.a[weight.a > min])
eps = 1 #min_second - min
scaled_weight = (np.ceil(weight.a / eps) *
(g.num_vertices() + 1)).astype(np.int) # ints >= 1
else:
scaled_weight = weight.a * (g.num_vertices() + 1)
summed_edge_weight = np.sum(scaled_weight)
adjusted_weight = g.new_edge_property("long", vals=scaled_weight - 1)
paths = []
covered_vertices = set()
while len(covered_vertices) != g.num_vertices():
curr_paths = shortest_path_visiting_most_nodes(g, adjusted_weight,
covered_vertices,
summed_edge_weight)
for path in curr_paths:
paths.append(path)
#if len(path) <= 2 switch to fast mode and just add single edges/vertices until done.
path_vertices = set(path)
for v in path_vertices.difference(covered_vertices):
for w in g.get_in_neighbors(v):
adjusted_weight[g.edge(w, v)] += 1 #.a[list()] -= 1
if adjusted_weight[g.edge(
w, v)] % (g.num_vertices() + 1) != 0:
exit(5)
new_covered = path_vertices.difference(covered_vertices)
covered_vertices = covered_vertices.union(path_vertices)
print(len(new_covered), len(path), len(covered_vertices), path)
if not started_with_directed:
g.set_directed(False)
for e in reversed_edges:
g.remove_edge(g.edge(e[0], e[1]))
return paths
def s2(g: gt.Graph, weight_prop: gt.EdgePropertyMap, labels, budget=20):
L = set()
n = g.num_vertices()
known_labels = -np.ones(n) * np.inf
W = gt.topology.shortest_distance(g, weights=weight_prop).get_2d_array(
range(n)) #original distance map
x = np.random.choice(list(set(range(n)).difference(L)))
while budget > 0:
known_labels[x] = labels[x]
L.add(x)
if len(L) == n:
break
budget -= 1
to_remove = []
for e in g.get_out_edges(x):
if known_labels[e[1]] >= 0 and known_labels[
e[1]] != known_labels[x]:
to_remove.append(e)
for e in to_remove:
g.remove_edge(g.edge(e[0], e[1]))
#mid_point = mssp(g, weight_prop, L, known_labels)
if False:
x = int(mid_point)
else:
x = np.random.choice(list(set(range(n)).difference(L)))
return label_propagation(W, known_labels, np.unique(labels))
def g():
g = Graph(directed=True)
g.add_vertex(4)
g.add_edge_list([(0, 1), (1, 0), (1, 3), (3, 1), (0, 2), (2, 0), (2, 3),
(3, 2)])
weights = g.new_edge_property('float')
weights[g.edge(0, 1)] = 0.9
weights[g.edge(1, 0)] = 0.7
weights[g.edge(1, 3)] = 0.8
weights[g.edge(3, 1)] = 0.2
weights[g.edge(2, 3)] = 0.4
weights[g.edge(3, 2)] = 0.3
weights[g.edge(0, 2)] = 0.1
weights[g.edge(2, 0)] = 0.4
g.edge_properties['weights'] = weights
return g
def score_solution(q: gt.Graph, a: gt.Graph, solution):
# Archive graph A
# query graph Q
# Solution = list of tuples, length |G|, e.g. (1,3),(2,8),(3,12)
solution_score = 0
sol_dict = {}
sol_dict_new = {}
q_original = original_vp(q)
a_original = original_vp(a)
q_o = dict_from_property_map(q, q_original)
a_o = dict_from_property_map(a, a_original)
q_v_map = vp_map(q, 'nValue')
a_v_map = vp_map(a, 'nValue')
q_e_map = ep_map(q, 'eValue')
a_e_map = ep_map(a, 'eValue')
# Current impl simply adds 1 for each matching node or edge
for s in solution: # s should be a tuple e.g. (1,3)
q_node, a_node = s
if q_node in q_o and a_node in a_o:
solution_score += q_v_map[q_o[q_node]] == a_v_map[a_o[a_node]]
sol_dict[q_node] = a_node
sol_dict_new[q_o[q_node]] = a_o[a_node]
for e_q in q.edges():
u_q, v_q = e_q
if u_q in sol_dict_new and v_q in sol_dict_new:
edges_a = a.edge(sol_dict_new[u_q],
sol_dict_new[v_q],
all_edges=True)
for e_a in edges_a:
if q_e_map[e_q] == a_e_map[e_a]:
u_a, v_a = e_a
solution_score += 1
u1 = q_original[u_q]
v1 = q_original[v_q]
u2 = a_original[u_a]
v2 = a_original[v_a]
sol_dict[(u1, v1)] = (u2, v2)
break
return sol_dict, solution_score
def simplicial_vertices(g: gt.Graph):
'''
returns the (unweighted, undirected) simplicial vertices of g
'''
simplicial_vertices = []
for v in g.vertices():
#try to find a clique around v
#TODO: Replace with numpy style
for x, y in itertools.combinations(g.get_all_neighbors(v), 2):
if g.edge(x, y) is None:
break
else:
simplicial_vertices.append(int(v))
#print(len(g.get_all_neighbors(v)))
return simplicial_vertices
def s2(g: graph_tool.Graph,
weight_prop: graph_tool.EdgePropertyMap,
labels,
budget=20,
use_adjacency=False):
L = set()
n = g.num_vertices()
known_labels = -np.ones(n) * np.inf
W = graph_tool.topology.shortest_distance(
g, weights=weight_prop).get_2d_array(range(n)) #original distance map
x = np.random.choice(list(set(range(n)).difference(L)))
while budget > 0:
known_labels[x] = labels[x]
L.add(x)
if len(L) == n:
break
budget -= 1
to_remove = []
for e in g.get_out_edges(x):
if known_labels[e[1]] > -np.inf and known_labels[
e[1]] != known_labels[x]:
to_remove.append(e)
for e in to_remove:
g.remove_edge(g.edge(e[0], e[1]))
mid_point = mssp(g, weight_prop, L, known_labels)
if mid_point is not None:
x = int(mid_point)
else:
x = np.random.choice(list(set(range(n)).difference(L)))
prediction = label_propagation(W,
known_labels,
labels,
use_adjacency=use_adjacency)
print("accuracy", np.sum(prediction == labels) / labels.size)
def gnp(n, e):
'''
Return an Erdos-renyi graph with n vertices and e edges
'''
g = Graph(directed=False)
g.add_vertex(n)
edgesAdded = 0
edgesNeeded = True
while edgesNeeded:
fromNode = range(n); toNode = range(n);
np.random.shuffle(fromNode)
np.random.shuffle(toNode)
for i in xrange(n):
if fromNode[i] == toNode[i] or g.edge(fromNode[i], toNode[i]) != None: continue #No self-loops or parallel edges
g.add_edge(fromNode[i], toNode[i])
edgesAdded += 1
if edgesAdded >= e:
edgesNeeded = False
break
generation.random_rewire(g, model="erdos")
return g
def parse_graph_from_string(self, graphML_string):
dom = minidom.parseString(graphML_string)
root = dom.getElementsByTagName("graphml")[0]
graph = root.getElementsByTagName("graph")[0]
name = graph.getAttribute('id')
g = Graph(directed=False)
vpos=g.new_vertex_property("vector<double>")
for node in graph.getElementsByTagName("node"):
id=node.getAttribute('id')
n = g.add_vertex()
g.vertex_index[id]
#right now only the positions are available
for attr in node.getElementsByTagName("data"):
if attr.firstChild:
key=attr.getAttribute("key")
#n[key] = attr.firstChild.data
if(key=="x"):
x=attr.firstChild.data
elif(key=="y"):
y=attr.firstChild.data
vpos[id]=(x,y)
g.vertex_properties["pos"]=vpos
#have to workaround the directed graph written by the server
for edge in graph.getElementsByTagName("edge"):
source = edge.getAttribute('source')
dest = edge.getAttribute('target')
edge=g.edge(dest,source)
if(edge==None):
e = g.add_edge(source, dest)
return g
class GraphAdapter(AdapterBase):
def __init__(
self,
seed_str,
name,
file_extension='gml',
vertex_schema={
'gene': 'vector<bool>',
'gen': 'int',
'fitness': 'vector<long>',
'score': 'long'
},
edge_schema={
'label': 'string',
'gen': 'int'
}):
self.seed = seed_str
self.name = name
self.file_extension = file_extension
self.graph = Graph()
# Create graph properties
self.graph.gp.labels = self.graph.new_gp('vector<string>')
self.graph.gp.labels = [seed_str]
self.graph.gp.name = self.graph.new_gp('string')
self.graph.gp.name = self.name
# Create vertex properties
for key in vertex_schema:
self.graph.vp[key] = self.graph.new_vp(vertex_schema[key])
# Create edge properties
for key in edge_schema:
self.graph.ep[key] = self.graph.new_ep(edge_schema[key])
def add_node(self, gene, gen=0, attrs={}):
v = self.graph.add_vertex()
self.graph.vp.gene[v] = gene
self.graph.vp.gen[v] = gen
self.set_props(v, attrs)
return self.graph.vertex_index[v]
def add_edge(self, TAG, srcID, destID, attrs={}):
e = self.graph.add_edge(srcID, destID)
self.graph.ep.label[e] = TAG
for key in attrs:
self.graph.ep[key][e] = attrs[key]
return self.graph.edge_index[e]
def getNode(self, nodeID):
return self.graph.vertex(nodeID)
def getEdge(self, edgeID):
return self.graph.edge(edgeID)
def fetchIndividual(self, individual):
targets = graph_tool.util.find_vertex(self.graph, self.graph.vp.gene,
individual)
# find the last node, the one with highest `gen`
if targets:
# guaranteed to be in order!!
return self.graph.vertex_index[targets[-1]]
else:
return None
def walk_edge(self, TAG, startID):
pass
def update_fitness(self, nodeID, fitness):
v = self.graph.vertex(nodeID)
self.set_props(v, {'fitness': fitness})
def update_score(self, nodeID, score):
v = self.graph.vertex(nodeID)
self.set_props(v, {'score': score})
def set_props(self, v, attrs):
for key in attrs:
self.graph.vp[key][v] = attrs[key]
def save(self):
filename = os.path.join('graphs',
self.name) + '.' + self.file_extension
self.graph.save(filename)
return filename
def numNodes(self):
return self.graph.num_vertices()
class ob_viz(QWidget):
def __init__(self, bg_color):
QWidget.__init__(self)
self.background_color = bg_color
self.c = 0
# K = 0.5
# how many iterations the realignment is supposed to take
self.step = 15
self.rwr_c = 0
# dumper([qt_coords])
dumper(['obv viz init'])
# self.show()
# with open("/tmp/eaf3.csv", "a") as fo:
# wr = csv.writer(fo)
# wr.writerow([self.c, "runs4"])
# dumper([self.c, "runs4"])
# self.node_names [g_id[i] for i in g.vertices()]
def init2(self, emacs_var_dict):
self.emacs_var_dict = emacs_var_dict
self.link_str = self.emacs_var_dict['links']
self.g = Graph()
self.label_ep = self.g.new_edge_property("string")
self.links = self.link_str.split(";")
link_tpls = [i.split(" -- ") for i in self.links]
dumper([str(i) for i in link_tpls])
self.g_id = self.g.add_edge_list(link_tpls,
hashed=True,
string_vals=True,
eprops=[self.label_ep])
self.adj = np.array([(int(i.source()), int(i.target()))
for i in self.g.edges()])
self.node_names = [self.g_id[i] for i in self.g.vertices()]
self.vd = {}
for i in self.g.vertices():
self.vd[self.g_id[i]] = int(i)
# self.pos_vp = sfdp_layout(self.g, K=0.5)
self.pos_vp = fruchterman_reingold_layout(self.g)
self.base_pos_ar = self.pos_vp.get_2d_array((0, 1)).T
self.qt_coords = self.nolz_pos_ar(self.base_pos_ar)
dumper([str(self.qt_coords)])
# dumper([link_str])
def update_graph(self, emacs_var_dict):
"""set new links and nodes"""
new_link_str = emacs_var_dict['links']
new_links = new_link_str.split(";")
new_link_tpls = [i.split(" -- ") for i in new_links]
links_to_add = list(set(new_links) - set(self.links))
links_to_del = list(set(self.links) - set(new_links))
# setting new stuff
self.links = new_links
new_nodes = []
for tpl in new_link_tpls:
new_nodes.append(tpl[0])
new_nodes.append(tpl[1])
new_nodes_unique = list(set(new_nodes))
nodes_to_del = list(set(self.node_names) - set(new_nodes_unique))
nodes_to_add = list(set(new_nodes_unique) - set(self.node_names))
dumper([
"nodes_to_add: ", nodes_to_add, "nodes_to_del: ", nodes_to_del,
"links_to_add: ", links_to_add, "links_to_del: ", links_to_del
])
# first add nodes + index them, but not there yet (first links)
for n in nodes_to_add:
dumper(['adding node'])
v = self.g.add_vertex()
# how to new nodes pos to parents? separate loop afterwards
self.vd[n] = int(v)
self.g_id[v] = n
del_node_ids = [self.vd[i] for i in nodes_to_del]
self.g.remove_vertex(del_node_ids)
# have to reindex after deletion
self.vd = {}
for i in self.g.vertices():
self.vd[self.g_id[i]] = int(i)
dumper(['node deleted'])
# nodes_to_del_id =
# dumper(['old nodes deleted, add new links'])
for l in links_to_add:
tpl = l.split(" -- ")
n0, n1 = tpl[0], tpl[1]
self.g.add_edge(self.vd[n0], self.vd[n1])
# dumper(['new links added, delete old links'])
for l in links_to_del:
tpl = l.split(" -- ")
n0 = tpl[0]
n1 = tpl[1]
dumper([list(self.vd.keys())])
# only remove edge when neither of nodes removed
if n0 in self.vd.keys() and n1 in self.vd.keys():
self.g.remove_edge(self.g.edge(self.vd[n0], self.vd[n1]))
# dumper(['graph modifications done'])
# set positions of new nodes to parent nodes
for n in nodes_to_add:
v = self.g.vertex(self.vd[n])
v_prnt = list(v.all_neighbors())[0]
self.pos_vp[v] = self.pos_vp[v_prnt]
# dumper(['node positions adjusted'])
self.adj = np.array([(int(i.source()), int(i.target()))
for i in self.g.edges()])
self.node_names = [self.g_id[i] for i in self.g.vertices()]
# dumper(['storage objects updated'])
# dumper(["nbr_edges new: ", str(len([i for i in self.g.edges()]))])
# dumper(['nodes_to_add'] + nodes_to_add)
# seems to work
dumper(['to here'])
self.recalculate_layout()
dumper(['to here2'])
def recalculate_layout(self):
"""calculate new change_array, set rwr_c counter"""
dumper(['recalculating starting'])
self.base_pos_ar = self.pos_vp.get_2d_array((0, 1)).T
# set_dict = {'p': 2, 'max_level': 20, 'adaptive_cooling': False,
# 'gamma': 1, 'theta': 1, 'cooling_step': 0.3, 'C': 0.6, 'mu_p': 1.2}
# self.goal_vp = sfdp_layout(self.g, K=0.5, pos=self.pos_vp, **set_dict)
self.goal_vp = fruchterman_reingold_layout(self.g, pos=self.pos_vp)
goal_ar = self.goal_vp.get_2d_array([0, 1]).T
self.chng_ar = (goal_ar - self.base_pos_ar) / self.step
self.rwr_c = self.step
dumper(["base_pos_ar: ", self.base_pos_ar])
dumper(["goal_ar: ", goal_ar])
dumper(["chng_ar: ", self.chng_ar])
dumper(['recalculating done'])
def redraw_layout(self):
"""actually do the drawing, run multiple (step (rwr_c)) times"""
self.cur_pos_ar = np.round(
self.base_pos_ar + self.chng_ar * (self.step - self.rwr_c), 3)
self.qt_coords = self.nolz_pos_ar(self.cur_pos_ar)
self.rwr_c -= 1
self.update()
# dumper(['redrawing'])
# def draw_arrow(qp, p1x, p1y, p2x, p2y):
def draw_arrow(self, qp, p1x, p1y, p2x, p2y, node_width):
"""draw arrow from p1 to rad units before p2"""
# get arrow angle, counterclockwise from center -> east line
# dumper(['painting time'])
angle = degrees(atan2((p1y - p2y), (p1x - p2x)))
# calculate attach point
arw_goal_x = p2x + node_width * cos(radians(angle))
arw_goal_y = p2y + node_width * sin(radians(angle))
# calculate start point: idk how trig works but does
start_px = p1x - node_width * cos(radians(angle))
start_py = p1y - node_width * sin(radians(angle))
# arrow stuff: +/- 30 deg
ar1 = angle + 25
ar2 = angle - 25
arw_len = 10
# need to focus on vector from p2 to p1
ar1_x = arw_goal_x + arw_len * cos(radians(ar1))
ar1_y = arw_goal_y + arw_len * sin(radians(ar1))
ar2_x = arw_goal_x + arw_len * cos(radians(ar2))
ar2_y = arw_goal_y + arw_len * sin(radians(ar2))
# qp.drawLine(p1x, p1y, p2x, p2y)
# qp.drawLine(p1x, p1y, arw_goal_x, arw_goal_y)
qp.drawLine(start_px, start_py, arw_goal_x, arw_goal_y)
qp.drawLine(ar1_x, ar1_y, arw_goal_x, arw_goal_y)
qp.drawLine(ar2_x, ar2_y, arw_goal_x, arw_goal_y)
def paintEvent(self, event):
# dumper(['start painting'])
node_width = 10
qp = QPainter(self)
edges = [(self.qt_coords[i[0]], self.qt_coords[i[1]])
for i in self.adj]
# dumper([str(i) for i in edges])
qp.setPen(QPen(Qt.green, 2, Qt.SolidLine))
# [qp.drawLine(e[0][0], e[0][1], e[1][0], e[1][1]) for e in edges]
[
self.draw_arrow(qp, e[0][0], e[0][1], e[1][0], e[1][1],
(node_width / 2) + 5) for e in edges
]
qp.setPen(QColor(168, 34, 3))
# qp.setPen(Qt.green)
qp.setFont(QFont('Decorative', 10))
[
qp.drawText(t[0][0] + node_width, t[0][1], t[1])
for t in zip(self.qt_coords, self.node_names)
]
# dumper(['done painting'])
qp.setPen(QPen(Qt.black, 3, Qt.SolidLine))
# qp.setBrush(QBrush(Qt.green, Qt.SolidPattern))
dumper(['painting nodes'])
for i in zip(self.qt_coords, self.node_names):
if self.emacs_var_dict['cur_node'] == i[1]:
qp.setPen(QPen(Qt.black, 4, Qt.SolidLine))
qp.drawEllipse(i[0][0] - (node_width / 2),
i[0][1] - (node_width / 2), node_width,
node_width)
qp.setPen(QPen(Qt.black, 3, Qt.SolidLine))
else:
qp.drawEllipse(i[0][0] - (node_width / 2),
i[0][1] - (node_width / 2), node_width,
node_width)
# qp.drawEllipse(self.c, self.c, 7, 7)
# qp.end()
def nolz_pos_ar(self, pos_ar_org):
"""normalize pos ar to window limits"""
# pos_ar_org = goal_ar
size = self.size()
limits = [[20, size.width() - 50], [20, size.height() - 20]]
x_max = max(pos_ar_org[:, 0])
x_min = min(pos_ar_org[:, 0])
y_max = max(pos_ar_org[:, 1])
y_min = min(pos_ar_org[:, 1])
# need linear maping function again
pos_ar2 = pos_ar_org
pos_ar2[:, 0] = (((pos_ar2[:, 0] - x_min) / (x_max - x_min)) *
(limits[0][1] - limits[0][0])) + limits[0][0]
pos_ar2[:, 1] = (((pos_ar2[:, 1] - y_min) / (y_max - y_min)) *
(limits[1][1] - limits[1][0])) + limits[1][0]
return (pos_ar2)
class BaseGraph(object):
"""
Class representing a graph. We do not use pure graph_tool.Graph for we want
to be able to easily change this library. Neither we use inheritance
as graph_tool has inconvenient licence.
"""
def __init__(self):
self._g = None
self._node_dict = {}
self._syn_to_vertex_map = None
self._lemma_to_nodes_dict = None
self._lu_on_vertex_dict = None
def use_graph_tool(self):
"""
Returns underlying graph_tool.Graph. It should be avoided at all costs.
"""
return self._g
def get_node_for_synset_id(self, syn_id):
"""
Lazy function to makes the map of synset identifiers to nodes into
the graph. The building of map is made only on the first funcion call.
The first and the next calls of this function will return the built map.
"""
if not self._syn_to_vertex_map:
self._syn_to_vertex_map = {}
for node in self.all_nodes():
if node.synset:
synset_id = node.synset.synset_id
self._syn_to_vertex_map[synset_id] = node
return self._syn_to_vertex_map.get(syn_id, None)
def pickle(self, filename):
self._g.save(filename)
def unpickle(self, filename):
self._g = load_graph(filename)
def init_graph(self, drctd=False):
self._g = Graph(directed=drctd)
def copy_graph_from(self, g):
self._g = g._g.copy()
def set_directed(self, drctd):
self._g.set_directed(drctd)
def is_directed(self):
return self._g.is_directed()
def merge_graphs(self, g1, g2):
self._g = graph_union(g1._g, g2._g, internal_props=True)
# Node operations:
def all_nodes(self):
for node in self._g.vertices():
yield BaseNode(self._g, node)
def create_node_attribute(self, name, kind, value=None):
if not self.has_node_attribute(name):
node_attr = self._g.new_vertex_property(kind, value)
self._g.vertex_properties[name] = node_attr
def create_node_attributes(self, node_attributes_list):
for attr in node_attributes_list:
if not self.has_node_attribute(attr[0]):
node_attr = self._g.new_vertex_property(attr[1])
self._g.vertex_properties[attr[0]] = node_attr
def has_node_attribute(self, name):
""" Checks if a node attribute already exists """
return name in self._g.vertex_properties
def delete_node_attribute(self, name):
""" Delete node attribute """
del self._g.vertex_properties[name]
def add_node(self, name, node_attributes_list=None):
if node_attributes_list is None:
node_attributes_list = []
if name not in self._node_dict:
new_node = self._g.add_vertex()
self._node_dict[name] = BaseNode(self._g, new_node)
for attr in node_attributes_list:
self._g.vertex_properties[attr[0]][new_node] = attr[1]
return self._node_dict[name]
def get_node(self, name):
return self._node_dict[name]
def remove_node(self, name):
self._g.remove_vertex(self._node_dict[name]._node)
del self._node_dict[name]
def nodes_filter(self,
nodes_to_filter_set,
inverted=False,
replace=False,
soft=False):
"""
Filters out nodes from set
Args:
nodes_to_filter_set (Iterable): Nodes which fill be filtered out.
inverted (bool): If True, nodes NOT in set will be filtered out.
Defaults to False.
replace (bool): Replace current filter instead of combining the two.
Defaults to False.
soft (bool): Hide nodes without removing them so they can be restored
with reset_nodes_filter. Defaults to False.
"""
predicate = lambda node: node not in nodes_to_filter_set
self.nodes_filter_conditional(predicate, inverted, replace, soft)
def nodes_filter_conditional(self,
predicate,
inverted=False,
replace=False,
soft=False):
"""
Filters node based on a predicate
Args:
predicate (Callable): Predicate returning False for nodes that should be
filtered out.
inverted (bool): Invert condition. Defaults to False.
replace (bool): Replace current filter instead of combining the two.
Defaults to False.
soft (bool): Hide nodes without removing them so they can be restored
with reset_nodes_filter. Defaults to False.
"""
(old_filter, old_inverted) = self._g.get_vertex_filter()
new_filter = self._g.new_vertex_property("bool")
for node in self.all_nodes():
kept = predicate(node) != inverted
if not replace and old_filter:
old_kept = bool(old_filter[node._node]) != old_inverted
kept = kept and old_kept
new_filter[node._node] = kept
self._g.set_vertex_filter(new_filter, False)
if not soft:
self.apply_nodes_filter()
def apply_nodes_filter(self):
""" Removes nodes that are currently filtered out """
self._g.purge_vertices()
def reset_nodes_filter(self):
""" Clears node filter """
self._g.set_vertex_filter(None)
# Edge operations:
def num_edges(self):
return self._g.num_edges()
def all_edges(self):
for e in self._g.edges():
yield BaseEdge(self._g, e)
def get_edges_between(self, source, target):
"""
Return all edges between source and target. Source and target can be either
BaseNode or integer.
"""
if isinstance(source, BaseNode):
source = source._node
if isinstance(target, BaseNode):
target = target._node
for e in self._g.edge(source, target, all_edges=True):
yield BaseEdge(self._g, e)
def get_edge(self, source, target, add_missing=False):
"""
Return some edge between source and target. Source and target can be either
BaseNode or integer.
"""
if isinstance(source, BaseNode):
source = source._node
if isinstance(target, BaseNode):
target = target._node
e = self._g.edge(source, target, add_missing)
if e is not None:
return BaseEdge(self._g, e)
else:
return None
def create_edge_attribute(self, name, kind, value=None):
if not self.has_edge_attribute(name):
edge_attr = self._g.new_edge_property(kind, value)
self._g.edge_properties[name] = edge_attr
def alias_edge_attribute(self, name, alias):
self._g.edge_properties[alias] = self._g.edge_properties[name]
def create_edge_attributes(self, edge_attributes_list):
for attr in edge_attributes_list:
if not self.has_edge_attribute(attr[0]):
edge_attr = self._g.new_edge_property(attr[1])
self._g.edge_properties[attr[0]] = edge_attr
def has_edge_attribute(self, name):
""" Checks if an edge attribute already existst """
return name in self._g.edge_properties
def delete_edge_attribute(self, name):
""" Delete edge attribute """
del self._g.edge_properties[name]
def add_edge(self, parent, child, edge_attributes_list=None):
if edge_attributes_list is None:
edge_attributes_list = []
new_edge = self._g.add_edge(parent._node, child._node)
for attr in edge_attributes_list:
self._g.edge_properties[attr[0]][new_edge] = attr[1]
return BaseEdge(self._g, new_edge)
def edges_filter(self, edges_to_filter_set):
edge_filter = self._g.new_edge_property("bool")
for e in self.all_edges():
if e in edges_to_filter_set:
edge_filter[e._edge] = False
else:
edge_filter[e._edge] = True
self._g.set_edge_filter(edge_filter)
self._g.purge_edges()
def ungraph_tool(self, thingy, lemma_on_only_synset_node_dict):
"""
Converts given data structure so that it no longer have any graph_tool dependencies.
"""
logger = logging.getLogger(__name__)
if type(thingy) == dict:
return {
self.ungraph_tool(k, lemma_on_only_synset_node_dict):
self.ungraph_tool(thingy[k], lemma_on_only_synset_node_dict)
for k in thingy
}
nodes_to_translate = set()
for vset in lemma_on_only_synset_node_dict.values():
for v in vset:
nodes_to_translate.add(v)
if type(thingy) == gt.PropertyMap:
dct = {}
if thingy.key_type() == 'v':
for node in nodes_to_translate:
dct[node] = thingy[node.use_graph_tool()]
elif thingy.key_type() == 'e':
for edge in self.all_edges():
dct[edge] = thingy[edge.use_graph_tool()]
else:
logger.error('Unknown property type %s', thingy.key_type())
raise NotImplemented
return dct
def generate_lemma_to_nodes_dict_synsets(self):
"""
This method generates a utility dictionary, which maps lemmas to
corresponding node objects. It is expensive in menas of time
needed to generate the dictionary. It should therefore be executed
at the beginning of the runtime and later its results should be reused
as many times as needed without re-executing the function.
"""
lemma_to_nodes_dict = defaultdict(set)
for node in self.all_nodes():
try:
lu_set = node.synset.lu_set
except KeyError:
continue
for lu in lu_set:
lemma = lu.lemma.lower()
lemma_to_nodes_dict[lemma].add(node)
self._lemma_to_nodes_dict = lemma_to_nodes_dict
def generate_lemma_to_nodes_dict_lexical_units(self):
"""
This method generates a utility dictionary, which maps lemmas to
corresponding node objects. It is expensive in menas of time
needed to generate the dictionary. It should therefore be executed
at the beginning of the runtime and later its results should be reused
as many times as needed without re-executing the function.
"""
lemma_to_nodes_dict = defaultdict(set)
for node in self.all_nodes():
try:
lemma = node.lu.lemma.lower()
lemma_to_nodes_dict[lemma].add(node)
except:
continue
self._lemma_to_nodes_dict = lemma_to_nodes_dict
@property
def lemma_to_nodes_dict(self):
return self._lemma_to_nodes_dict
def _make_lu_on_v_dict(self):
"""
Makes dictionary lu on vertex
"""
lu_on_vertex_dict = defaultdict(set)
for node in self.all_nodes():
try:
nl = node.lu
except Exception:
continue
if nl:
lu_on_vertex_dict[node.lu.lu_id] = node
self._lu_on_vertex_dict = lu_on_vertex_dict
class MapGraph(object):
def __init__(self):
self.g = Graph()
self.dvertex_index = dict()
self.vertex_label = self.g.new_vertex_property("string")
self.g.vertex_properties["label"] = self.vertex_label
self.edge_weight = self.g.new_edge_property("int")
self.g.edge_properties["weight"] = self.edge_weight
def has_vertex(self, label):
"""返回index"""
return self.dvertex_index.get(label)
def has_edge(self, s_label, e_label):
s_vertex = self.dvertex_index.get(s_label)
e_vertex = self.dvertex_index.get(e_label)
if s_vertex and e_vertex:
return self.g.edge(s_vertex, e_vertex)
else:
return None
def add_edge(self, s_label, e_label):
if self.has_edge(s_label, e_label):
return self.g.edge(s_label, e_label)
s_vertex = self.add_vertex(s_label)
e_vertex = self.add_vertex(e_label)
return self.g.add_edge(s_vertex, e_vertex)
def add_vertex(self, label):
"""如果点存在则直接返回节点索引号"""
if self.dvertex_index.get(label):
return self.dvertex_index.get(label)
v = self.g.add_vertex()
self.vertex_label[v] = label
self.dvertex_index[label] = v
return v
def add_edge_weight(self, s_label, e_label, weight):
if self.has_edge(s_label, e_label):
self.edge_weight[self.g.edge(s_label, e_label)] += weight
else:
edge = self.add_edge(s_label, e_label)
self.edge_weight[edge] = weight
@classmethod
def networkx_to_graph_tool(cls, nx_g):
gt_g = MapGraph()
for e in nx_g.edges():
gt_g.add_edge_weight(e[0], e[1], nx_g[e[0]][e[1]]["weight"])
return gt_g
def all_paths(self, s_label, e_label):
if self.has_vertex(s_label) and self.has_vertex(e_label):
time_s = time.time()
s_vertex = self.dvertex_index.get(s_label)
e_vertex = self.dvertex_index.get(e_label)
for path in all_paths(
self.g,
s_vertex,
e_vertex,
cutoff=shortest_distance(self.g, s_vertex, e_vertex) *
1.5):
if time.time() - time_s > 60 * 10:
break
yield path
counter = 0
for seed_edge in src.out_edges():
if g.ep.edge_flow[seed_edge] == 1:
counter += 1
for i in range(counter):
path = []
current = src
path.append(src)
s.push(src)
while (not(current == tgt)) and (not(s.isEmpty())):
for edge in current.out_edges():
if g.ep.edge_flow[edge] == 1 and g.ep.residual_capacity[edge] == 1:
s.push(edge.target())
current = s.pop()
g.ep.residual_capacity[g.edge(path[-1], current)] = 0
g.ep.residual_capacity[g.edge(current, path[-1])] = 0
path.append(current)
paths.append(path)
s.allClear()
temp_list = []
for each_path in paths:
temp_list.append([int(x) for x in each_path])
frequency_n_paths[g.gp.layer_name] = temp_list
paths = []
max_flow = sum(g.ep.edge_flow[e] for e in tgt.in_edges())
# In[28]:
edges = list(zip(df['u'].as_matrix(), df['v'].as_matrix()))
# In[29]:
g.add_edge_list(edges)
# In[30]:
# add
edges_iter = list(g.edges())
for e in tqdm(edges_iter):
u, v = int(e.source()), int(e.target())
if g.edge(v, u) is None:
g.add_edge(v, u)
# In[31]:
weight = g.new_edge_property('float')
weight.set_value(EPS)
# In[32]:
for i, r in tqdm(df.iterrows(), total=df.shape[0]):
u, v, w = int(r['u']), int(r['v']), r['w']
weight[g.edge(u, v)] = w
g.edge_properties['weights'] = weight
# In[33]:
