class TestSampleAggregator(unittest.TestCase):
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData()
nodedata.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(skel, 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 test_rseq(self):
self.assertTrue(len(self.rseq) == 50)
for key in self.ravg.keys():
summ = 0
for entry in self.ravg[key].keys():
summ += self.ravg[key][entry]
self.assertTrue(summ > .99 and summ < 1.01)
def test_gseq(self):
self.assertTrue(len(self.gseq) == 51)
for key in self.gavg.keys():
summ = 0
for entry in self.gavg[key].keys():
summ += self.gavg[key][entry]
self.assertTrue(summ > .99 and summ < 1.01)
class TestSampleAggregator(unittest.TestCase):
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData()
nodedata.load("unittestdict.txt")
self.bn = DiscreteBayesianNetwork(skel, 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 test_rseq(self):
self.assertTrue(len(self.rseq) == 50)
for key in self.ravg.keys():
summ = 0
for entry in self.ravg[key].keys():
summ += self.ravg[key][entry]
self.assertTrue(summ > .99 and summ < 1.01)
def test_gseq(self):
self.assertTrue(len(self.gseq) == 51)
for key in self.gavg.keys():
summ = 0
for entry in self.gavg[key].keys():
summ += self.gavg[key][entry]
self.assertTrue(summ > .99 and summ < 1.01)
class TestDiscreteBayesianNetwork(unittest.TestCase):
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(nodedata)
def test_randomsample(self):
randomsample = self.instance.randomsample(5)
self.assertTrue(randomsample[0]["Difficulty"] == 'easy' or randomsample[0]["Difficulty"] == 'hard')
for key in randomsample[0].keys():
self.assertTrue(randomsample[0][key] != "default")
def test_randomsamplewithevidence(self):
evidence = dict(Difficulty='easy')
randomsample = self.instance.randomsample(10, evidence)
for entry in randomsample:
self.assertEqual(entry["Difficulty"], 'easy')
class TestDiscreteBayesianNetwork(unittest.TestCase):
def setUp(self):
skel = GraphSkeleton()
skel.load("unittestdict.txt")
skel.toporder()
nodedata = NodeData.load("unittestdict.txt")
self.instance = DiscreteBayesianNetwork(nodedata)
def test_randomsample(self):
randomsample = self.instance.randomsample(5)
self.assertTrue(randomsample[0]["Difficulty"] == 'easy'
or randomsample[0]["Difficulty"] == 'hard')
for key in randomsample[0].keys():
self.assertTrue(randomsample[0][key] != "default")
def test_randomsamplewithevidence(self):
evidence = dict(Difficulty='easy')
randomsample = self.instance.randomsample(10, evidence)
for entry in randomsample:
self.assertEqual(entry["Difficulty"], 'easy')
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 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 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 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 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)
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"])
rospy.init_node("pgm_learner_sample_discrete")
param_estimate = rospy.ServiceProxy(
"pgm_learner/discrete/parameter_estimation",
DiscreteParameterEstimation)
req = DiscreteParameterEstimationRequest()
dpath = os.path.join(PKG_PATH, "test", "graph-test.txt")
tpath = dpath
# load graph structure
skel = GraphSkeleton()
skel.load(dpath)
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(dpath)
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)
PP.pprint(param_estimate(req).nodes)
# Generate a sequence of samples from a discrete-CPD Bayesian network
# load nodedata and graphskeleton
nd = NodeData()
skel = GraphSkeleton()
nd.load("../tests/unittestdict.txt")
skel.load("../tests/unittestdict.txt")
# topologically order graphskeleton
skel.toporder()
# load bayesian network
bn = DiscreteBayesianNetwork(skel, nd)
# sample
result = bn.randomsample(10)
# output - toggle comment to see
#print json.dumps(result, indent=2)
# (2) ----------------------------------------------------------------------
# Generate a sequence of samples from a linear Gaussian-CPD Bayesian network
# load nodedata and graphskeleton
nd = NodeData()
skel = GraphSkeleton()
nd.load("../tests/unittestlgdict.txt")
skel.load("../tests/unittestdict.txt")
# topologically order graphskeleton
skel.toporder()
if __name__ == '__main__':
rospy.init_node("pgm_learner_sample_discrete")
param_estimate = rospy.ServiceProxy("pgm_learner/discrete/parameter_estimation", DiscreteParameterEstimation)
req = DiscreteParameterEstimationRequest()
dpath = os.path.join(PKG_PATH, "test", "graph-test.txt")
tpath = dpath
# load graph structure
skel = GraphSkeleton()
skel.load(dpath)
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(dpath)
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)
PP.pprint(param_estimate(req).nodes)
import json
from libpgm.nodedata import NodeData
from libpgm.graphskeleton import GraphSkeleton
from libpgm.discretebayesiannetwork import DiscreteBayesianNetwork
from libpgm.pgmlearner import PGMLearner
# generate some data to use
nd = NodeData()
nd.load("grades.txt") # an input file
skel = GraphSkeleton()
skel.load("grades.txt")
skel.toporder()
bn = DiscreteBayesianNetwork(skel, nd)
data = bn.randomsample(80000)
# instantiate my learner
learner = PGMLearner()
# estimate structure
result = learner.discrete_constraint_estimatestruct(data)
# output
print json.dumps(result.E, indent=2)
"X3": '1'
}]
X1arms = {0: 0, 1: 1}
X2arms = {0: 2, 1: 3}
X3arms = {0: 4, 1: 5}
regrets2 = []
progress = 0
for i in range(simulations):
if (100 * i) / simulations != progress:
progress += 1
print "part2", progress, "%"
bandit = NetworkBetaBandit(bn, interventions, 'Y')
for j in xrange(experiments):
arm = bandit.get_recommendation()
result = bn.randomsample(1, evidence=bandit.interventions[arm])[0]
# add results for two arms, one for what X1 was and one for what X2 was
a1 = X1arms.get(int(result.get("X1")))
a2 = X2arms.get(int(result.get("X2")))
a3 = X3arms.get(int(result.get("X3")))
reward = result.get('Y')
bandit.add_result(a1, reward)
bandit.add_result(a2, reward)
bandit.add_result(a3, reward)
regrets2.append(bandit.regret(.4))
# a rough estimate how well we do with Causal Bayes Bandit - appears empirically better even in this setting. Now verify theoretically
#print np.mean(regrets2),"+-", stats.sem(regrets2)
o = open("causalreinforceresults.txt", "w")
for i in xrange(simulations):
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"])
# Generate a sequence of samples from a discrete-CPD Bayesian network
# load nodedata and graphskeleton
nd = NodeData()
skel = GraphSkeleton()
nd.load("../tests/unittestdict.txt")
skel.load("../tests/unittestdict.txt")
# topologically order graphskeleton
skel.toporder()
# load bayesian network
bn = DiscreteBayesianNetwork(skel, nd)
# sample
result = bn.randomsample(10)
# output - toggle comment to see
#print json.dumps(result, indent=2)
# (2) ----------------------------------------------------------------------
# Generate a sequence of samples from a linear Gaussian-CPD Bayesian network
# load nodedata and graphskeleton
nd = NodeData()
skel = GraphSkeleton()
nd.load("../tests/unittestlgdict.txt")
skel.load("../tests/unittestdict.txt")
# topologically order graphskeleton
skel.toporder()
import json
from libpgm.nodedata import NodeData
from libpgm.graphskeleton import GraphSkeleton
from libpgm.discretebayesiannetwork import DiscreteBayesianNetwork
from libpgm.pgmlearner import PGMLearner
# generate some data to use
nd = NodeData()
nd.load("grades.txt") # an input file
skel = GraphSkeleton()
skel.load("grades.txt")
skel.toporder()
bn = DiscreteBayesianNetwork(skel, nd)
data = bn.randomsample(80000)
# instantiate my learner
learner = PGMLearner()
# estimate structure
result = learner.discrete_constraint_estimatestruct(data)
# output
print json.dumps(result.E, indent=2)
class BinaryNetworkBandit(object):
"""Class represents a Discrete Bayesian Network that supports Thompson sampling.
Currently only supports interventions on a single variable at a time"""
def __init__(self, bayesnetfile, targetVar = 'Y', prior=(1.0,1.0)):
self.file = bayesnetfile
self.theta_range = linspace(0.0001,0.9999,100)
self.set_bayesnet()
self.y = targetVar
self.reset(prior = prior)
def getCPD(self):
""" required as querying a TableCPDFactorization leads modifies the underlying Bayesian network (refresh() appears broken) """
self.set_bayesnet()
return 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 reset(self,prior=(1.0,1.0)):
""" Clears all the data on samples that have been taken so far but keeps graph structure.
You can optionally specify a new prior"""
# possible single interventions on non-target variable
self.prior = prior
self.interventions = [] # a list of possible assignments
self.variables = [] # store the variables - defines an ordering
self.intervention_to_arm = {}
self.variable_name_to_index = {}
values = []
index = 0
variable_index = 0
for variable, data in self.bn.Vdata.iteritems():
if variable != self.y:
self.variables.append(variable)
self.variable_name_to_index[variable] = variable_index
variable_index +=1
vals = data.get("vals")
values.append(vals)
for value in vals:
self.interventions.append({variable:value})
self.intervention_to_arm[(variable,value)]=index
index +=1
# lets calculate and print the actual value of theta for each arm (since we know it)
truth = []
for i in self.interventions:
cpd = self.getCPD()
answer = cpd.specificquery({self.y:"1"},i)
truth.append(answer)
print "THETA",truth
cpd = self.getCPD() # reset the network to its original state
# generate all possible assignments (intervention on all variables) to non-target values
combinations = list(itertools.product(*values))
self.assignements = [dict(zip(self.variables,v)) for v in combinations]
num_assignments = len(self.assignements)
self.assingment_map = dict(zip([str(list(v)) for v in combinations],range(num_assignments))) # builds a map from a each assingment to its indx
self.atrials = self.trials = zeros(shape=(num_assignments,), dtype=int) # stores how often each assignment occured
self.asuccesses = zeros(shape=(num_assignments,), dtype=int) # stores how often each assignment paid off
self.num_arms = len(self.interventions)
self.trials = zeros(shape=(self.num_arms,), dtype=int) # stores how often each arm was selected
self.successes = zeros(shape=(self.num_arms,), dtype=int) # stores how often each arm paid off
# now here I'm going to assume models where X1 ... Xn mutually independent causes of Y
# record distributions for P(X1), P(X2) ... - they update only when we observe Xn not when we do it
self.observed_trials = zeros(shape=(self.num_arms,), dtype=int)
self.observed_true = zeros(shape=(self.num_arms,), dtype=int)
# records how many times each variable was set by intervention
self.intervened_trials = zeros(shape=(self.num_arms,), dtype=int)
self.intervened_true = zeros(shape=(self.num_arms,), dtype=int)
def sample(self,n,plot=-1):
""" returns n samples based on Thompson sampling """
for i in xrange(n):
if plot > 0 and i % plot == 0:
do_plot = True
else:
do_plot = False
arm = self.get_recommendation(do_plot)
intervention = self.interventions[arm]
# note: evidence is equivelent to do in libpgm
result = self.bn.randomsample(1,evidence=intervention)[0] # returns a dictionary containing values for each variable
reward = int(result.get(self.y))
# update the counts for the pulled arm (P(Y|X?=?))
self.trials[arm] = self.trials[arm] + 1
if (reward == 1):
self.successes[arm] = self.successes[arm] + 1
# for variable we intervened on record that the we intervened
assert(len(interventions.keys())==1)
do_variable = intervention.keys()[0] # ASSUMING SINGLE INTERVENTIONS AT THIS POINT
do_value = intervention.values()[0]
do_variable_indx = self.variable_name_to_index[do_variable]
self.intervened_trials[do_variable_indx] +=1
self.intervened_true[do_variable_indx] +=1
# for all variables we did not intervene on, update observed
values = []
for indx,v in enumerate(self.variables):
value = result[v]
values.append(value)
if v not in intervention:
self.observed_trials[indx] += 1
if int(value) == 1:
self.observed_true[indx]+=1
# update based on intervened and non-intervened ...
# for the pulled arm
self.trials_c[arm] = self.trials_c[arm] + 1
if (reward == 1):
self.successes_c[arm] = self.successes_c[arm] + 1
# each other value in result corresponds to an arm
for k,val in result:
# calculate how much this should be weighted down
otrials = self.observed_trials[do_variable_indx]
oratio = (otrials+self.observed_true[do_variable_indx])/otrials
itrials = self.intervened_trials[do_variable_indx]
isuccess = itrials/
total_success = osuccess+/
w =
if k not in intervention:
o_arm = # get arm corresponding to setting variable k to var
self.trials_c[o_arm] = self.trials_c[o_arm]+w
if reward == 1:
self.successes_c[arm] = self.successes_c[arm] + w
# the value of [arm] occured because of intervention so we need to weight down based on that - going to lead to fractional trials...
# update relevent exact assignment
key = str((values))
a = self.assingment_map[key]
self.atrials[a] = self.atrials[a]+1
if (reward == 1):
self.asuccesses[a] = self.asuccesses[a] + 1
def plot_observed(self):
# put labels under each plot
f,sp = plt.subplots(1,len(self.variables),sharey=False,figsize=(15,5))
for i in range(len(self.variables)):
dist = beta(self.prior[0]+self.observed_true[i], self.prior[1]+self.observed_trials[i]-self.observed_true[i])
sp[i].plot(self.theta_range,dist.pdf(self.theta_range))
plt.show()
def plot_assignments(self):
print self.atrials
print self.asuccesses
f,sp = plt.subplots(1,len(self.assingment_map),sharey=False,figsize=(15,5))
titles = [json.dumps(x) for x in self.assignements]
for i in range(len(self.assingment_map)): # need to get rid of the unicode tags so things fit - dirty way is s.encode('ascii')
dist = beta(self.prior[0]+self.asuccesses[i]+1, self.prior[1]+self.atrials[i]-self.asuccesses[i])
sp[i].set_title(titles[i])
sp[i].plot(self.theta_range,dist.pdf(self.theta_range))
plt.show()
def get_recommendation(self,do_plot=False):
""" recommends which arm to pull next proportional to the estimated probability that it is the optimal one"""
sampled_theta = []
if do_plot:
f,sp = plt.subplots(1,self.num_arms,sharey=False,figsize=(15,5))
for i in range(self.num_arms):
#Construct beta distribution for posterior
dist = beta(self.prior[0]+self.successes[i], self.prior[1]+self.trials[i]-self.successes[i])
if do_plot:
sp[i].plot(self.theta_range,dist.pdf(self.theta_range))
#Draw sample from beta distribution
sampled_theta.append(dist.rvs())
# Alternately calculate P(Y|X1) as sum(P(Y|X1,X2)P(X2))
# Do this here ....
if do_plot:
plt.show()
# Return the index of the sample with the largest value
return sampled_theta.index( max(sampled_theta) )
def regret(self, bestprob):
""" regret as ratio between reward and expectation of reward had we always selected best """
reward = sum(self.successes)/float(sum(self.trials))
optimal = bestprob
return 1 - reward/bestprob
