def opt(self, file1, file2):
f1 = open(file1, encoding="utf8")
lines = f1.readlines()
nodes = self.getegdes(lines[0])
edges = self.getegdes(lines[1])
data = pd.read_csv(file2)
G = BayesianModel()
G.add_nodes_from(nodes)
for i in range(int(len(edges) / 2)):
G.add_edge(edges[2 * i], edges[2 * i + 1])
# nx.draw(G)
# plt.show()
k2 = K2Score(data).score(G)
bic = BicScore(data).score(G)
bdeu = BDeuScore(data).score(G)
print(k2, ",", bic, ",", bdeu)
est = HillClimbSearch(data, scoring_method=K2Score(data))
model = est.estimate()
model_edges = model.edges()
G_ = nx.DiGraph()
G_.add_edges_from(model_edges)
G_copy = nx.DiGraph()
G_copy.add_edges_from(G.edges)
add = []
add_mut = []
delete = []
delete_mut = []
# a = list(G.edges._adjdict.key())
for edge in model_edges:
node1 = edge[0]
node2 = edge[1]
if not nx.has_path(G, node2, node1):
if not G.has_edge(node1, node2):
this = (node1, node2)
# this = '('+node1+','+node2+')'
add.append(this)
x = data[node1]
mut = mr.mutual_info_score(data[node1], data[node2])
add_mut.append(mut)
seq = list(zip(add_mut, add))
seq = sorted(seq, key=lambda s: s[0], reverse=True)
alpha = 0.015
# if seq[0][0] > alpha:
# add = seq[0:1]
add = seq[0:1]
data_edges = []
for edge in G.edges:
node1 = edge[0]
node2 = edge[1]
mut = mr.mutual_info_score(data[node1], data[node2])
delete_mut.append(mut)
data_edges.append(edge)
# if not (nx.has_path(G_, node1, node2) or nx.has_path(G_, node2, node1)):
# this = '('+node1+','+node2+')'
# delete.append(this)
seq = list(zip(delete_mut, data_edges))
seq = sorted(seq, key=lambda s: s[0])
# if seq[0][0] < alpha:
# delete = seq[0:1]
if len(edges) > 2:
delete = seq[0:1]
if len(add) > 0:
if delete[0][0] > add[0][0]:
delete = []
print('add')
for i in add:
print(str(i[1]) + "," + str(i[0]))
print('delete')
for j in delete:
print(str(j[1]) + "," + str(j[0]))
# print(j[0])
print('cpt')
estimator = BayesianEstimator(G, data)
for i in G.nodes:
cpd = estimator.estimate_cpd(i, prior_type="K2")
nodeName = i
values = dict(data[i].value_counts())
valueNum = len(values)
CPT = np.transpose(cpd.values)
# CPT = cpd.values
sequence = cpd.variables[1::]
card = []
for x in sequence:
s = len(dict(data[x].value_counts()))
card.append(s)
output = nodeName + '\t' + str(valueNum) + '\t' + str(
CPT.tolist()) + '\t' + str(sequence) + '\t' + str(card)
print(output)
print('mutual')
output1 = []
for i in range(int(len(edges) / 2)):
mut = mr.mutual_info_score(data[edges[2 * i]],
data[edges[2 * i + 1]])
output1.append(mut)
output2 = {}
for node1 in G.nodes():
d = {}
for node2 in G.nodes():
if node1 == node2:
continue
mut = mr.mutual_info_score(data[node1], data[node2])
d[node2] = mut
output2[node1] = d
print(output1)
print(output2)
def pdag_to_dag(pdag):
"""Completes a PDAG to a DAG, without adding v-structures, if such a
completion exists. If no faithful extension is possible, some fully
oriented DAG that corresponds to the PDAG is returned and a warning is
generated. This is a static method.
Parameters
----------
pdag: DirectedGraph
A directed acyclic graph pattern, consisting in (acyclic) directed edges
as well as "undirected" edges, represented as both-way edges between
nodes.
Returns
-------
dag: BayesianModel
A faithful orientation of pdag, if one exists. Otherwise any
fully orientated DAG/BayesianModel with the structure of pdag.
References
----------
[1] Chickering, Learning Equivalence Classes of Bayesian-Network Structures,
2002; See page 454 (last paragraph) for the algorithm pdag_to_dag
http://www.jmlr.org/papers/volume2/chickering02a/chickering02a.pdf
[2] Dor & Tarsi, A simple algorithm to construct a consistent extension
of a partially oriented graph, 1992,
http://ftp.cs.ucla.edu/pub/stat_ser/r185-dor-tarsi.pdf
Examples
--------
>>> import pandas as pd
>>> import numpy as np
>>> from pgmpy.base import DirectedGraph
>>> from pgmpy.estimators import ConstraintBasedEstimator
>>> data = pd.DataFrame(np.random.randint(0, 4, size=(5000, 3)), columns=list('ABD'))
>>> data['C'] = data['A'] - data['B']
>>> data['D'] += data['A']
>>> c = ConstraintBasedEstimator(data)
>>> pdag = c.skeleton_to_pdag(*c.estimate_skeleton())
>>> pdag.edges()
[('B', 'C'), ('D', 'A'), ('A', 'D'), ('A', 'C')]
>>> c.pdag_to_dag(pdag).edges()
[('B', 'C'), ('A', 'D'), ('A', 'C')]
>>> # pdag_to_dag is static:
... pdag1 = DirectedGraph([('A', 'B'), ('C', 'B'), ('C', 'D'), ('D', 'C'), ('D', 'A'), ('A', 'D')])
>>> ConstraintBasedEstimator.pdag_to_dag(pdag1).edges()
[('D', 'C'), ('C', 'B'), ('A', 'B'), ('A', 'D')]
>>> # example of a pdag with no faithful extension:
... pdag2 = DirectedGraph([('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B')])
>>> ConstraintBasedEstimator.pdag_to_dag(pdag2).edges()
UserWarning: PDAG has no faithful extension (= no oriented DAG with the same v-structures as PDAG).
Remaining undirected PDAG edges oriented arbitrarily.
[('B', 'C'), ('A', 'B'), ('A', 'C')]
"""
pdag = pdag.copy()
dag = BayesianModel()
dag.add_nodes_from(pdag.nodes())
# add already directed edges of pdag to dag
for X, Y in pdag.edges():
if not pdag.has_edge(Y, X):
dag.add_edge(X, Y)
while pdag.number_of_nodes() > 0:
# find node with (1) no directed outgoing edges and
# (2) the set of undirected neighbors is either empty or
# undirected neighbors + parents of X are a clique
found = False
for X in pdag.nodes():
directed_outgoing_edges = set(pdag.successors(X)) - set(
pdag.predecessors(X))
undirected_neighbors = set(pdag.successors(X)) & set(
pdag.predecessors(X))
neighbors_are_clique = all((pdag.has_edge(Y, Z)
for Z in pdag.predecessors(X)
for Y in undirected_neighbors
if not Y == Z))
if not directed_outgoing_edges and \
(not undirected_neighbors or neighbors_are_clique):
found = True
# add all edges of X as outgoing edges to dag
for Y in pdag.predecessors(X):
dag.add_edge(Y, X)
pdag.remove_node(X)
break
if not found:
warn(
"PDAG has no faithful extension (= no oriented DAG with the "
+
"same v-structures as PDAG). Remaining undirected PDAG edges "
+ "oriented arbitrarily.")
for X, Y in pdag.edges():
if not dag.has_edge(Y, X):
try:
dag.add_edge(X, Y)
except ValueError:
pass
break
return dag
def pdag_to_dag(pdag):
"""Completes a PDAG to a DAG, without adding v-structures, if such a
completion exists. If no faithful extension is possible, some fully
oriented DAG that corresponds to the PDAG is returned and a warning is
generated. This is a static method.
Parameters
----------
pdag: DirectedGraph
A directed acyclic graph pattern, consisting in (acyclic) directed edges
as well as "undirected" edges, represented as both-way edges between
nodes.
Returns
-------
dag: BayesianModel
A faithful orientation of pdag, if one exists. Otherwise any
fully orientated DAG/BayesianModel with the structure of pdag.
References
----------
[1] Chickering, Learning Equivalence Classes of Bayesian-Network Structures,
2002; See page 454 (last paragraph) for the algorithm pdag_to_dag
http://www.jmlr.org/papers/volume2/chickering02a/chickering02a.pdf
[2] Dor & Tarsi, A simple algorithm to construct a consistent extension
of a partially oriented graph, 1992,
http://ftp.cs.ucla.edu/pub/stat_ser/r185-dor-tarsi.pdf
Examples
--------
>>> import pandas as pd
>>> import numpy as np
>>> from pgmpy.base import DirectedGraph
>>> from pgmpy.estimators import ConstraintBasedEstimator
>>> data = pd.DataFrame(np.random.randint(0, 4, size=(5000, 3)), columns=list('ABD'))
>>> data['C'] = data['A'] - data['B']
>>> data['D'] += data['A']
>>> c = ConstraintBasedEstimator(data)
>>> pdag = c.skeleton_to_pdag(*c.estimate_skeleton())
>>> pdag.edges()
[('B', 'C'), ('D', 'A'), ('A', 'D'), ('A', 'C')]
>>> c.pdag_to_dag(pdag).edges()
[('B', 'C'), ('A', 'D'), ('A', 'C')]
>>> # pdag_to_dag is static:
... pdag1 = DirectedGraph([('A', 'B'), ('C', 'B'), ('C', 'D'), ('D', 'C'), ('D', 'A'), ('A', 'D')])
>>> ConstraintBasedEstimator.pdag_to_dag(pdag1).edges()
[('D', 'C'), ('C', 'B'), ('A', 'B'), ('A', 'D')]
>>> # example of a pdag with no faithful extension:
... pdag2 = DirectedGraph([('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B')])
>>> ConstraintBasedEstimator.pdag_to_dag(pdag2).edges()
UserWarning: PDAG has no faithful extension (= no oriented DAG with the same v-structures as PDAG).
Remaining undirected PDAG edges oriented arbitrarily.
[('B', 'C'), ('A', 'B'), ('A', 'C')]
"""
pdag = pdag.copy()
dag = BayesianModel()
dag.add_nodes_from(pdag.nodes())
# add already directed edges of pdag to dag
for X, Y in pdag.edges():
if not pdag.has_edge(Y, X):
dag.add_edge(X, Y)
while pdag.number_of_nodes() > 0:
# find node with (1) no directed outgoing edges and
# (2) the set of undirected neighbors is either empty or
# undirected neighbors + parents of X are a clique
found = False
for X in pdag.nodes():
directed_outgoing_edges = set(pdag.successors(X)) - set(pdag.predecessors(X))
undirected_neighbors = set(pdag.successors(X)) & set(pdag.predecessors(X))
neighbors_are_clique = all((pdag.has_edge(Y, Z)
for Z in pdag.predecessors(X)
for Y in undirected_neighbors if not Y == Z))
if not directed_outgoing_edges and \
(not undirected_neighbors or neighbors_are_clique):
found = True
# add all edges of X as outgoing edges to dag
for Y in pdag.predecessors(X):
dag.add_edge(Y, X)
pdag.remove_node(X)
break
if not found:
warn("PDAG has no faithful extension (= no oriented DAG with the " +
"same v-structures as PDAG). Remaining undirected PDAG edges " +
"oriented arbitrarily.")
for X, Y in pdag.edges():
if not dag.has_edge(Y, X):
try:
dag.add_edge(X, Y)
except ValueError:
pass
break
return dag
