def bayesNetCont(textFile,unique):
cleanText(textFile,'tempOutput.txt')
## imports textFile into pandas
try:
df = pd.read_csv('tempOutput.txt', sep='\s+',dtype='float64',header=None)
except:
print 'next file'
return
df.fillna(0, inplace=True)
df.convert_objects(convert_numeric=True)
## set to either setUnique() or setMax()
if unique is True:
grouped = setUnique(df)
else:
grouped = setMax(df)
#turns into correct dictionary format for libpgm
newDict = DFtoLibpgm(grouped)
# instantiate my learner
learner = PGMLearner()
# estimate structure
#gaussian
try:
result = learner.lg_constraint_estimatestruct(newDict)
except:
print 'error'
return
# output
return result
def bayesNet(textFile):
cleanText(textFile, 'tempOutput.txt')
## imports textFile into pandas
try:
df = pd.read_csv('tempOutput.txt',
sep='\s+',
dtype='float32',
header=None)
except:
print 'next file'
return
df.fillna(0, inplace=True)
df.convert_objects(convert_numeric=True)
##
for i, row in df.iterrows():
print df.ix[0, i]
df.ix[0, i] = df.ix[0, i] + str(i)
grouped = df.set_index([0], verify_integrity=True)
df2 = grouped.to_dict()
print json.dumps(df2, indent=2)
newDict = []
for key in df2.keys():
newDict.append(df2[key])
#print json.dumps(newDict, indent=2)
# instantiate my learner
learner = PGMLearner()
# estimate structure
result = learner.lg_constraint_estimatestruct(newDict)
# output
return json.dumps(result.E, indent=2)
def bayesNet(textFile):
cleanText(textFile,'tempOutput.txt')
## imports textFile into pandas
try:
df = pd.read_csv('tempOutput.txt', sep='\s+',dtype='float32',header=None)
except:
print 'next file'
return
df.fillna(0, inplace=True)
df.convert_objects(convert_numeric=True)
##
for i, row in df.iterrows():
print df.ix[0,i]
df.ix[0,i] = df.ix[0,i] + str(i)
grouped = df.set_index([0], verify_integrity=True)
df2 = grouped.to_dict()
print json.dumps(df2, indent=2)
newDict = []
for key in df2.keys():
newDict.append(df2[key])
#print json.dumps(newDict, indent=2)
# instantiate my learner
learner = PGMLearner()
# estimate structure
result = learner.lg_constraint_estimatestruct(newDict)
# output
return json.dumps(result.E, indent=2)
def bayesNetCont(textFile, unique):
cleanText(textFile, 'tempOutput.txt')
## imports textFile into pandas
try:
df = pd.read_csv('tempOutput.txt',
sep='\s+',
dtype='float64',
header=None)
except:
print 'next file'
return
df.fillna(0, inplace=True)
df.convert_objects(convert_numeric=True)
## set to either setUnique() or setMax()
if unique is True:
grouped = setUnique(df)
else:
grouped = setMax(df)
#turns into correct dictionary format for libpgm
newDict = DFtoLibpgm(grouped)
# instantiate my learner
learner = PGMLearner()
# estimate structure
#gaussian
try:
result = learner.lg_constraint_estimatestruct(newDict)
except:
print 'error'
return
# output
return result
import json
from libpgm.nodedata import NodeData
from libpgm.graphskeleton import GraphSkeleton
from libpgm.lgbayesiannetwork import LGBayesianNetwork
from libpgm.pgmlearner import PGMLearner
# generate some data to use
nd = NodeData()
nd.load("gaussGrades.txt") # an input file
skel = GraphSkeleton()
skel.load("gaussGrades.txt")
skel.toporder()
lgbn = LGBayesianNetwork(skel, nd)
data = lgbn.randomsample(8000)
print data
# instantiate my learner
learner = PGMLearner()
# estimate structure
result = learner.lg_constraint_estimatestruct(data)
# output
print json.dumps(result.E, indent=2)
class TestPGMLearner(unittest.TestCase):
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()
nd.load("unittestdict.txt")
self.samplediscbn = DiscreteBayesianNetwork(skel, nd)
self.samplediscseq = self.samplediscbn.randomsample(5000)
# generate sample sequence to try to learn from - discrete
nda = NodeData()
nda.load("unittestlgdict.txt")
self.samplelgbn = LGBayesianNetwork(skel, nda)
self.samplelgseq = self.samplelgbn.randomsample(10000)
self.skel = skel
def test_discrete_mle_estimateparams(self):
result = self.l.discrete_mle_estimateparams(self.skel, self.samplediscseq)
indexa = result.Vdata['SAT']['vals'].index('lowscore')
self.assertTrue(result.Vdata['SAT']['cprob']["['low']"][indexa] < 1 and result.Vdata['SAT']['cprob']["['low']"][indexa] > .9)
indexb = result.Vdata['Letter']['vals'].index('weak')
self.assertTrue(result.Vdata['Letter']['cprob']["['A']"][indexb] < .15 and result.Vdata['Letter']['cprob']["['A']"][indexb] > .05)
def test_lg_mle_estimateparams(self):
result = self.l.lg_mle_estimateparams(self.skel, self.samplelgseq)
self.assertTrue(result.Vdata['SAT']['mean_base'] < 15 and result.Vdata['SAT']['mean_base'] > 5)
self.assertTrue(result.Vdata['Letter']['variance'] < 15 and result.Vdata['Letter']['variance'] > 5)
def test_discrete_constraint_estimatestruct(self):
result = self.l.discrete_constraint_estimatestruct(self.samplediscseq)
self.assertTrue(["Difficulty", "Grade"] in result.E)
def test_lg_constraint_estimatestruct(self):
result = self.l.lg_constraint_estimatestruct(self.samplelgseq)
self.assertTrue(["Intelligence", "Grade"] in result.E)
def test_discrete_condind(self):
chi, pv, witness = self.l.discrete_condind(self.samplediscseq, "Difficulty", "Letter", ["Grade"])
self.assertTrue(pv > .05)
self.assertTrue(witness, ["Grade"])
chia, pva, witnessa = self.l.discrete_condind(self.samplediscseq, "Difficulty", "Intelligence", [])
self.assertTrue(pva < .05)
def test_discrete_estimatebn(self):
result = self.l.discrete_estimatebn(self.samplediscseq)
self.assertTrue(result.V)
self.assertTrue(result.E)
self.assertTrue(result.Vdata["Difficulty"]["cprob"][0])
def test_lg_estimatebn(self):
result = self.l.lg_estimatebn(self.samplelgseq)
self.assertTrue(result.V)
self.assertTrue(result.E)
self.assertTrue(result.Vdata["Intelligence"]["mean_base"])
class TestPGMLearner(unittest.TestCase):
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()
nd.load("unittestdict.txt")
self.samplediscbn = DiscreteBayesianNetwork(skel, nd)
self.samplediscseq = self.samplediscbn.randomsample(5000)
# generate sample sequence to try to learn from - discrete
nda = NodeData()
nda.load("unittestlgdict.txt")
self.samplelgbn = LGBayesianNetwork(skel, nda)
self.samplelgseq = self.samplelgbn.randomsample(10000)
self.skel = skel
def test_discrete_mle_estimateparams(self):
result = self.l.discrete_mle_estimateparams(self.skel, self.samplediscseq)
indexa = result.Vdata['SAT']['vals'].index('lowscore')
self.assertTrue(result.Vdata['SAT']['cprob']["['low']"][indexa] < 1 and result.Vdata['SAT']['cprob']["['low']"][indexa] > .9)
indexb = result.Vdata['Letter']['vals'].index('weak')
self.assertTrue(result.Vdata['Letter']['cprob']["['A']"][indexb] < .15 and result.Vdata['Letter']['cprob']["['A']"][indexb] > .05)
def test_lg_mle_estimateparams(self):
result = self.l.lg_mle_estimateparams(self.skel, self.samplelgseq)
self.assertTrue(result.Vdata['SAT']['mean_base'] < 15 and result.Vdata['SAT']['mean_base'] > 5)
self.assertTrue(result.Vdata['Letter']['variance'] < 15 and result.Vdata['Letter']['variance'] > 5)
def test_discrete_constraint_estimatestruct(self):
result = self.l.discrete_constraint_estimatestruct(self.samplediscseq)
self.assertTrue(["Difficulty", "Grade"] in result.E)
def test_lg_constraint_estimatestruct(self):
result = self.l.lg_constraint_estimatestruct(self.samplelgseq)
self.assertTrue(["Intelligence", "Grade"] in result.E)
def test_discrete_condind(self):
chi, pv, witness = self.l.discrete_condind(self.samplediscseq, "Difficulty", "Letter", ["Grade"])
self.assertTrue(pv > .05)
self.assertTrue(witness, ["Grade"])
chia, pva, witnessa = self.l.discrete_condind(self.samplediscseq, "Difficulty", "Intelligence", [])
self.assertTrue(pva < .05)
def test_discrete_estimatebn(self):
result = self.l.discrete_estimatebn(self.samplediscseq)
self.assertTrue(result.V)
self.assertTrue(result.E)
self.assertTrue(result.Vdata["Difficulty"]["cprob"][0])
def test_lg_estimatebn(self):
result = self.l.lg_estimatebn(self.samplelgseq)
self.assertTrue(result.V)
self.assertTrue(result.E)
self.assertTrue(result.Vdata["Intelligence"]["mean_base"])
result = learner.lg_mle_estimateparams(skel, data) # output - toggle comment to see #print json.dumps(result.Vdata, indent=2) # (11) ---------------------------------------------------------------------- # Learn a structure of a linear Gaussian Bayesian network, given only data # say I have some data data = lgbn.randomsample(8000) # instantiate my learner learner = PGMLearner() # estimate parameters result = learner.lg_constraint_estimatestruct(data) # output - toggle comment to see #print json.dumps(result.E, indent=2) # (12) ----------------------------------------------------------------------- # Learn entire Bayesian networks # say I have some data data = lgbn.randomsample(8000) # instantiate my learner learner = PGMLearner() # estimate parameters result = learner.lg_estimatebn(data)
def learn(self):
print "ds: ", len(self.dataset)
#print self.dataset
data = []
rw = []
bestreward = -100
for seq in self.dataset:
for state_, action_, reward_ in seq:
if reward_[0] > bestreward:
bestreward = reward_[0]
# find limit for theta
print "bestrw", bestreward
nds = []
lt=[]
ls = []
ltv =[]
lsv=[]
i = 0
for seq in self.dataset:
for state_, action_, reward_ in seq:
# if reward_[0] == 0:
# print state_, action_, reward_
#print state_, reward_
if reward_[0] == bestreward:
ns = (state_, action_[0], reward_[0])
nds.append(ns)
# print state_[0], state_[2], reward_[0], bestreward
t = state_[0]
tv= state_[1]
s = state_[2]
sv = state_[3]
if t > 0.05:
print "hmmm,", i, t
#raise Exception(i)
i += 1
lt.append(t)
ls.append(s)
ltv.append(tv)
lsv.append(sv)
limits = dict(theta=[min(lt),max(lt)],s=[min(ls),max(ls)],thetaV=[min(ltv),max(ltv)],sV=[min(lsv),max(lsv)])
print "limits: ", limits
# print "all good things:", nds
#convert ds
for seq in self.dataset:
for state_, action_, reward_ in seq:
# sample = dict(theta=state_[0],thetaPrime=state_[1],s=state_[2],sPrime=state_[3],Action=action_[0],Reward=reward_[0])
#
#
# dtpo = min( abs(sample["thetaPrime"] - limits["theta"][0]), abs(sample["thetaPrime"] - limits["theta"][1]))
# dto = min( abs(sample["theta"] - limits["theta"][0]), abs(sample["theta"] - limits["theta"][1]))
# dspo = min( abs(sample["sPrime"] - limits["s"][0]), abs(sample["sPrime"] - limits["s"][1]))
# dso = min( abs(sample["s"] - limits["s"][0]), abs(sample["s"] - limits["s"][1]))
#
# #print dspo, dso
#
# netsample = dict(theta=sample["theta"],s=sample["s"],Action=sample["Action"],Reward=sample["Reward"])
# # did this action improve theta or s??
# if dtpo <= dto or dspo <= dso: #yes it did
## data.append(netsample)
# rw.append(sample["Reward"])
sample = dict(theta=state_[0],thetaV=state_[1],s=state_[2],sV=state_[3],Action=action_[0],Reward=reward_[0])
#print state_, action_, reward_
#print sample
if sample["Reward"] != 990:
data.append(sample)
if numpy.random.random() >= 9.1:
continue
import matplotlib.pyplot as plt
import pandas as pd
df = pd.DataFrame(rw)
# print df
# plt.figure()
# df[0].diff().hist()
# instantiate my learner
learner = PGMLearner()
# estimate parameters
rbn = []
for i in range(0,1):
result = learner.lg_constraint_estimatestruct(data,bins=10, pvalparam=0.05)
rbn.append(result)
print len(result.E), result.E
result = rbn[0]
# output - toggle comment to see
print json.dumps(result.V, indent=2)
print len(result.E), "Edges", result.E
import pydot
# this time, in graph_type we specify we want a DIrected GRAPH
graph = pydot.Dot(graph_type='digraph')
nd = {}
for n in result.V:
nd[n] = pydot.Node(n)
graph.add_node(nd[n])
for e in result.E:
graph.add_edge(pydot.Edge(nd[e[0]], nd[e[1]]))
graph.write_png('eg.png')
from IPython.display import Image
Image('eg.png')
f = open('workfile', 'w')
f.write("{\n \"V\":")
f.write(json.dumps(result.V))
f.write(",\n \"E\":")
f.write(json.dumps(result.E))
f.write("}")
f.close()
skel = GraphSkeleton()
skel.load("workfile")
# topologically order graphskeleton
skel.toporder()
return
class PGMLearnerServer(object):
def __init__(self):
self.learner = PGMLearner()
rospy.Service("~discrete/parameter_estimation",
DiscreteParameterEstimation,
self.discrete_parameter_estimation_cb)
rospy.Service("~discrete/query", DiscreteQuery, self.discrete_query_cb)
rospy.Service("~discrete/structure_estimation",
DiscreteStructureEstimation,
self.discrete_structure_estimation_cb)
rospy.Service("~linear_gaussian/parameter_estimation",
LinearGaussianParameterEstimation,
self.lg_parameter_estimation_cb)
rospy.Service("~linear_gaussian/structure_estimation",
LinearGaussianStructureEstimation,
self.lg_structure_estimation_cb)
def discrete_parameter_estimation_cb(self, req):
skel = U.graph_skeleton_from_ros(req.graph)
skel.toporder()
data = U.graph_states_dict_from_ros(req.states)
res = self.learner.discrete_mle_estimateparams(skel, data)
return DiscreteParameterEstimationResponse(
U.discrete_nodes_to_ros(res.Vdata))
def discrete_query_cb(self, req):
nd = U.discrete_nodedata_from_ros(req.nodes)
skel = U.graph_skeleton_from_node_data(nd)
skel.toporder()
bn = DiscreteBayesianNetwork(skel, nd)
fn = TableCPDFactorization(bn)
q = {n: nd.Vdata[n]["vals"] for n in req.query}
ev = {ns.node: ns.state for ns in req.evidence}
rospy.loginfo("resolving query %s with evidence %s" % (q, ev))
ans = fn.condprobve(query=q, evidence=ev)
rospy.loginfo("%s -> %s" % (ans.scope, ans.vals))
res = DiscreteQueryResponse()
node = DiscreteNode()
node.name = ans.scope[0]
node.outcomes = q[node.name]
node.CPT.append(ConditionalProbability(node.outcomes, ans.vals))
res.nodes.append(node)
return res
def discrete_structure_estimation_cb(self, req):
states = [{ns.node: ns.state
for ns in s.node_states} for s in req.states]
pvalparam = 0.05 # default value
indegree = 1 # default value
if req.pvalparam != 0.0:
pvalparam = req.pvalparam
if req.indegree != 0:
indegree = req.indegree
res = self.learner.discrete_constraint_estimatestruct(
states, pvalparam=pvalparam, indegree=indegree)
return DiscreteStructureEstimationResponse(
U.graph_skeleton_to_ros(res))
def lg_parameter_estimation_cb(self, req):
skel = U.graph_skeleton_from_ros(req.graph)
skel.toporder()
data = U.graph_states_dict_from_ros(req.states)
res = self.learner.lg_mle_estimateparams(skel, data)
rospy.logdebug("parameter estimation: %s" % res.Vdata)
return LinearGaussianParameterEstimationResponse(
U.linear_gaussian_nodes_to_ros(res.Vdata))
def lg_structure_estimation_cb(self, req):
states = [{ns.node: ns.state
for ns in s.node_states} for s in req.states]
rospy.logdebug(states)
pvalparam = 0.05 # default value
bins = 10 # default value
indegree = 1 # default value
if req.pvalparam != 0.0:
pvalparam = req.pvalparam
if req.bins != 0:
bins = req.bins
if req.indegree != 0:
indegree = req.indegree
rospy.logdebug("bins: %d, pvalparam: %f, indegree: %d" %
(bins, pvalparam, indegree))
res = self.learner.lg_constraint_estimatestruct(states,
pvalparam=pvalparam,
bins=bins,
indegree=indegree)
rospy.logdebug("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
rospy.logdebug(res.V)
rospy.logdebug(res.E)
return LinearGaussianStructureEstimationResponse(
U.graph_skeleton_to_ros(res))
