obsnoiseCPT = training_values[0]
par_obs = [movement_node]
else:
obsnoiseCPT = np.array(
[prob_left, prob_right, prob_remain, prob_brake])
par_obs = []
CPTi = (obsnoiseCPT, par_obs, action_space)
chance_nodes = []
for index_node in range(nr_vehicles):
node_basename = 'car' + str(index_node)
node_name = node_basename + str(time_step)
# print 'Add node' + node_name
chance_nodes.append(
ChanceNode('C' + node_name,
CPTip=CPTi,
basename='C' + node_basename,
time=time_step))
# Mixes movement (node F) with observational noise (node Cseek)
obs_car_nodes = []
for index_node in range(nr_vehicles):
node_basename = 'car' + str(index_node)
node_name = node_basename + str(time_step)
# param_obs = {'loc': root_node, 'noise': chance_nodes, 'car_nr': index_node}
param_obs = {
'car_nr': index_node,
'previous_poses': movement_node
} # , 'decision_nodes': car_decision_nodes}
for index_chance_node in range(nr_vehicles):
# adding the other nodes
a = m[0]
b = m[1]
price = a - b * Q
return price
###########################################
# MARKET Conditions ChanceNode
###########################################
MCPT = np.ones(len(markets)) / len(
markets) # CPT for demand function at Market node
Mparents = [] # no parents for market demand because it is a root node
Mspace = markets # the space of the market node
Mip = (MCPT, Mparents, Mspace) # CPT input tuple
M = ChanceNode('M', CPTip=Mip, description='determine market conditions')
###########################################
# ONE DecisionNode FOR EACH PLAYER
###########################################
# note that 1 observes M but not Q2
Q1 = DecisionNode('Q1', '1', actions, [M], 'Stackelberg leader q')
# note that 2 observes Q1 but not M
Q2 = DecisionNode('Q2', '2', actions, [Q1], 'Stackelberg follower q')
###########################################
# DEMAND DeterNode
###########################################
Dfunc = demand # the deterministic function for the Demand DeterNode
Dparams = {'q1': Q1, 'q2': Q2, 'm': M} # parameter input for Demand DeterNode
Dcont = True
# Create an observational noise for each car : ChanceNode CcarX, no parents
if training_values is not None:
obsnoiseCPT = training_values[index_node]
par_obs = [obs_nodes_prev[index_node]]
else:
obsnoiseCPT = prob_dist_actions
par_obs = []
# obsnoiseCPT = initial_policy
# par_obs = [obs_nodes_prev[index_node]]
CPTi = (obsnoiseCPT, par_obs, action_space)
node_basename = 'car' + str(index_node)
node_name = node_basename + str(time_step)
# print 'Add node' + node_name
chance_nodes.append(ChanceNode('C' + node_name, CPTip=CPTi, basename='C' + node_basename, time=time_step))
# Mixes movement (node F) with observational noise (node Cseek)
obs_car_nodes = []
for index_node in range(nr_vehicles):
node_basename = 'car' + str(index_node)
node_name = node_basename + str(time_step)
# param_obs = {'loc': root_node, 'noise': chance_nodes, 'car_nr': index_node}
param_obs = {'car_nr': index_node, 'previous_status': movement_node} # , 'decision_nodes': car_decision_nodes}
for index_chance_node in range(nr_vehicles):
# adding the other nodes
if index_chance_node is not index_node:
# print 'Chance node ' + str(index_chande_node)
param_obs['Cnode' + str(index_chance_node)] = chance_nodes[index_chance_node]
# obs_car_nodes.append(DeterNode('O' + node_name, adjust_car_obs, param_obs, continuous_f,
return np.vstack((opponent, loc[1]))
##################################################
# THE NODES - first time 0, then 1 to T in a loop
##################################################
# STATE ROOT NODE, DeterNode F
paramsf = {}
continuousf = False
Froot = DeterNode('Froot0', newloc, paramsf, continuousf, space=statespace, basename='Froot', time=0)
# OBSERVATIONAL NOISE for SEEKER, ChanceNode Cseek
parseek = []
CPTipseek = (obsnoiseCPT, parseek, actionspace)
Cseek = ChanceNode('Cseek0', CPTip=CPTipseek, basename='Cseek', time=0)
# OBSERVATIONAL NOISE for HIDER, ChanceNode C2
parhide = []
CPTiphide = (obsnoiseCPT, parhide, actionspace)
Chide = ChanceNode('Chide0', CPTip=CPTiphide, basename='Chide', time=0)
# COMBINE OBS NOISE FOR SEEKER, DeterNode Fseek
paramsseek = {'noise': Cseek, 'loc': Froot}
continuousseek = False
Fseek = DeterNode('Fseek0', adjust_seeker, paramsseek, continuousseek, space=statespace, basename='Fseek', time=0)
# COMBINE OBS NOISE FOR SEEKER, DeterNode Fseek
paramshide = {'noise': Chide, 'loc': Froot}
Fhide = DeterNode('Fhide0', adjust_hider, paramshide, continuousseek, space=statespace, basename='Fhide', time=0)
# SEEKER DecisionNode, Dseek
# STATE ROOT NODE, DeterNode F
params_f = {}
continuous_f = False
root_node = DeterNode('Froot0',
new_localization,
params_f,
continuous_f,
space=statespace,
basename='Froot',
time=0)
# OBSERVATIONAL NOISE for fast car : ChanceNode Cfast, no parents
par_obs_f = []
CPTi_f = (obsnoiseCPT_f, par_obs_f, actionspace_f)
C_fast = ChanceNode('Cfast0', CPTip=CPTi_f, basename='Cfast', time=0)
# OBSERVATIONAL NOISE for slow car : ChanceNode Cslow, no parents
par_obs_s = []
CPTi_s = (obsnoiseCPT_s, par_obs_s, actionspace_s)
C_slow = ChanceNode('Cslow0', CPTip=CPTi_s, basename='Cslow', time=0)
# COMBINE OBS NOISE FOR fast car, DeterNode Ffast.
# Parents chance node of slow car (C_slow) and previous localization (root_node)
params_Obs_fast = {'noise': C_slow, 'loc': root_node}
Obs_fast = DeterNode('Ffast0',
adjust_fast_car_obs,
params_Obs_fast,
continuous_f,
space=statespace,
basename='Ffast0',