def connect_subgraphs_by_spanning_trees(self):
subgraphs = {}
labels = graph_tool.label_components(self.g)[0].a
for i in range(len(labels)):
label = labels[i]
if label in subgraphs:
subgraphs[label].append(self.g.vertex(i))
else:
subgraphs[label] = [self.g.vertex(i)]
vertices_idx_to_connect = []
print(len(subgraphs.keys()))
for l, s in tqdm(subgraphs.items()):
# print(l)
subgraph = graph_tool.GraphView(self.g,
vfilt=labels == l,
directed=True)
tree_edges = graph_tool.min_spanning_tree(subgraph)
tree = graph_tool.GraphView(subgraph,
efilt=tree_edges,
directed=True)
sort = graph_tool.topological_sort(tree)
vertices_idx_to_connect.append(sort[0])
self.v_root = self.g.add_vertex()
for i in vertices_idx_to_connect:
self.g.add_edge(self.v_root, i)
def posteriorQuery(self, dict_q_names_factor, dict_e_names_values):
""" Queries of type P(Q_1,...,Q_k | e_1,...,e_m)
"""
dict_q_names_rv= {}
rvs_Y= []
rvs_all= []
factors= []
evidence_dict= {}
top_sort_vertices = gt.topological_sort(self.graph)
# stictly speaking topological sorting is not needed here- any ordering will do.
rv_prop= self.graph.vertex_properties["rv"]
for vertex in top_sort_vertices:
rv= rv_prop[self.graph.vertex(vertex)]
rvs_all.append(rv)
if rv.name in dict_e_names_values:
evidence_dict[rv.name]= rv.values_dict[dict_e_names_values[rv.name]]
elif rv.name in dict_q_names_factor:
dict_q_names_factor[rv.name]= rv
dict_q_names_rv[rv.name]= rv
else:
rvs_Y.append(rv)
for rv in rvs_all:
factors.append(rv.factor(self.graph, evidence_dict))
self.variableElimination(dict_q_names_factor, rvs_Y, evidence_dict, factors)
return dict_q_names_rv
def prepare(self):
"""
Computes ans saves the topological sort of the graph for future use.
"""
self.order = np.array(gt.topological_sort(self.g)[::-1])
for vIdx in self.order[:self.nInput]:
self.activation[self.g.vertex(vIdx)] = Identity()
def __init__(self, a_graph):
dict.__init__(self)
self.graph= a_graph
self.top_sort_vertices = gt.topological_sort(self.graph)