def test_graphtool(): g = Graph(directed=True) g.add_vertex(4) g.add_edge_list([(0, 1), (1, 2), (2, 3), (3, 0)]) weight = g.new_edge_property('float') weight[g.edge(0, 1)] = 1 weight[g.edge(1, 2)] = 2 weight[g.edge(2, 3)] = 3 weight[g.edge(3, 0)] = 4 assert set(gt2edges_and_weights(g, weight)) == { (0, 1, 1), (1, 2, 2), (2, 3, 3), (3, 0, 4) }
def mwgm_graph_tool(pairs, sim_mat): from graph_tool.all import Graph, max_cardinality_matching if not isinstance(pairs, list): pairs = list(pairs) g = Graph() weight_map = g.new_edge_property("float") nodes_dict1 = dict() nodes_dict2 = dict() edges = list() for x, y in pairs: if x not in nodes_dict1.keys(): n1 = g.add_vertex() nodes_dict1[x] = n1 if y not in nodes_dict2.keys(): n2 = g.add_vertex() nodes_dict2[y] = n2 n1 = nodes_dict1.get(x) n2 = nodes_dict2.get(y) e = g.add_edge(n1, n2) edges.append(e) weight_map[g.edge(n1, n2)] = sim_mat[x, y] print("graph via graph_tool", g) res = max_cardinality_matching(g, heuristic=True, weight=weight_map, minimize=False) edge_index = np.where(res.get_array() == 1)[0].tolist() matched_pairs = set() for index in edge_index: matched_pairs.add(pairs[index]) return matched_pairs
class StackGraph(object): def __init__(self): self.g = None def load(self, filename): # Initialize the graph self.g = Graph() # Each node will store a FunctionWrapper() class instance. self.g.vertex_properties["functions"] = self.g.new_vertex_property("object") self.g.vertex_properties["display"] = self.g.new_vertex_property("string") # Each edge will store a [ ..tbd.. ] . self.g.edge_properties["calls"] = self.g.new_edge_property("object") # Load the log file and build the graph i = 0 f = open(filename, "rb") for line in f: i += 1 try: # Skip any informational lines if "*" in line: continue # Extract a call stack snapshot words = line.split() time = words[0][2:] depth = words[1][2:] stack = [FunctionWrapper(instring=item) for item in words[2].split("->")] # Add the top 2 functions to the graph, if necessary. Format: f1()->f2() f1, f2 = stack[-2], stack[-1] v1, v2 = None, None # Search for the vertices for v in self.g.vertices(): if self.g.vp.functions[v] == f1: v1 = v if self.g.vp.functions[v] == f2: v2 = v if v1 != None and v2 != None: break # Add new vertices if needed if v1 == None: v1 = self.g.add_vertex() self.g.vp.functions[v1] = f1 self.g.vp.display[v1] = f1.graphDisplayString() if v2 == None: v2 = self.g.add_vertex() self.g.vp.functions[v2] = f2 self.g.vp.display[v2] = f2.graphDisplayString() # Add the edge if necessary, and then add data to it if not self.g.edge(v1, v2): e = self.g.add_edge(v1, v2) self.g.ep.calls[e] = CallList(v1, v2) self.g.ep.calls[e].addCall(time, depth) except Exception as e: print "Exception on line", i, ":", e print [str(x) for x in stack] exit()
def build_region_closure(g, root, regions, infection_times, obs_nodes, debug=False): """return a closure graph on the the components""" regions = copy(regions) root_region = {'nodes': {root}, 'head': root, 'head_time': -float('inf')} regions[len(regions)] = root_region gc = Graph(directed=True) for _ in range(len(regions)): gc.add_vertex() # connect each region gc_edges = [] original_edge_info = {} for i, j in combinations(regions, 2): # make group i the one with *later* head if regions[i]['head_time'] < regions[j]['head_time']: i, j = j, i if debug: print('i, j={}, {}'.format(i, j)) # only need to connect head i to one of the nodes in group j # where nodes in j have time stamp < head i # then an edge from region j to region i (because j is earlier) head_i = regions[i]['head'] def get_pseudo_time(n): if n == root: return - float('inf') else: return infection_times[n] targets = [n for n in regions[j]['nodes'] if get_pseudo_time(n) < regions[i]['head_time']] if debug: print('head_i: {}'.format(head_i)) print('targets: {}'.format(targets)) print('regions[j]["nodes"]: {}'.format(regions[j]['nodes'])) if len(targets) == 0: continue visitor = init_visitor(g, head_i) forbidden_nodes = list(set(regions[i]['nodes']) | (set(regions[j]['nodes']) - set(targets))) if debug: print('forbidden_nodes: {}'.format(forbidden_nodes)) # NOTE: count_threshold = 1 cpbfs_search(g, source=head_i, terminals=targets, forbidden_nodes=forbidden_nodes, visitor=visitor, count_threshold=1) reachable_targets = [t for t in targets if visitor.dist[t] > 0] if debug: print('reachable_targets: {}'.format(reachable_targets)) if len(reachable_targets) == 0: # cannot reach there continue source = min(reachable_targets, key=visitor.dist.__getitem__) dist = visitor.dist[source] assert dist > 0 gc_edges.append(((j, i, dist))) original_edge_info[(j, i)] = { 'dist': dist, 'pred': visitor.pred, 'original_edge': (source, head_i) } for u, v, _ in gc_edges: gc.add_edge(u, v) eweight = gc.new_edge_property('int') for u, v, c in gc_edges: eweight[gc.edge(gc.vertex(u), gc.vertex(v))] = c return gc, eweight, original_edge_info
class TTC(AbstractMatchingAlgorithm): """This class searches for cycles where each student gets his best option. This takes a list of students, a list of schools and a ruleset (which is used to calculate priorities). This works by generating a directed graph, where each student points at at his best option, and each school points at the student (or students) with the highest priority. """ EDGE_WIDTH_SIZE_FACTOR = 700 """Size factor (in the image) of each edge that is not part of the main cycle.""" EDGE_WIDTH_CYCLE_SIZE = 10 """Size factor (in the image) of each edge that takes part of the main cycle.""" def __init__(self, generate_images=False, images_folder="TTC_images", use_longest_cycle=True): """Initializes the algorithm. :param generate_images: If the process generates images or not. :type generate_images: bool :param images_folder: Where images are saved. :type images_folder: str :param use_longest_cycle: If the algorithm applies the longest cycle available, or the first one encountered. :type use_longest_cycle: bool """ self.generate_images = generate_images self.images_folder = images_folder self.use_longest_cycle = use_longest_cycle self.__graph = None self.__vertices_by_school_id = None self.__vertices_by_student_id = None self.__students_by_id = None self.__schools_by_id = None self.__entity_id = None self.__entity_type = None def reset_variables(self): """Resets all variables.""" self.__graph = Graph() self.__vertices_by_school_id = {} self.__vertices_by_student_id = {} self.__students_by_id = {} self.__schools_by_id = {} self.__entity_id = self.__graph.new_vertex_property("int") self.__graph.vertex_properties["entity_id"] = self.__entity_id self.__entity_type = self.__graph.new_vertex_property("string") self.__graph.vertex_properties["entity_type"] = self.__entity_type def run(self, students, schools, ruleset): """Runs the algorithm. First it creates the graph, then it lists all the cycles available, after that it selects one cycle, and applies it. Finally, it starts the process again. :param students: List of students. :type students: list :param schools: List of school. :type schools: list :param ruleset: Set of rules used. :type ruleset: Ruleset """ self.reset_variables() can_improve = True iteration_counter = 1 while can_improve: self.structure_graph(students, schools) cycles = [c for c in all_circuits(self.__graph, unique=True)] # print("CYCLES", cycles, "iteration", iteration_counter) cycle_edges = [] if cycles: for cycle in cycles: # ToDo: Possible optimisation: apply all disjoint cycles at once for current_v_index in range(len(cycle)): next_v_index = (current_v_index + 1) % len(cycle) from_v = self.__graph.vertex(cycle[current_v_index]) target_v = self.__graph.vertex(cycle[next_v_index]) edge = self.__graph.edge(from_v, target_v) cycle_edges.append(edge) if self.__entity_type[from_v] == "st": sel_student = self.__students_by_id[ self.__entity_id[from_v]] sel_school = self.__schools_by_id[ self.__entity_id[target_v]] sel_student.assigned_school = sel_school sel_school.assignation.append(sel_student) # vertex_school_target_id = self.__entity_id[target_v] # vertex_school_target = self.__schools_by_id[vertex_school_target_id] # print("CYCLE: Student", sel_student.id, "School", sel_school.id) # print("VVV: School {} -> School {} (Student {}) ".format(self.__entity_id[from_v], self.__entity_id[target_v], self.__entity_id[self.__graph.edge(from_v, target_v)])) if self.generate_images: self.generate_image(cycle_edges, iteration_n=iteration_counter) else: can_improve = False self.__graph.clear() iteration_counter += 1 def structure_graph(self, students, schools): """Creates a graph where students points to schools, and schools points to students. In the graph, each student points at at his best option, and each school points at the student (or students) with the highest priority. :param students: List of students. :type students: list :param schools: :type schools: list """ if not self.__students_by_id and not self.__schools_by_id: for student in students: self.__students_by_id[student.id] = student for school in schools: self.__schools_by_id[school.id] = school for school in schools: setattr(school, 'preferences', StudentQueue(school, preference_mode=True)) remaining_students = [ student for student in students if not student.assigned_school ] for student in remaining_students: for pref_school in student.preferences: pref_school.preferences.append(student) for student in remaining_students: v_source_student = self.create_vertex_student(student) pref_school = next( (school for school in student.preferences if len(school.assignation.get_all_students()) < school.capacity), None) if pref_school: v_target_school = self.create_vertex_school(pref_school) self.create_edge(v_source_student, v_target_school) for school in schools: if len(school.assignation.get_all_students()) < school.capacity: v_source_school = self.create_vertex_school(school) pref_student = next( iter(school.preferences.get_all_students()), None) if pref_student: v_target_student = self.create_vertex_student(pref_student) self.create_edge(v_source_school, v_target_student) # graph_draw(self.__graph, # vertex_text=self.__entity_id, vertex_shape="circle", # output_size=(1000, 1000), bg_color=[1., 1., 1., 1], output="graph.png") def create_vertex_student(self, student): """Defines a new student as a vertex in the graph (if it did not existed before).""" if student.id in self.__vertices_by_student_id: vertex = self.__vertices_by_student_id[student.id] else: vertex = self.__graph.add_vertex() self.__vertices_by_student_id[student.id] = vertex self.__entity_id[vertex] = student.id self.__entity_type[ vertex] = "st" # ToDo: There may be other ways to do this. return vertex def create_vertex_school(self, school): """Defines a new school as a vertex in the graph (if it did not existed before).""" if school.id in self.__vertices_by_school_id: vertex = self.__vertices_by_school_id[school.id] else: vertex = self.__graph.add_vertex() self.__vertices_by_school_id[school.id] = vertex self.__entity_id[vertex] = school.id self.__entity_type[vertex] = "sc" return vertex def create_edge(self, source_v, target_v): """Creates a directed edge between two vertices.""" self.__graph.add_edge(source_v, target_v) def generate_image(self, cycle_edges, iteration_n=0): """Generates an image of a graph. :param cycle_edges: Edges which are part of the main cycle (they will be highlighted in red). :type cycle_edges: list :param iteration_n: Number of iteration of the algorithm (this is added in the filename of the image). :type iteration_n: int .. DANGER:: This is an experimental feature. """ edge_color = self.__graph.new_edge_property("vector<float>") edge_width = self.__graph.new_edge_property("int") for edge in self.__graph.edges(): if edge in cycle_edges: edge_color[edge] = [1., 0.2, 0.2, 0.999] edge_width[edge] = 7 else: edge_color[edge] = [0., 0., 0., 0.3] edge_width[edge] = 4 vertex_shape = self.__graph.new_vertex_property("string") vertex_size = self.__graph.new_vertex_property("int") for vertex in self.__graph.vertices(): if self.__entity_type[vertex] == "st": vertex_shape[vertex] = "circle" vertex_size[vertex] = 1 else: vertex_shape[vertex] = "double_circle" vertex_size[vertex] = 100 # pos = sfdp_layout(self.__graph, C=10, p=5, theta=2, gamma=1) pos = arf_layout(self.__graph, d=0.2, a=3) graph_draw( self.__graph, pos=pos, vertex_text=self.__entity_id, vertex_font_size= 1, # ToDo: Move image related code outside the class. vertex_fill_color=[0.97, 0.97, 0.97, 1], vertex_color=[0.05, 0.05, 0.05, 0.95], vertex_shape=vertex_shape, edge_color=edge_color, edge_pen_width=edge_width, output_size=(1000, 1000), bg_color=[1., 1., 1., 1], output=self.generate_filename(iteration_n)) def generate_filename(self, iteration_n): # ToDo: Move this to utils """Returns a filename (which is used to generate the images).""" filename = "Graph (iteration {})".format( iteration_n) if iteration_n > 0 else "Graph" output_file = gen_filepath(self.images_folder, filename=filename, extension="png") return output_file
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())
# improving cut print("Improving cut") dists = pairs_graph.new_vertex_property("int") pos = 0 neg = 1 polarity = ["pos", "neg"] if count1 < count2: pos, neg = neg, pos polarity = ["neg", "pos"] bad_vertices = {} for v in pairs_graph.vertices(): dists[v] = 0 for w in v.out_neighbours(): if part[w] == pos: dists[v] += edge_weights[pairs_graph.edge(v, w)] else: dists[v] -= edge_weights[pairs_graph.edge(v, w)] # print(ver_names[v] + " is in " + polarity[part[v]] + " -> " + str(dists[v])) if part[v] == pos and dists[v] < 0: bad_vertices[v] = dists[v] elif part[v] == neg and dists[v] > 0: bad_vertices[v] = -dists[v] else: bad_vertices[v] = 0 worst_vertex = min(bad_vertices, key=bad_vertices.get) max_iter = 1000 i = 0 while bad_vertices[worst_vertex] != 0 and i < max_iter:
# improving cut print("Improving cut") dists = pairs_graph.new_vertex_property("int") pos = 0 neg = 1 polarity = ["pos", "neg"] if count1 < count2: pos, neg = neg, pos polarity = ["neg", "pos"] bad_vertices = {} for v in pairs_graph.vertices(): dists[v] = 0 for w in v.out_neighbours(): if part[w] == pos: dists[v] += edge_weights[pairs_graph.edge(v, w)] else: dists[v] -= edge_weights[pairs_graph.edge(v, w)] # print(ver_names[v] + " is in " + polarity[part[v]] + " -> " + str(dists[v])) if part[v] == pos and dists[v] < 0: bad_vertices[v] = dists[v] elif part[v] == neg and dists[v] > 0: bad_vertices[v] = -dists[v] else: bad_vertices[v] = 0 worst_vertex = min(bad_vertices, key=bad_vertices.get) max_iter = 1000 i = 0 while bad_vertices[worst_vertex] != 0 and i < max_iter:
def build_region_closure(g, root, regions, infection_times, obs_nodes, debug=False): """return a closure graph on the the components""" regions = copy(regions) root_region = {'nodes': {root}, 'head': root, 'head_time': -float('inf')} regions[len(regions)] = root_region gc = Graph(directed=True) for _ in range(len(regions)): gc.add_vertex() # connect each region gc_edges = [] original_edge_info = {} for i, j in combinations(regions, 2): # make group i the one with *later* head if regions[i]['head_time'] < regions[j]['head_time']: i, j = j, i if debug: print('i, j={}, {}'.format(i, j)) # only need to connect head i to one of the nodes in group j # where nodes in j have time stamp < head i # then an edge from region j to region i (because j is earlier) head_i = regions[i]['head'] def get_pseudo_time(n): if n == root: return -float('inf') else: return infection_times[n] targets = [ n for n in regions[j]['nodes'] if get_pseudo_time(n) < regions[i]['head_time'] ] if debug: print('head_i: {}'.format(head_i)) print('targets: {}'.format(targets)) print('regions[j]["nodes"]: {}'.format(regions[j]['nodes'])) if len(targets) == 0: continue visitor = init_visitor(g, head_i) forbidden_nodes = list( set(regions[i]['nodes']) | (set(regions[j]['nodes']) - set(targets))) if debug: print('forbidden_nodes: {}'.format(forbidden_nodes)) # NOTE: count_threshold = 1 cpbfs_search(g, source=head_i, terminals=targets, forbidden_nodes=forbidden_nodes, visitor=visitor, count_threshold=1) reachable_targets = [t for t in targets if visitor.dist[t] > 0] if debug: print('reachable_targets: {}'.format(reachable_targets)) if len(reachable_targets) == 0: # cannot reach there continue source = min(reachable_targets, key=visitor.dist.__getitem__) dist = visitor.dist[source] assert dist > 0 gc_edges.append(((j, i, dist))) original_edge_info[(j, i)] = { 'dist': dist, 'pred': visitor.pred, 'original_edge': (source, head_i) } for u, v, _ in gc_edges: gc.add_edge(u, v) eweight = gc.new_edge_property('int') for u, v, c in gc_edges: eweight[gc.edge(gc.vertex(u), gc.vertex(v))] = c return gc, eweight, original_edge_info