def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData()
nodedata.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(skel, nodedata)
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):
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):
nodedata = NodeData.load("unittestlgdict.txt")
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
self.lgb = LGBayesianNetwork(nodedata)
def set_bayesnet(self):
nd = NodeData()
skel = GraphSkeleton()
nd.load(self.file)
skel.load(self.file)
skel.toporder()
self.bn = DiscreteBayesianNetwork(skel, 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 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.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 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 getTableCPD():
nd = NodeData()
skel = GraphSkeleton()
jsonpath = ""
nd.load(jsonpath)
skel.load(jsonpath)
bn = DiscreteBayesianNetwork(skel, nd)
tablecpd = TableCPDFactorization(bn)
return tablecpd
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 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 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)
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 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
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 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
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]
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):
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)
activValsList = ["Away", "Sleeping", "Wandering", "Reading", "Diverse"]
dictionary = set().union(wkdayValsList, hourValsList, locatValsList,
activValsList)
# checking if input from user was approppriate
if set(userinput).issubset(dictionary):
# initializing probabilities lists
wkdayProbList = []
hourProbList = []
locatProbList = []
activProbList = []
#INITIALIZING BN 1
# load nodedata and graphskeleton
nd1 = NodeData()
skel1 = GraphSkeleton()
nd1.load(path_bn1)
skel1.load(path_bn1)
skel1.toporder() # toporder graph skeleton
#INITIALIZING BN 2
# load nodedata and graphskeleton
nd2 = NodeData()
skel2 = GraphSkeleton()
nd2.load(path_bn2)
skel2.load(path_bn2)
skel2.toporder() # toporder graph skeleton
# FINDING NEXT ACTIVITY ATTRIBUTES THROUGH INFERENCE ON BN 1
# wkday variable query
evidence1 = dict(wkdayT0=userinput[0])
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.dumps(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 Occupation is student
myquery = dict(rating=[1])
myevidence = dict(occupation='student')
result = tcf.specificquery(query=myquery, evidence=myevidence)
print result
tcf.refresh()
def bn_learn(attr, cicli, passed_file):
path_to_sentiments = 'sentiment_AFINN'
print "Using AFINN sentiment dictionary"
if attr == 0:
print "Considering tweets' number"
elif attr == 1:
print "Considering averaged number of positive, negative and neutral tweets"
elif attr == 2:
print "Considering averaged value of positive and negative tweets"
elif attr == 3:
print "Considering positive and negative tweets\' increment"
elif attr == 4:
print "Considering bullisment index obtained by number of tweets sentiment"
elif attr == 5:
print "Considering bullisment index obtained by tweets value of sentiment"
print "And considering market trend"
all_data = []
files = [
path_to_sentiments + "/" + file
for file in os.listdir(path_to_sentiments) if file.endswith('.json')
]
for file in files:
with open(file) as sentiment_file:
data = json.load(sentiment_file)
vdata = {}
if attr == 0:
vdata["com"] = data["n_tweets"]
elif attr == 1:
vdata["pos"] = data["n_pos_ave"]
vdata["neg"] = data["n_neg_ave"]
vdata["neu"] = data["n_neu_ave"]
elif attr == 2:
vdata["pos"] = data["pos_val_ave"]
vdata["neg"] = data["neg_val_ave"]
elif attr == 3:
vdata["pos"] = data["pos_inc"]
vdata["neg"] = data["neg_inc"]
elif attr == 4:
vdata["com"] = data["bull_ind"]
elif attr == 5:
vdata["com"] = data["bull_ind_val"]
vdata["market"] = data["market_inc"]
all_data.append(vdata)
skel = GraphSkeleton()
if len(all_data[0]) == 2:
skel.load("network_struct_1_vertex.json")
print "Loading structure with 2 node"
elif len(all_data[0]) == 3:
skel.load("network_struct_2_vertex.json")
print "Loading structure with 3 node"
elif len(all_data[0]) == 4:
skel.load("network_struct_3_vertex.json")
print "Loading structure with 4 node"
skel.toporder()
learner = PGMLearner()
result = learner.lg_mle_estimateparams(skel, all_data)
for key in result.Vdata.keys():
result.Vdata[key]['type'] = 'lg'
prob_pos = prob_neg = prob_neu = 0
for data in all_data:
if data['market'] == 1:
prob_pos += 1
elif data['market'] == 0:
prob_neu += 1
else:
prob_neg += 1
prob_pos = float(prob_pos) / float(len(all_data))
prob_neg = float(prob_neg) / float(len(all_data))
prob_neu = float(prob_neu) / float(len(all_data))
tmp = {}
tmp['numoutcomes'] = len(all_data)
tmp['cprob'] = [prob_pos, prob_neg, prob_neu]
tmp['parents'] = result.Vdata['market']['parents']
tmp['vals'] = ['positive', 'negative', 'neutral']
tmp['type'] = 'discrete'
tmp['children'] = result.Vdata['market']['children']
result.Vdata['market'] = tmp
node = Discrete(result.Vdata["market"])
print "Loading node as Discrete"
estimated, real = mcmc_json(passed_file, attr, cicli, node)
return estimated, real
