def setUp(self):
nodedata = NodeData.load("unittestlgdict.txt")
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
self.lgb = LGBayesianNetwork(nodedata)
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(nodedata)
self.fn = TableCPDFactorization(self.bn)
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData()
nodedata.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(skel, nodedata)
def setUp(self):
self.nd = NodeData()
self.nd.load("unittestdyndict.txt")
self.skel = GraphSkeleton()
self.skel.load("unittestdyndict.txt")
self.skel.toporder()
self.d = DynDiscBayesianNetwork(self.skel, self.nd)
def setUp(self):
self.nd = HybridNodeData.load("unittesthdict.txt")
self.nd.entriestoinstances()
self.skel = GraphSkeleton()
self.skel.load("unittestdict.txt")
self.skel.toporder()
self.hybn = HyBayesianNetwork(self.skel, self.nd)
def graph_skeleton_from_node_data(nd):
skel = GraphSkeleton()
skel.V = []
skel.E = []
for name, v in nd.Vdata.items():
skel.V += [name]
skel.E += [[name, c] for c in v["children"]]
return skel
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(nodedata)
self.factor = TableCPDFactor("Grade", self.instance)
self.factor2 = TableCPDFactor("Letter", self.instance)
def graph_skeleton_from_node_data(nd):
skel = GraphSkeleton()
skel.V = []
skel.E = []
for name, v in nd.Vdata.items():
skel.V += [name]
skel.E += [[name, c] for c in v["children"]]
return skel
def getTableCPD():
nd = NodeData()
skel = GraphSkeleton()
jsonpath = ""
nd.load(jsonpath)
skel.load(jsonpath)
bn = DiscreteBayesianNetwork(skel, nd)
tablecpd = TableCPDFactorization(bn)
return tablecpd
def test_hybn_mte_estimateparams(self):
skel = GraphSkeleton()
skel.load("../tests/bn_skeleton.txt")
skel.toporder()
with open('../tests/dataBR2.json', 'r') as f:
samples = eval(f.read())
result = self.l.hybn_mte_estimateparams(self.skel, self.samplelgseq)
def q_without_ros():
skel = GraphSkeleton()
skel.V = ["prize_door", "guest_door", "monty_door"]
skel.E = [["prize_door", "monty_door"],
["guest_door", "monty_door"]]
skel.toporder()
nd = NodeData()
nd.Vdata = {
"prize_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0/3, 1.0/3, 1.0/3],
},
"guest_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0/3, 1.0/3, 1.0/3],
},
"monty_door": {
"numoutcomes": 3,
"parents": ["prize_door", "guest_door"],
"children": None,
"vals": ["A", "B", "C"],
"cprob": {
"['A', 'A']": [0., 0.5, 0.5],
"['B', 'B']": [0.5, 0., 0.5],
"['C', 'C']": [0.5, 0.5, 0.],
"['A', 'B']": [0., 0., 1.],
"['A', 'C']": [0., 1., 0.],
"['B', 'A']": [0., 0., 1.],
"['B', 'C']": [1., 0., 0.],
"['C', 'A']": [0., 1., 0.],
"['C', 'B']": [1., 0., 0.],
},
},
}
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
query = {
"prize_door": ["A","B","C"],
}
evidence = {
"guest_door": "A",
"monty_door": "B",
}
res = fn.condprobve(query, evidence)
print res.vals
print res.scope
print res.card
print res.stride
def getTableCPD():
nd = NodeData()
skel = GraphSkeleton()
jsonpath = "./graph/graph_example.txt"
nd.load(jsonpath)
skel.load(jsonpath)
# load Bayesian network
bn = DiscreteBayesianNetwork(skel, nd)
tablecpd = TableCPDFactorization(bn)
return tablecpd
def test_libpgm(df1):
data = df1.T.to_dict().values()
#pprint(data)
skel = GraphSkeleton()
skel.load("bn_struct.txt")
learner = PGMLearner()
result = learner.discrete_mle_estimateparams(skel, data)
print json.dumps(result.Vdata, indent=2)
class TestOrderedSkeleton(unittest.TestCase):
def setUp(self):
self.os = OrderedSkeleton()
self.os.load("unittestdict.txt")
self.gs = GraphSkeleton()
self.gs.load("unittestdict.txt")
def test_constructor(self):
self.assertNotEqual(self.os.V, self.gs.V)
self.gs.toporder()
self.assertEqual(self.os.V, self.gs.V)
def getTableCPD(): nd = NodeData() skel = GraphSkeleton() jsonpath = "job_interview.txt" nd.load(jsonpath) skel.load(jsonpath) #load bayesian network bn = DiscreteBayesianNetwork(skel, nd) tablecpd = TableCPDFactorization(bn) return tablecpd
def load(self, file_name):
#### Load BN
nd = NodeData()
skel = GraphSkeleton()
nd.load(file_name) # any input file
skel.load(file_name)
# topologically order graphskeleton
skel.toporder()
super(DiscreteBayesianNetworkExt, self).__init__(skel, nd)
##TODO load evidence
class TestOrderedSkeleton(unittest.TestCase):
def setUp(self):
self.os = OrderedSkeleton()
self.os.load("unittestdict.txt")
self.gs = GraphSkeleton()
self.gs.load("unittestdict.txt")
def test_constructor(self):
self.assertNotEqual(self.os.V, self.gs.V)
self.gs.toporder()
self.assertEqual(self.os.V, self.gs.V)
class TestDynDiscBayesianNetwork(unittest.TestCase):
def setUp(self):
self.nd = NodeData.load("unittestdyndict.txt")
self.skel = GraphSkeleton()
self.skel.load("unittestdyndict.txt")
self.skel.toporder()
self.d = DynDiscBayesianNetwork(self.skel, self.nd)
def test_randomsample(self):
sample = self.d.randomsample(10)
for i in range(1, 10):
self.assertEqual(sample[0]['Difficulty'], sample[i]['Difficulty'])
class TestDynDiscBayesianNetwork(unittest.TestCase):
def setUp(self):
self.nd = NodeData.load("unittestdyndict.txt")
self.skel = GraphSkeleton()
self.skel.load("unittestdyndict.txt")
self.skel.toporder()
self.d = DynDiscBayesianNetwork(self.skel, self.nd)
def test_randomsample(self):
sample = self.d.randomsample(10)
for i in range(1, 10):
self.assertEqual(sample[0]['Difficulty'], sample[i]['Difficulty'])
def getBNparams(graph, ddata, n):
# Gets Disc. BN parameters given a graph skeleton
#skeleton should include t-1 and t nodes for each variable
nodes = range(1, (n * 2) + 1)
nodes = map(str, nodes)
edges = gk.edgelist(graph)
for i in range(len(edges)):
edges[i] = list([edges[i][0], str(n + int(edges[i][1]))])
skel = GraphSkeleton()
skel.V = nodes
skel.E = edges
learner = PGMLearner()
result = learner.discrete_mle_estimateparams(skel, ddata)
return result
class TestHyBayesianNetwork(unittest.TestCase):
def setUp(self):
self.nd = HybridNodeData.load("unittesthdict.txt")
self.nd.entriestoinstances()
self.skel = GraphSkeleton()
self.skel.load("unittestdict.txt")
self.skel.toporder()
self.hybn = HyBayesianNetwork(self.skel, self.nd)
def test_randomsample(self):
sample = self.hybn.randomsample(1)[0]
self.assertTrue(isinstance(sample['Grade'], float))
self.assertTrue(isinstance(sample['Intelligence'], str))
self.assertEqual(sample["SAT"][-12:], 'blueberries!')
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(nodedata)
agg = SampleAggregator()
agg.aggregate(self.bn.randomsample(50))
self.rseq = agg.seq
self.ravg = agg.avg
self.fn = TableCPDFactorization(self.bn)
evidence = dict(Letter='weak')
agg.aggregate(self.fn.gibbssample(evidence, 51))
self.gseq = agg.seq
self.gavg = agg.avg
class TestHyBayesianNetwork(unittest.TestCase):
def setUp(self):
self.nd = HybridNodeData.load("unittesthdict.txt")
self.nd.entriestoinstances()
self.skel = GraphSkeleton()
self.skel.load("unittestdict.txt")
self.skel.toporder()
self.hybn = HyBayesianNetwork(self.skel, self.nd)
def test_randomsample(self):
sample = self.hybn.randomsample(1)[0]
self.assertTrue(isinstance(sample['Grade'], float))
self.assertTrue(isinstance(sample['Intelligence'], str))
self.assertEqual(sample["SAT"][-12:], 'blueberries!')
def setUp(self):
self.nd = NodeData()
self.nd.load("unittestdyndict.txt")
self.skel = GraphSkeleton()
self.skel.load("unittestdyndict.txt")
self.skel.toporder()
self.d = DynDiscBayesianNetwork(self.skel, self.nd)
def setUp(self):
self.nd = HybridNodeData.load("unittesthdict.txt")
self.nd.entriestoinstances()
self.skel = GraphSkeleton()
self.skel.load("unittestdict.txt")
self.skel.toporder()
self.hybn = HyBayesianNetwork(self.skel, self.nd)
def createData(): nd = NodeData() skel = GraphSkeleton() fpath = "job_interview.txt" nd.load(fpath) skel.load(fpath) skel.toporder() bn = DiscreteBayesianNetwork(skel, nd) learner = PGMLearner() data = bn.randomsample(1000) X, Y = 'Grades', 'Offer' c,p,w=learner.discrete_condind(data, X, Y, ['Interview']) print "independence between X and Y: ", c, " p-value ", p, " witness node: ", w result = learner.discrete_constraint_estimatestruct(data) print result.E
def add_sensor(self, sensor_keys):
for key in sensor_keys:
network_file = open(self.dbn_file_name, 'r')
network_file_data = eval(network_file.read())
network_skeleton = GraphSkeleton()
network_skeleton.V = network_file_data["V"]
network_skeleton.E = network_file_data["E"]
self.network = DynDiscBayesianNetwork()
self.network.V = network_skeleton.V
self.network.E = network_skeleton.E
self.network.initial_Vdata = network_file_data["initial_Vdata"]
self.network.twotbn_Vdata = network_file_data["twotbn_Vdata"]
self.inference_engines[key] = SensorDbnInferenceEngine(self.network)
class TestGraphSkeleton(unittest.TestCase):
def setUp(self):
self.instance = GraphSkeleton()
self.instance.V = [1, 2, 3, 4, 5]
self.instance.E = [[5, 1], [1, 2]]
def test_getparents(self):
self.assertEqual(self.instance.getparents(1), [5])
self.assertEqual(self.instance.getparents(4), [])
def test_getchildren(self):
self.assertEqual(self.instance.getchildren(5), [1])
self.assertEqual(self.instance.getchildren(4), [])
def test_toporder(self):
self.instance.toporder()
self.assertTrue(self.instance.V.index(5) < self.instance.V.index(1))
self.assertTrue(self.instance.V.index(5) < self.instance.V.index(2))
def net2():
nd = NodeData()
skel = GraphSkeleton()
nd.load("net.txt") # an input file
skel.load("net.txt")
# topologically order graphskeleton
skel.toporder()
# load bayesian network
lgbn = LGBayesianNetwork(skel, nd)
in_data=read_data.getdata2()
learner = PGMLearner()
bn=learner.lg_mle_estimateparams(skel,in_data)
p=cal_prob(in_data[300:500],bn)
print p
return 0
def ConstructDynBN(num_graph, numvalues, A, ss):
graph = conv.ian2g(num_graph)
print(graph)
V, E, initVdata = INITdata(graph, numvalues)
tfVdata = gettfVdata(num_graph, numvalues, A)
d = DynDiscBayesianNetwork()
skel = GraphSkeleton()
skel.V = V
skel.E = E
d.V = skel.V
d.E = skel.E
d.initial_Vdata = initVdata
d.twotbn_Vdata = tfVdata
print(d.V)
print(d.E)
print(d.initial_Vdata)
print(d.twotbn_Vdata)
data = sampleBN(d, ss)
return data
class TestGraphSkeleton(unittest.TestCase):
def setUp(self):
self.instance = GraphSkeleton()
self.instance.V = [1,2,3,4,5]
self.instance.E = [[5,1],[1,2]]
def test_getparents(self):
self.assertEqual(self.instance.getparents(1), [5])
self.assertEqual(self.instance.getparents(4), [])
def test_getchildren(self):
self.assertEqual(self.instance.getchildren(5), [1])
self.assertEqual(self.instance.getchildren(4), [])
def test_toporder(self):
self.instance.toporder()
self.assertTrue(self.instance.V.index(5)<self.instance.V.index(1))
self.assertTrue(self.instance.V.index(5)<self.instance.V.index(2))
def BNskelFromCSV(csvdata, targets):
#TODO: must know how to swap direction of too many inputs into a node
######## EXTRACT HEADER STRINGS FROM CSV FILE ########
skel = GraphSkeleton()
BNstructure = {}
inputVerts = []
# if data is a filepath
if isinstance(csvdata, basestring):
dataset = []
with open(csvdata, 'rb') as csvfile:
lines = csv.reader(csvfile)
for row in lines:
dataset.append(row)
allVertices = dataset[0]
else:
allVertices = csvdata[0]
BNstructure['V'] = allVertices
skel.V = allVertices
for verts in allVertices:
if verts not in targets:
inputVerts.append(verts)
#target, each input
edges = []
if len(inputVerts) > len(targets):
for target in targets:
for input in inputVerts:
edge = [target, input]
edges.append(edge)
BNstructure['E'] = edges
skel.E = edges
else:
for input in inputVerts:
for target in targets:
edge = [input, target]
edges.append(edge)
BNstructure['E'] = edges
skel.E = edges
skel.toporder()
return skel
def setUp(self):
# instantiate learner
self.l = PGMLearner()
# generate graph skeleton
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
# generate sample sequence to try to learn from - discrete
nd = NodeData.load("unittestdict.txt")
self.samplediscbn = DiscreteBayesianNetwork(nd)
self.samplediscseq = self.samplediscbn.randomsample(5000)
# generate sample sequence to try to learn from - discrete
nda = NodeData.load("unittestlgdict.txt")
self.samplelgbn = LGBayesianNetwork(nda)
self.samplelgseq = self.samplelgbn.randomsample(10000)
self.skel = skel
def test_structure_estimation(self):
req = DiscreteStructureEstimationRequest()
skel = GraphSkeleton()
skel.load(self.data_path)
skel.toporder()
teacher_nd = NodeData()
teacher_nd.load(self.teacher_data_path)
bn = DiscreteBayesianNetwork(skel, teacher_nd)
data = bn.randomsample(8000)
for v in data:
gs = DiscreteGraphState()
for k_s, v_s in v.items():
gs.node_states.append(DiscreteNodeState(node=k_s, state=v_s))
req.states.append(gs)
res = self.struct_estimate(req)
self.assertIsNotNone(res.graph)
self.assertEqual(len(res.graph.nodes), 5)
self.assertGreater(len(res.graph.edges), 0)
def setUp(self):
nodedata = NodeData.load("unittestlgdict.txt")
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
self.lgb = LGBayesianNetwork(nodedata)
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(nodedata)
self.fn = TableCPDFactorization(self.bn)
def set_bayesnet(self):
nd = NodeData()
skel = GraphSkeleton()
nd.load(self.file)
skel.load(self.file)
skel.toporder()
self.bn = DiscreteBayesianNetwork(skel, nd)
def buildBN(trainingData, binstyleDict, numbinsDict,
**kwargs): # need to modify to accept skel or skelfile
discretized_training_data, bin_ranges = discretizeTrainingData(
trainingData, binstyleDict, numbinsDict, True)
print 'discret training ', discretized_training_data
if 'skel' in kwargs:
# load file into skeleton
if isinstance(kwargs['skel'], basestring):
skel = GraphSkeleton()
skel.load(kwargs['skel'])
skel.toporder()
else:
skel = kwargs['skel']
# learn bayesian network
learner = PGMLearner()
# baynet = learner.discrete_mle_estimateparams(skel, discretized_training_data)
# baynet = discrete_estimatebn(learner, discretized_training_data, skel, 0.05, 1)
baynet = discrete_mle_estimateparams2(
skel, discretized_training_data
) # using discrete_mle_estimateparams2 written as function in this file, not calling from libpgm
return baynet
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData()
nodedata.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(skel, nodedata)
def main():
in_data=read_data.getdata()
f_data=format_data(in_data)
nd = NodeData()
nd.load("net4.txt") # an input file
skel = GraphSkeleton()
skel.load("net4.txt")
skel.toporder()
bn=DiscreteBayesianNetwork(skel,nd)
#training dataset:70%
bn2=em(f_data[1:6000],bn,skel)
pr_training = precision(f_data[1:6000],bn2)
print "Prediction accuracy for training data:" , pr_training[1]
#testing dataset:30%
pr=precision(f_data[6700:6800],bn2)
print "Prediction accuracy for test data:", pr[1]
def test_param_estimation(self):
req = DiscreteParameterEstimationRequest()
# load graph structure
skel = GraphSkeleton()
skel.load(self.data_path)
req.graph.nodes = skel.V
req.graph.edges = [GraphEdge(k, v) for k,v in skel.E]
skel.toporder()
# generate trial data
teacher_nd = NodeData()
teacher_nd.load(self.teacher_data_path)
bn = DiscreteBayesianNetwork(skel, teacher_nd)
data = bn.randomsample(200)
for v in data:
gs = DiscreteGraphState()
for k_s, v_s in v.items():
gs.node_states.append(DiscreteNodeState(node=k_s, state=v_s))
req.states.append(gs)
self.assertEqual(len(self.param_estimate(req).nodes), 5)
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(nodedata)
self.factor = TableCPDFactor("Grade", self.instance)
self.factor2 = TableCPDFactor("Letter", self.instance)
def setup(self):
self.nd = NodeData()
self.skel = GraphSkeleton()
self.skel.V, self.skel.E = [], []
self.nd.Vdata = {}
for i, node in enumerate(self.node.values()):
dNode = {}
node.sId = str(i)
dNode["numoutcomes"] = len(node.values)
dNode["vals"] = node.values
dNode["cprob"] = node.cpt
# dNode["parents"] = map(lambda x: if x=x.name, node.parents);
self.skel.V.append(node.name)
aParents = []
for parent in node.parents:
if parent == None: continue
aParents.append(parent.name)
self.skel.E.append([parent.name, node.name])
dNode["parents"] = aParents if len(aParents) > 0 else None
self.nd.Vdata[node.name] = dNode
self.skel.toporder()
self.bn = DiscreteBayesianNetwork(self.skel, self.nd)
self.fn = TableCPDFactorization(self.bn)
def q_without_ros():
skel = GraphSkeleton()
skel.V = ["prize_door", "guest_door", "monty_door"]
skel.E = [["prize_door", "monty_door"], ["guest_door", "monty_door"]]
skel.toporder()
nd = NodeData()
nd.Vdata = {
"prize_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0 / 3, 1.0 / 3, 1.0 / 3],
},
"guest_door": {
"numoutcomes": 3,
"parents": None,
"children": ["monty_door"],
"vals": ["A", "B", "C"],
"cprob": [1.0 / 3, 1.0 / 3, 1.0 / 3],
},
"monty_door": {
"numoutcomes": 3,
"parents": ["prize_door", "guest_door"],
"children": None,
"vals": ["A", "B", "C"],
"cprob": {
"['A', 'A']": [0., 0.5, 0.5],
"['B', 'B']": [0.5, 0., 0.5],
"['C', 'C']": [0.5, 0.5, 0.],
"['A', 'B']": [0., 0., 1.],
"['A', 'C']": [0., 1., 0.],
"['B', 'A']": [0., 0., 1.],
"['B', 'C']": [1., 0., 0.],
"['C', 'A']": [0., 1., 0.],
"['C', 'B']": [1., 0., 0.],
},
},
}
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
query = {
"prize_door": ["A", "B", "C"],
}
evidence = {
"guest_door": "A",
"monty_door": "B",
}
res = fn.condprobve(query, evidence)
print res.vals
print res.scope
print res.card
print res.stride
def load(self, file_name):
#### Load BN
nd = NodeData()
skel = GraphSkeleton()
nd.load(file_name) # any input file
skel.load(file_name)
# topologically order graphskeleton
skel.toporder()
super(DiscreteBayesianNetworkExt, self).__init__(skel, nd)
def learnBN(fdata_array, bn_file):
bn_path = os.path.join(experiment_dir, 'parameters', bn_file + '.txt')
skel = GraphSkeleton()
skel.load(bn_path)
skel.toporder()
learner = PGMLearner()
bn = learner.discrete_mle_estimateparams(skel, fdata_array)
return bn
def loadbn(param_file):
"""
This function loads the bn model into the workspace from its associated .txt file.
"""
file_path = os.path.join(experiment_dir, 'parameters', param_file + '.txt')
nd = NodeData()
skel = GraphSkeleton()
nd.load(file_path)
skel.load(file_path)
skel.toporder()
bn = DiscreteBayesianNetwork(skel, nd)
return bn
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(nodedata)
agg = SampleAggregator()
agg.aggregate(self.bn.randomsample(50))
self.rseq = agg.seq
self.ravg = agg.avg
self.fn = TableCPDFactorization(self.bn)
evidence = dict(Letter='weak')
agg.aggregate(self.fn.gibbssample(evidence, 51))
self.gseq = agg.seq
self.gavg = agg.avg
def construct(self):
skel = GraphSkeleton()
skel.V = self.nodes.keys()
skel.E = []
for node, ndata in self.nodes.iteritems():
if ndata['parents']:
for p in ndata['parents']:
skel.E.append([p, node])
self.nodes[p]['children'].append(node)
for node, ndata in self.nodes.iteritems():
if len(ndata['children']) == 0:
ndata['children'] = None
data = NodeData()
data.Vdata = self.nodes
skel.toporder()
bn = DiscreteBayesianNetwork(skel, data)
return bn
def net2():
nd = NodeData()
skel = GraphSkeleton()
nd.load("net.txt") # an input file
skel.load("net.txt")
# topologically order graphskeleton
skel.toporder()
# load bayesian network
lgbn = LGBayesianNetwork(skel, nd)
in_data = read_data.getdata2()
learner = PGMLearner()
bn = learner.lg_mle_estimateparams(skel, in_data)
p = cal_prob(in_data[300:500], bn)
print p
return 0
def test_structure_estimation(self):
req = DiscreteStructureEstimationRequest()
skel = GraphSkeleton()
skel.load(self.data_path)
skel.toporder()
teacher_nd = NodeData()
teacher_nd.load(self.teacher_data_path)
bn = DiscreteBayesianNetwork(skel, teacher_nd)
data = bn.randomsample(8000)
for v in data:
gs = DiscreteGraphState()
for k_s, v_s in v.items():
gs.node_states.append(DiscreteNodeState(node=k_s, state=v_s))
req.states.append(gs)
res = self.struct_estimate(req)
self.assertIsNotNone(res.graph)
self.assertEqual(len(res.graph.nodes), 5)
self.assertGreater(len(res.graph.edges), 0)
def setUp(self):
# instantiate learner
self.l = PGMLearner()
# generate graph skeleton
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
# generate sample sequence to try to learn from - discrete
nd = NodeData.load("unittestdict.txt")
self.samplediscbn = DiscreteBayesianNetwork(nd)
self.samplediscseq = self.samplediscbn.randomsample(5000)
# generate sample sequence to try to learn from - discrete
nda = NodeData.load("unittestlgdict.txt")
self.samplelgbn = LGBayesianNetwork(nda)
self.samplelgseq = self.samplelgbn.randomsample(10000)
self.skel = skel
def main():
in_data = read_data.getdata()
f_data = format_data(in_data)
nd = NodeData()
nd.load("net4.txt") # an input file
skel = GraphSkeleton()
skel.load("net4.txt")
skel.toporder()
bn = DiscreteBayesianNetwork(skel, nd)
#training dataset:70%
bn2 = em(f_data[1:6000], bn, skel)
pr_training = precision(f_data[1:6000], bn2)
print "Prediction accuracy for training data:", pr_training[1]
#testing dataset:30%
pr = precision(f_data[6700:6800], bn2)
print "Prediction accuracy for test data:", pr[1]
import sys
import string
from libpgm.graphskeleton import GraphSkeleton
from libpgm.tablecpdfactorization import TableCPDFactorization
from libpgm.pgmlearner import PGMLearner
text = open("../unifiedMLData2.json")
data=text.read()
printable = set(string.printable)
asciiData=filter(lambda x: x in printable, data)
listofDicts=json.loads(asciiData)
skel = GraphSkeleton()
skel.load("../skeleton.json")
learner = PGMLearner()
result = learner.discrete_mle_estimateparams(skel, listofDicts)
tcf=TableCPDFactorization(result)
#Rating 1 Given Genre is Drama
myquery = dict(rating=[1])
myevidence = dict(genre='Drama')
result=tcf.specificquery(query=myquery,evidence=myevidence)
print result
def Threshold(list):
temp = []
#temp.append(min(list)+float(max(list) - min(list))*1/3)
#temp.append(min(list)+float(max(list) - min(list))*2/3)
temp.append(float(max(list))/3)
temp.append(float(max(list))/3*2)
return temp
EachLikeThreshold = Threshold(EachLike)
EachLikedThreshold = Threshold(EachLiked)
print EachLikeThreshold
print EachLikedThreshold
BulliedPro = []
nd = NodeData()
skel = GraphSkeleton()
nd.load('unittestdict.txt')
skel.load('unittestdict.txt')
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
for i in range(len(EachLike)):
evidence = {}
if EachLike[i] <= EachLikeThreshold[0]:
evidence['LikeN'] = 'Small'
elif EachLikeThreshold[0] < EachLike[i] and EachLike[i] <= EachLikeThreshold[1]:
evidence['LikeN'] = 'Mid'
else:
evidence['LikeN'] = 'Big'
if EachLiked[i] <= EachLikedThreshold[0]:
evidence['LikedN'] = 'Small'
def graph_skeleton_from_ros(graph_structure):
skel = GraphSkeleton()
skel.V = graph_structure.nodes
skel.E = [[e.node_from, e.node_to] for e in graph_structure.edges]
return skel
def setUp(self):
self.os = OrderedSkeleton()
self.os.load("unittestdict.txt")
self.gs = GraphSkeleton()
self.gs.load("unittestdict.txt")
data_l = []
for line in data_r.readlines():
data_l.append(map(int, line.split()))
truth_l = []
for row in truth_r:
truth_l.append(row[0])
w = csv.writer(open("bayesian_outcome.txt", "wb"))
count = 0
for i in range(104):
nd = NodeData()
skel = GraphSkeleton()
nd.load('bayes_net/'+str(i)+".txt") # any input file
skel.load('bayes_net/'+str(i)+".txt")
# topologically order graphskeleton
skel.toporder()
# load bayesian network
# load bayesian network
bn = DiscreteBayesianNetwork(skel, nd)
dic1 = {}
k = 1
for c in data_l[i]:
dic1[str(k)] = str(c)
k += 2
def setUp(self):
self.instance = GraphSkeleton()
self.instance.V = [1,2,3,4,5]
self.instance.E = [[5,1],[1,2]]
def learnDiscreteBN_with_structure(df, continous_columns, features_column_names, label_column='cat',
draw_network=False):
features_df = df.copy()
features_df = features_df.drop(label_column, axis=1)
labels_df = DataFrame()
labels_df[label_column] = df[label_column].copy()
for i in continous_columns:
bins = np.arange((min(features_df[i])), (max(features_df[i])),
((max(features_df[i]) - min(features_df[i])) / 5.0))
features_df[i] = pandas.np.digitize(features_df[i], bins=bins)
data = []
for index, row in features_df.iterrows():
dict = {}
for i in features_column_names:
dict[i] = row[i]
dict[label_column] = labels_df[label_column][index]
data.append(dict)
print "Init done"
learner = PGMLearner()
graph = GraphSkeleton()
graph.V = []
graph.E = []
graph.V.append(label_column)
for vertice in features_column_names:
graph.V.append(vertice)
graph.E.append([vertice, label_column])
test = learner.discrete_mle_estimateparams(graphskeleton=graph, data=data)
print "done learning"
edges = test.E
vertices = test.V
probas = test.Vdata
# print probas
dot_string = 'digraph BN{\n'
dot_string += 'node[fontname="Arial"];\n'
dataframes = {}
print "save data"
for vertice in vertices:
print "New vertice: " + str(vertice)
dataframe = DataFrame()
pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(probas[vertice])
dot_string += vertice.replace(" ", "_") + ' [label="' + vertice + '\n' + '" ]; \n'
if len(probas[vertice]['parents']) == 0:
dataframe['Outcome'] = None
dataframe['Probability'] = None
vertex_dict = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
vertex_dict[str(outcome)] = probas[vertice]["cprob"][index_outcome]
od = collections.OrderedDict(sorted(vertex_dict.items()))
# print "Vertice: " + str(vertice)
# print "%-7s|%-11s" % ("Outcome", "Probability")
# print "-------------------"
for k, v in od.iteritems():
# print "%-7s|%-11s" % (str(k), str(round(v, 3)))
dataframe.loc[len(dataframe)] = [k, v]
dataframes[vertice] = dataframe
else:
# pp.pprint(probas[vertice])
dataframe['Outcome'] = None
vertexen = {}
for index_outcome, outcome in enumerate(probas[vertice]['vals']):
temp = []
for parent_index, parent in enumerate(probas[vertice]["parents"]):
# print str([str(float(index_outcome))])
temp = probas[vertice]["cprob"]
dataframe[parent] = None
vertexen[str(outcome)] = temp
dataframe['Probability'] = None
od = collections.OrderedDict(sorted(vertexen.items()))
# [str(float(i)) for i in ast.literal_eval(key)]
# str(v[key][int(float(k))-1])
# print "Vertice: " + str(vertice) + " with parents: " + str(probas[vertice]['parents'])
# print "Outcome" + "\t\t" + '\t\t'.join(probas[vertice]['parents']) + "\t\tProbability"
# print "------------" * len(probas[vertice]['parents']) *3
# pp.pprint(od.values())
counter = 0
# print number_of_cols
for outcome, cprobs in od.iteritems():
for key in cprobs.keys():
array_frame = []
array_frame.append((outcome))
print_string = str(outcome) + "\t\t"
for parent_value, parent in enumerate([i for i in ast.literal_eval(key)]):
# print "parent-value:"+str(parent_value)
# print "parten:"+str(parent)
array_frame.append(int(float(parent)))
# print "lengte array_frame: "+str(len(array_frame))
print_string += parent + "\t\t"
array_frame.append(cprobs[key][counter])
# print "lengte array_frame (2): "+str(len(array_frame))
# print cprobs[key][counter]
print_string += str(cprobs[key][counter]) + "\t"
# for stront in [str(round(float(i), 3)) for i in ast.literal_eval(key)]:
# print_string += stront + "\t\t"
# print "print string: " + print_string
# print "array_frame:" + str(array_frame)
dataframe.loc[len(dataframe)] = array_frame
counter += 1
print "Vertice " + str(vertice) + " done"
dataframes[vertice] = dataframe
for edge in edges:
dot_string += edge[0].replace(" ", "_") + ' -> ' + edge[1].replace(" ", "_") + ';\n'
dot_string += '}'
# src = Source(dot_string)
# src.render('../data/BN', view=draw_network)
# src.render('../data/BN', view=False)
print "vizualisation done"
return dataframes