def vytvořím_graph_tool_graf():
from graph_tool.all import Graph
graf = Graph()
u1 = graf.add_vertex()
u2 = graf.add_vertex()
graf.add_edge(u1, u2)
vprop_double = graf.new_vertex_property("double") # Double-precision floating point
vprop_double[graf.vertex(1)] = 3.1416
vprop_vint = graf.new_vertex_property("vector<int>") # Vector of ints
vprop_vint[graf.vertex(0)] = [1, 3, 42, 54]
eprop_dict = graf.new_edge_property("object") # Arbitrary python object. In this case, a dictionary.
eprop_dict[graf.edges().next()] = {"foo": "bar", "gnu": 42}
gprop_bool = graf.new_graph_property("bool") # Boolean
gprop_bool[graf] = True
graf.save('./data/graph_tool.graphml', fmt='xml')
def gen_graph((repo, events)):
graph = Graph()
repo_on_graph = graph.new_graph_property('string')
repo_on_graph[graph] = repo
graph.graph_properties['repo_on_graph'] = repo_on_graph
language_on_graph = graph.new_graph_property('string')
language_on_graph[graph] = events[0]['language']
graph.graph_properties['language_on_graph'] = language_on_graph
events_on_vertices = graph.new_vertex_property('object')
graph.vertex_properties['events_on_vertices'] = events_on_vertices
actors_on_vertices = graph.new_vertex_property('string')
graph.vertex_properties['actors_on_vertices'] = actors_on_vertices
weights_on_edges = graph.new_edge_property('long double')
graph.edge_properties['weights_on_edges'] = weights_on_edges
# pre_vertices = []
pre_events_map = {}
pre_vertices_map = {}
owner_vertex = graph.add_vertex()
owner = repo.split('/')[0]
dummy_event = {'created_at': events[0]['repo-created_at']}
actors_on_vertices[owner_vertex] = owner
events_on_vertices[owner_vertex] = dummy_event
pre_vertices_map[owner] = owner_vertex
pre_events_map[owner] = dummy_event
events = sorted(events, key=lambda x: x['created_at'])
for event in events:
actor = event['actor']
if actor in pre_events_map:
continue
created_at = event['created_at']
vertex = graph.add_vertex()
events_on_vertices[vertex] = event
actors_on_vertices[vertex] = actor
# if 'actor-following' not in event:
# continue
following = set(event['actor-following'])
commons = following.intersection(pre_vertices_map.keys())
# pre_vertices.append(vertex)
# if len(commons) == 0:
# edge = graph.add_edge(vertex, owner_vertex)
# weights_on_edges[edge] = 1.0
for pre_actor in commons:
interval =\
(created_at - pre_events_map[pre_actor]['created_at']).days
if interval < 0:
continue
edge = graph.add_edge(vertex, pre_vertices_map[pre_actor])
if pre_actor == owner:
weight = 1.0
else:
weight = 1.0 / fib(interval + 2)
weights_on_edges[edge] = weight
pre_events_map[actor] = event
pre_vertices_map[actor] = vertex
return graph
def gen_graph((repo, events)):
graph = Graph()
repo_on_graph = graph.new_graph_property('string')
repo_on_graph[graph] = repo
graph.graph_properties['repo_on_graph'] = repo_on_graph
language_on_graph = graph.new_graph_property('string')
language_on_graph[graph] = events[0]['language']
graph.graph_properties['language_on_graph'] = language_on_graph
events_on_vertices = graph.new_vertex_property('object')
graph.vertex_properties['events_on_vertices'] = events_on_vertices
actors_on_vertices = graph.new_vertex_property('string')
graph.vertex_properties['actors_on_vertices'] = actors_on_vertices
weights_on_edges = graph.new_edge_property('long double')
graph.edge_properties['weights_on_edges'] = weights_on_edges
# pre_vertices = []
pre_events_map = {}
pre_vertices_map = {}
# owner_vertex = graph.add_vertex()
# owner = repo.split('/')[0]
# actors_on_vertices[owner_vertex] = owner
# pre_vertices_map[owner] = owner_vertex
events = sorted(events, key=lambda x: x['created_at'])
for event in events:
actor = event['actor']
if actor in pre_events_map:
continue
created_at = event['created_at']
vertex = graph.add_vertex()
events_on_vertices[vertex] = event
actors_on_vertices[vertex] = actor
if 'actor-following' not in event:
continue
following = set(event['actor-following'])
commons = following.intersection(pre_vertices_map.keys())
# pre_vertices.append(vertex)
# if len(commons) == 0:
# edge = graph.add_edge(vertex, owner_vertex)
# weights_on_edges[edge] = 1.0
for pre_actor in commons:
edge = graph.add_edge(vertex, pre_vertices_map[pre_actor])
interval =\
(created_at - pre_events_map[pre_actor]['created_at']).days
weight = 1.0 / fib(interval + 2)
weights_on_edges[edge] = weight
pre_events_map[actor] = event
pre_vertices_map[actor] = vertex
return graph
class SentenceGraph():
def __init__(self, sentence, directed=False, graph=None):
# Create a SentenceGraph from an existing graph tool graph
if graph is not None:
self.sentence_graph = graph
return
# Create a new SentenceGraph from scratch
self.sentence_graph = Graph(directed=directed)
# Graph properties
sentence_property = self.sentence_graph.new_graph_property("string", sentence)
self.sentence_graph.graph_properties[SENTENCE_KEY] = sentence_property
# Vertex properties
word_property = self.sentence_graph.new_vertex_property("string")
part_of_speech_property = self.sentence_graph.new_vertex_property("string")
vertex_color_property = self.sentence_graph.new_vertex_property("vector<double>")
self.sentence_graph.vertex_properties[WORD_KEY] = word_property
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY] = part_of_speech_property
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY] = vertex_color_property
# Edge properties
sentence_edge_property = self.sentence_graph.new_edge_property("string")
definition_edge_property = self.sentence_graph.new_edge_property("string")
parsed_dependencies_edge_property = self.sentence_graph.new_edge_property("string")
inter_sentence_edge_property = self.sentence_graph.new_edge_property("string")
edge_color_property = self.sentence_graph.new_edge_property("vector<double>")
dependency_edge_property = self.sentence_graph.new_edge_property("string")
self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY] = sentence_edge_property
self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY] = definition_edge_property
self.sentence_graph.edge_properties[PARSED_DEPENDENCIES_EDGE_KEY] = parsed_dependencies_edge_property
self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY] = inter_sentence_edge_property
self.sentence_graph.edge_properties[EDGE_COLOR_KEY] = edge_color_property
self.sentence_graph.edge_properties[PARSE_TREE_DEPENDENCY_VALUE_KEY] = dependency_edge_property
# Edge filter properties
definition_edge_filter_property = self.sentence_graph.new_edge_property("bool")
inter_sentence_edge_filter_property = self.sentence_graph.new_edge_property("bool")
parsed_dependencies_edge_filter_property = self.sentence_graph.new_edge_property("bool")
sentence_edge_filter_property = self.sentence_graph.new_edge_property("bool")
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY] = definition_edge_filter_property
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY] = inter_sentence_edge_filter_property
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY] = parsed_dependencies_edge_filter_property
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY] = sentence_edge_filter_property
def get_sentence(self):
return self.sentence_graph.graph_properties[SENTENCE_KEY]
def add_vertex(self, word, pos):
word_pos_tuple = (word, pos)
# Create vertex, set properties
word_vertex = self.sentence_graph.add_vertex()
self.sentence_graph.vertex_properties[WORD_KEY][word_vertex] = word
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][word_vertex] = pos
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY][word_vertex] = [0, 0, 1, 1]
return word_vertex
def set_vertex_color_from_word(self, word, pos, color=[1, 0, 0, 1]):
word_vertex = self.get_vertex(word, pos)
return self.set_vertex_color(word_vertex, color)
def set_vertex_color(self, vertex, color=[1, 0, 0, 1]):
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY][vertex] = color
def set_vertices_color(self, vertices, color=[1, 0, 0, 1]):
for vertex in vertices:
self.set_vertex_color(vertex, color)
def add_sentence_edge_from_words(self, word1, pos1, word2, pos2):
return self.add_sentence_edge(self.get_vertex(word1, pos1), self.get_vertex(word2, pos2))
def add_sentence_edge(self, word_vertex1, word_vertex2):
sentence_edge = self.sentence_graph.add_edge(word_vertex1, word_vertex2, add_missing=False)
self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY][sentence_edge] = sentence_edge
# Green
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][sentence_edge] = [0.2, 1, 0.2, 1]
self._set_edge_to_zero_in_all_filters(sentence_edge)
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY][sentence_edge] = True
return sentence_edge
def add_sentence_edges(self, sentence_vertices):
for i in range(1, len(sentence_vertices)):
self.add_sentence_edge(sentence_vertices[i - 1], sentence_vertices[i])
def add_parsed_dependency_edge(self, word_vertex1, word_vertex2, dependency_relationship):
parsed_dependency_edge = self.sentence_graph.add_edge(word_vertex1, word_vertex2, add_missing=False)
self.sentence_graph.edge_properties[PARSED_DEPENDENCIES_EDGE_KEY][parsed_dependency_edge] = parsed_dependency_edge
self.sentence_graph.edge_properties[PARSE_TREE_DEPENDENCY_VALUE_KEY][parsed_dependency_edge] = dependency_relationship
# Blue
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][parsed_dependency_edge] = [0, 0, 1, 1]
self._set_edge_to_zero_in_all_filters(parsed_dependency_edge)
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY][parsed_dependency_edge] = True
return parsed_dependency_edge
def add_parsed_dependency_edge_from_words(self, word1, pos1, word2, pos2, dependency_relationship):
return self.add_parsed_dependency_edge(
self.get_vertex(word1, pos1),
self.get_vertex(word2, pos2),
dependency_relationship)
def add_definition_edge_from_words(self, word, pos, definition_word, definition_pos):
return self.add_definition_edge(
self.get_vertex(word, pos),
self.get_vertex(definition_word, definition_pos))
def _set_edge_to_zero_in_all_filters(self, edge):
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY][edge] = False
def add_definition_edge(self, word_vertex, definition_word_vertex):
definition_edge = self.sentence_graph.add_edge(word_vertex, definition_word_vertex, add_missing=False)
self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY][definition_edge] = definition_edge
# Red
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][definition_edge] = [1, 0.1, 0.1, 1]
self._set_edge_to_zero_in_all_filters(definition_edge)
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY][definition_edge] = True
return definition_edge
def add_definition_edges(self, word_vertex, definition_word_vertices):
# Add edges from the word_vertex to all definition vertices and set
# the definition edge property on each edge
for definition_word_vertex in definition_word_vertices:
self.add_definition_edge(word_vertex, definition_word_vertex)
return self
def add_inter_sentence_edge(self, sentence1_word_vertex, sentence2_word_vertex):
inter_sentence_edge = self.sentence_graph.add_edge(sentence1_word_vertex, sentence2_word_vertex, add_missing=False)
self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY][inter_sentence_edge] = inter_sentence_edge
# Pink
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][inter_sentence_edge] = [1, 0.05, 1, 1]
self._set_edge_to_zero_in_all_filters(inter_sentence_edge)
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY][inter_sentence_edge] = True
return inter_sentence_edge
def add_inter_sentence_edge_from_words(self, word1, pos1, word2, pos2):
return self.add_inter_sentence_edge(
self.get_vertex(word1, pos1),
self.get_vertex(word2, pos2))
def remove_vertex_by_word(self, word, pos):
self.remove_vertex(self.get_vertex(word, pos))
def remove_vertex(self, vertex):
word = self.sentence_graph.vertex_properties[WORD_KEY][vertex]
pos = self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
self.sentence_graph.remove_vertex(vertex)
def remove_edge(self, word1, pos1, word2, pos2):
self.sentence_graph.remove_edge(self.get_edge(word1, pos1, word2, pos2))
def contains(self, word, pos):
return self.get_vertex(word, pos) is not None
def get_vertex(self, word, pos):
for vertex in self.sentence_graph.vertices():
try:
vertex_word = self.sentence_graph.vertex_properties[WORD_KEY][vertex]
vertex_pos = self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
if vertex_word == word and vertex_pos == pos:
return vertex
except:
pass
return None
def get_word_pos_tuple(self, vertex):
return self.sentence_graph.vertex_properties[WORD_KEY][vertex],\
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
def get_word_pos_tuple_by_index(self, index):
return self.get_word_pos_tuple(self.get_vertex_by_index(index))
def get_vertex_by_index(self, index):
return self.sentence_graph.vertex(index)
def get_vertices_iterator(self):
return self.sentence_graph.vertices()
def get_vertices(self):
return [x for x in self.sentence_graph.vertices()]
def get_vertex_out_neighbor_word_pos_tuples(self, vertex):
return [self.get_word_pos_tuple(neighbor_vertex)
for neighbor_vertex in self.get_vertex_out_neighbors(vertex)]
def get_vertex_in_neighbor_word_pos_tuples(self, vertex):
return [self.get_word_pos_tuple(neighbor_vertex)
for neighbor_vertex in self.get_vertex_in_neighbors(vertex)]
def get_vertex_out_neighbors(self, vertex):
return [neighbor_vertex for neighbor_vertex in vertex.out_neighbours()]
def get_vertex_in_neighbors(self, vertex):
return [neighbor_vertex for neighbor_vertex in vertex.in_neighbours()]
def get_word_pos_tuples(self):
return [self.get_word_pos_tuple(v) for v in self.sentence_graph.vertices()]
def get_num_vertices(self):
return self.sentence_graph.num_vertices()
def get_num_edges(self):
return self.sentence_graph.num_edges()
def get_edge(self, word1, pos1, word2, pos2):
vertex_1 = self.get_vertex(word1, pos1)
vertex_2 = self.get_vertex(word2, pos2)
return None\
if vertex_1 is None or vertex_2 is None\
else self.sentence_graph.edge(vertex_1, vertex_2)
def get_edges_iterator(self):
return self.sentence_graph.edges()
def get_edges(self):
return [x for x in self.sentence_graph.edges()]
def set_definition_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY],
inverted=inverted)
def set_inter_sentence_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY],
inverted=inverted)
def set_parsed_dependency_edge_filter(self, inverted=False):
self.sentence_edge.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY],
inverted=inverted)
def set_sentence_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY],
inverted=inverted)
def clear_filters(self):
self.sentence_graph.clear_filters()
def get_definition_edges(self):
return filter(lambda x: x in self.get_definition_edge_properties(), self.get_edges())
def get_word_vertex_properties(self):
return self.sentence_graph.vertex_properties[WORD_KEY]
def get_pos_vertex_properties(self):
return self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY]
def get_color_vertex_properties(self):
return self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY]
def get_sentence_edge_properties(self):
return self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY]
def get_definition_edge_properties(self):
return self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY]
def get_inter_sentence_edge_properties(self):
return self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY]
def get_color_edge_properties(self):
return self.sentence_graph.edge_properties[EDGE_COLOR_KEY]
def get_vertex_index(self, vertex):
return self.sentence_graph.vertex_index[vertex]
def get_degree_properties(self, degree_type):
return self.sentence_graph.degree_property_map(degree_type)
def get_graph(self):
return self.sentence_graph
def copy(self):
return SentenceGraph(
sentence=self.sentence_graph.graph_properties[SENTENCE_KEY],
graph=self.sentence_graph.copy())
class MemoryGraph:
# "my_graph.xml.gz"
def __init__(self, index_path=None, graph_path=None):
#index
if index_path != None:
self.load_index(index_path)
else:
self.init_index()
#graph
if graph_path != None:
self.load_graph(graph_path)
else:
self.init_graph()
def save_index(self, index_path):
self.index.save_index(index_path)
def load_index(self, index_path):
self.index = hnswlib.Index(space='l2', dim=256)
self.index.load_index(index_path)
self.index.set_ef(10)
def init_index(self):
self.index = hnswlib.Index(space='l2', dim=256)
self.index.init_index(max_elements=50000, ef_construction=100, M=16)
self.index.set_ef(10)
def save_graph(self, graph_path):
self.graph.save(graph_path)
def load_graph(self, graph_path):
self.graph = load_graph(graph_path)
self.vertex_index = dict()
for v in self.graph.vertices():
self.vertex_index[self.graph.vp.id[v]] = v
def init_graph(self):
self.graph = Graph(directed=False)
self.vertex_index = dict()
self.graph.graph_properties["id"] = self.graph.new_graph_property(
"long")
self.graph.graph_properties["id"] = 0
self.graph.vertex_properties["id"] = self.graph.new_vertex_property(
"long")
self.graph.vertex_properties["x"] = self.graph.new_vertex_property(
"double")
self.graph.vertex_properties["y"] = self.graph.new_vertex_property(
"double")
self.graph.vertex_properties["t"] = self.graph.new_vertex_property(
"long")
self.graph.vertex_properties["f"] = self.graph.new_vertex_property(
"vector<double>")
self.graph.edge_properties["d"] = self.graph.new_edge_property(
"double")
def get_observation(self, id):
v = self.vertex_index[id]
return dict(id=id,
x=self.graph.vp.x[v],
y=self.graph.vp.y[v],
t=self.graph.vp.t[v],
f=self.graph.vp.f[v])
def get_observations(self, ids):
return [self.get_observation(id) for id in ids]
def insert_observation(self, t, y, x, f):
v = self.graph.add_vertex()
id = self.graph.graph_properties["id"]
self.graph.graph_properties["id"] = id + 1
self.graph.vp.id[v] = id
self.graph.vp.x[v] = x
self.graph.vp.y[v] = y
self.graph.vp.t[v] = t
self.graph.vp.f[v] = f
self.index.add_items([f], [id])
return id
def get_adjacencies(self, id, radius):
v = self.vertex_index[id]
return [self.vertex_index[n] for n in self._neighbors(v, radius)]
def _neighbors(self, v, radius, depth=0):
result = set()
for w in v.out_neighbors():
result.add(w)
if depth + 1 < radius:
result.update(self._neighbors(w, radius, depth + 1))
return result
def insert_adjacency(self, from_id, to_id, distance):
va = self.vertex_index[from_id]
vb = self.vertex_index[to_id]
e = self.graph.add_edge(va, vb)
self.graph.ep.d[e] = distance
def knn_query(self, feats, k=1):
return self.index.knn_query(feats, k)
def load_instance(filepath):
g = Graph(directed=False)
node_upgraded = g.new_vertex_property("bool")
node_cost = g.new_vertex_property("float")
edge_weight = g.new_edge_property("float")
edge_weight_lv2 = g.new_edge_property("float")
edge_weight_lv3 = g.new_edge_property("float")
edge_upgradeable_weights = g.new_edge_property("vector<float>")
graph_total_cost = g.new_graph_property("float")
graph_total_cost[g] = 0
with open(filepath, "r") as f:
first_line = f.readline()
tokens = first_line.split(" ")
assert len(tokens) == 2
n = int(tokens[0])
m = int(tokens[1])
g.add_vertex(n)
#print (n, m)
for _ in range(m):
line = f.readline()
tokens = line.split(" ")
assert len(tokens) == 5
v1 = int(tokens[0])
v2 = int(tokens[1])
e = g.add_edge(v1, v2)
w1 = float(tokens[2])
w2 = float(tokens[3])
w3 = float(tokens[4])
edge_weight[e] = w1
edge_weight_lv2[e] = w2
edge_weight_lv3[e] = w3
# identify how weights are for vertices
line = f.readline()
v_cost = [float(x) for x in line.split(" ") if x != " "]
if len(v_cost) > 1: # case where formatting is incorrect
for i in range(n):
v = g.vertex(i)
node_cost[v] = v_cost[i]
node_upgraded[i] = False
else:
v = g.vertex(0)
node_cost[v] = float(v_cost[0])
node_upgraded[v] = False
vertices = g.vertices()
vertices.next()
for v in vertices:
line = f.readline()
c = float(line)
node_cost[v] = c
node_upgraded[v] = False
g.vp.is_upgraded = node_upgraded
g.vp.cost = node_cost
g.ep.weight = edge_weight
g.ep.weight_2 = edge_weight_lv2
g.ep.weight_3 = edge_weight_lv3
for v in g.vertices():
graph_total_cost[g] += node_cost[v]
g.gp.total_cost = graph_total_cost
return g
