def setUp(self): # Create world self.world = World() # Create agents self.tom = Agent('Tom') self.world.addAgent(self.tom) self.jerry = Agent('Jerry') self.world.addAgent(self.jerry)
def run_univariate_function(name, symbol_fmt, func): print('\n*************************************') print('Testing {} function'.format(name)) # PsychSim elements world = World() agent = Agent('The Agent') world.addAgent(agent) # gets samples from real non-linear function x_params, y_params, sample_values = \ get_bivariate_samples(func, MIN_X, MAX_X, MIN_Y, MAX_Y, NUM_SAMPLES, NUM_SAMPLES) sample_mean = np.nanmean(sample_values) # create two features: one holding the variable, the other the result (dependent) var_x = world.defineState(agent.name, 'var_x', float, lo=MIN_X, hi=MAX_X) var_y = world.defineState(agent.name, 'var_y', float, lo=MIN_Y, hi=MAX_Y) result = world.defineState(agent.name, 'result', float, lo=np.min(sample_values), hi=np.max(sample_values)) world.setFeature(result, 0) # create action that is approximates the function, storing the result in the result feature action = agent.addAction({'verb': 'operation', 'action': name}) tree = makeTree( tree_from_bivariate_samples(result, var_x, var_y, x_params, y_params, sample_values)) world.setDynamics(result, action, tree) world.setOrder([agent.name]) np.random.seed(SEED) values_original = [] values_approx = [] for i in range(NUM_TEST_SAMPLES): # gets random sample parameters x = MIN_X + np.random.rand() * (MAX_X - MIN_X) y = MIN_Y + np.random.rand() * (MAX_Y - MIN_Y) # sets variable and updates result world.setFeature(var_x, x) world.setFeature(var_y, y) world.step() real = func(x, y) psych = world.getValue(result) print('{:3}: {:30} | Expected: {:10.2f} | PsychSim: {:10.2f}'.format( i, symbol_fmt.format(x, y), real, psych)) values_original.append(real) values_approx.append(psych) # gets error stats rmse = np.sqrt(np.mean((np.array(values_approx) - values_original)**2)) print('=====================================') print('RMSE = {:.3f}'.format(rmse)) print('\nPress \'Enter\' to continue...') input()
def parseGDELT(fname, targets=[]): """ Extracts events from a single GDELT CSV file """ # Parse filename root, ext = os.path.splitext(os.path.basename(fname)) assert ext == '.csv', 'CSV file expected instead of %s' % (fname) if len(root) == 4: year = int(root) month = 0 else: assert len( root) == 6, 'Filename not in YYYY.csv or YYYYMM.csv format: %s' % ( fname) year = int(root[:4]) month = int(root[4:]) # Initialize storage result = { 'month': month, 'year': year, 'agents': {}, 'matrix': {}, 'calendar': {}, } today = None start = time.time() lines = 0 for line in fileinput.input(fname): lines += 1 # Extract the event fields elements = map(lambda x: x.strip(), line.split('\t')) event = {} for index in range(len(elements)): if len(elements[index]) == 0: event[headings[index]] = None elif headings[index] in intHeadings: event[headings[index]] = int(elements[index]) elif headings[index] in floatHeadings: event[headings[index]] = float(elements[index]) else: event[headings[index]] = elements[index].strip() if event['SQLDATE'] != today: today = event['SQLDATE'] events = [] result['calendar'][event['SQLDATE']] = events print >> sys.stderr, today if event['Actor1Code'] is None: # No actor? event['Actor1Code'] = 'Unknown' if lines % 10000 == 0 and events: print >> sys.stderr,'\t%dK (%d events,%d agents)' % \ (lines/1000,len(events),len(result['agents'])) if matchActor(event['Actor1Code'],targets) or \ matchActor(event['Actor2Code'],targets): # Event matching our target events.append(event) if not result['agents'].has_key(event['Actor1Code']): agent = Agent(event['Actor1Code']) result['agents'][agent.name] = agent event['action'] = Action({ 'subject': event['Actor1Code'], 'verb': cameo[event['EventCode']] }) if event['Actor2Code']: if not result['agents'].has_key(event['Actor2Code']): agent = Agent(event['Actor2Code']) result['agents'][agent.name] = agent event['action']['object'] = event['Actor2Code'] # Update relationship matrix if event['Actor1Code'] < event['Actor2Code']: key = '%s,%s' % (event['Actor1Code'], event['Actor2Code']) else: key = '%s,%s' % (event['Actor2Code'], event['Actor1Code']) try: result['matrix'][key].append(event) except KeyError: result['matrix'][key] = [event] return result
__email__ = '*****@*****.**' __description__ = 'Example of how to discretize a feature\'s value in-place using a helper function. ' \ 'Discretization occurs by directly approximating the value of the feature to the closest bin from ' \ 'a discrete set of bins.' \ 'This method can be used to discretize features\' values at each timestep after world.update().' HIGH = 100 LOW = 50 NUM_BINS = 11 NUM_SAMPLES = 100 if __name__ == '__main__': # create world and add agent world = World() agent = Agent('Agent') world.addAgent(agent) # add feature to world feat = world.defineState(agent.name, 'x', float, lo=LOW, hi=HIGH) print('====================================') print('High:\t{}'.format(HIGH)) print('Low:\t{}'.format(LOW)) print('Bins:\t{}'.format(NUM_BINS)) print('\nSamples:') values_original = [] values_discrete = [] for i in range(NUM_SAMPLES): num = np.random.uniform(LOW, HIGH)
import sys from ConfigParser import SafeConfigParser from optparse import OptionParser from psychsim.pwl import * from psychsim.action import Action, ActionSet from psychsim.world import World, stateKey, actionKey from psychsim.agent import Agent if __name__ == '__main__': # Create scenario world = World() totals = {'apple': 3, 'pear': 2} # Stacy state stacy = Agent('Stacy') world.addAgent(stacy) world.defineState(stacy.name, 'applesOwned', int, lo=0, hi=totals['apple']) stacy.setState('applesOwned', 0) world.defineState(stacy.name, 'applesOffered', int, lo=0, hi=totals['apple']) stacy.setState('applesOffered', 0) world.defineState(stacy.name, 'pearsOwned', int, lo=0, hi=totals['pear']) stacy.setState('pearsOwned', 0) world.defineState(stacy.name, 'pearsOffered', int, lo=0, hi=totals['pear']) stacy.setState('pearsOffered', 0) # David state
def createWorld(username='******', level=0, ability='good', explanation='none', embodiment='robot', acknowledgment='no', sequence=False, root='.', ext='xml', beliefs=True): """ Creates the initial PsychSim scenario and saves it @param username: name of user ID to use in filenames @param level: robot mission level to use as template @param ability: the level of the robot's ability - good or C{True}: perfect sensors and sensor model - badSensor or C{False}: noisy sensors, but perfect model of noisy sensors - badModel: perfect sensors, but imperfect model of sensors @type ability: bool @param explanation: the type of explanation to use - none: No explanations - ability: Explanation based on robot ability provided. - abilitybenevolence: Explanation based on both robot's ability and benevolence provided. @type explanation: str @param embodiment: the robot's embodiment - robot: The robot looks like a robot - dog: The robot looks like a dog @type embodiment: str @param acknowledgment: the robot's behavior regarding the acknowledgment of errors - no: The robot does not acknowledge its errors - yes: The robot acknowledges its errors @type acknowledgment: str @param root: the root directory to use for files (default is current working directory) @param ext: the file extension for the PsychSim scenario file - xml: Save as uncompressed XML - psy: Save as bzipped XML @type ext: str @param beliefs: if C{True}, store robot's uncertain beliefs in scenario file, rather than compute them on the fly. Storing in scenario file makes the scenario a more complete model, but greatly increases file sixe. Default is C{True} @type beliefs: bool """ print "**************************createWorld***********************" print 'Username:\t%s\nLevel:\t\t%s' % (username, level + 1) print 'Ability\t\t%s\nExplanation:\t%s\nEmbodiment:\t%s\nAcknowledge:\t%s' % \ (ability,explanation,embodiment,acknowledgment) # Pre-compute symbols for this level's waypoints for point in WAYPOINTS[level]: if not point.has_key('symbol'): point['symbol'] = point['name'].replace(' ', '') world = World() world.defineState( None, 'level', int, lo=0, hi=len(WAYPOINTS) - 1, description='Static variable indicating what mission level') world.setState(None, 'level', level) world.defineState(None, 'time', float) world.setState(None, 'time', 0.) world.defineState(None, 'complete', bool) world.setState(None, 'complete', False) world.addTermination( makeTree({ 'if': trueRow('complete'), True: True, False: False })) # Buildings threats = ['none', 'NBC', 'armed'] for waypoint in WAYPOINTS[level]: if not waypoint.has_key('symbol'): waypoint['symbol'] = waypoint['name'].replace(' ', '') world.addAgent(Agent(waypoint['symbol'])) # Have we visited this waypoint? key = world.defineState(waypoint['symbol'], 'visited', bool) world.setFeature(key, False) # Are there dangerous chemicals or armed people here? key = world.defineState(waypoint['symbol'], 'danger', list, threats[:]) if waypoint.has_key('NBC') and waypoint['NBC']: world.setFeature(key, 'NBC') elif waypoint.has_key('armed') and waypoint['armed']: world.setFeature(key, 'armed') else: world.setFeature(key, 'none') key = world.defineState(waypoint['symbol'], 'recommendation', list, ['none', 'protected', 'unprotected']) world.setFeature(key, 'none') # Human human = Agent('human') world.addAgent(human) world.defineState(human.name, 'alive', bool) human.setState('alive', True) world.defineState(human.name, 'deaths', int) human.setState('deaths', 0) # Robot robot = Agent('robot') world.addAgent(robot) # Robot states world.defineState(robot.name, 'waypoint', list, [point['symbol'] for point in WAYPOINTS[level]]) robot.setState('waypoint', WAYPOINTS[level][getStart(level)]['symbol']) world.defineState(robot.name, 'explanation', list, [ 'none', 'ability', 'abilitybenevolence', 'abilityconfidence', 'confidence' ]) robot.setState('explanation', explanation) world.defineState(robot.name, 'embodiment', list, ['robot', 'dog']) robot.setState('embodiment', embodiment) world.defineState(robot.name, 'acknowledgment', list, ['no', 'yes']) robot.setState('acknowledgment', acknowledgment) world.defineState(robot.name, 'ability', list, ['badSensor', 'badModel', 'good']) if ability is True: # Backward compatibility with boolean ability ability = 'good' elif ability is False: ability = 'badSensor' robot.setState('ability', ability) # State of the robot's sensors world.defineState(robot.name, 'sensorModel', list, ['good', 'bad']) robot.setState('sensorModel', 'good') world.defineState(robot.name, 'command', list, ['none'] + [point['symbol'] for point in WAYPOINTS[level]]) robot.setState('command', 'none') # Actions for end in range(len(WAYPOINTS[level])): symbol = WAYPOINTS[level][end]['symbol'] # Robot movement action = robot.addAction({'verb': 'moveto', 'object': symbol}) # Legal if no contradictory command tree = makeTree({ 'if': equalRow(stateKey(robot.name, 'command'), 'none'), True: True, False: { 'if': equalRow(stateKey(robot.name, 'command'), symbol), True: True, False: False } }) robot.setLegal(action, tree) # Dynamics of robot's location tree = makeTree( setToConstantMatrix(stateKey(action['subject'], 'waypoint'), symbol)) world.setDynamics(stateKey(action['subject'], 'waypoint'), action, tree) # Dynamics of visited flag key = stateKey(symbol, 'visited') tree = makeTree(setTrueMatrix(key)) world.setDynamics(key, action, tree) # Dynamics of time key = stateKey(None, 'time') tree = setToConstantMatrix(key, 0.) for start in range(len(WAYPOINTS[level])): if start != end: startsymbol = WAYPOINTS[level][start]['symbol'] if sequence: # Distance is measured by level sequence distance = abs(start - end) * 50 else: try: distance = DISTANCES[WAYPOINTS[level][start]['name']][ WAYPOINTS[level][end]['name']] except KeyError: try: distance = DISTANCES[WAYPOINTS[level][end][ 'name']][WAYPOINTS[level][start]['name']] except KeyError: distance = 250 tree = { 'if': equalRow(stateKey(action['subject'], 'waypoint'), startsymbol), True: setToConstantMatrix(key, float(distance) / 1000.), False: tree } world.setDynamics(key, action, makeTree(tree)) # Human entry: Dead or alive if unprotected? key = stateKey(human.name, 'alive') action = robot.addAction({ 'verb': 'recommend unprotected', 'object': symbol }) tree = makeTree({ 'if': equalRow(stateKey(symbol, 'danger'), 'none'), True: setTrueMatrix(key), False: setFalseMatrix(key) }) world.setDynamics(key, action, tree) robot.setLegal(action, makeTree(False)) # Human entry: How much "time" if protected? action = robot.addAction({ 'verb': 'recommend protected', 'object': symbol }) key = stateKey(None, 'time') world.setDynamics(key, action, makeTree(setToConstantMatrix(key, 0.25))) robot.setLegal(action, makeTree(False)) # Robot goals goal = minimizeFeature(stateKey(None, 'time')) robot.setReward(goal, 2.) goal = maximizeFeature(stateKey(human.name, 'alive')) robot.setReward(goal, 1.) for point in WAYPOINTS[level]: robot.setReward(maximizeFeature(stateKey(point['symbol'], 'visited')), 1.) if beliefs: # omega = 'danger' world.defineVariable(robot.name, ActionSet) # Robot beliefs world.setModel(robot.name, True) value = 1. / float(len(WAYPOINTS[level])) # tree = KeyedVector({CONSTANT: world.value2float(omega,'none')}) for index in range(len(WAYPOINTS[level])): waypoint = WAYPOINTS[level][index] key = stateKey(waypoint['symbol'], 'danger') # if index > 0: # Starting state is safe robot.setBelief( key, psychsim.probability.Distribution({ 'NBC': value / 2., 'armed': value / 2., 'none': 1. - value })) # Observation function # tree = {'if': equalRow(stateKey(robot.name,'waypoint'),waypoint['symbol']), # True: generateO(world,key), # False: tree} # robot.defineObservation(omega,makeTree(tree),domain=list,lo=['none','NBC','armed']) robot.defineObservation('microphone', makeTree(None), None, domain=list, lo=['nobody', 'friendly', 'suspicious']) robot.defineObservation('NBCsensor', makeTree(None), None, domain=bool) robot.defineObservation('camera', makeTree(None), None, domain=bool) else: robot.defineObservation('microphone', makeTree(None), None, domain=list, lo=['nobody', 'friendly', 'suspicious']) robot.defineObservation('NBCsensor', makeTree(None), None, domain=bool) robot.defineObservation('camera', makeTree(None), None, domain=bool) robot.setAttribute('horizon', 1) world.setOrder([robot.name]) filename = getFilename(username, level, ext, root) world.save(filename, ext == 'psy') WriteLogData('%s user %s, level %d, ability %s, explanation %s' % \ (CREATE_TAG,username,level,ability,explanation),username,level,root=root) return world
def scenarioCreationUseCase(enemy='Sylvania', model='powell', web=False, fCollapse=None, sCollapse=None, maxRounds=15): """ An example of how to create a scenario @param enemy: the name of the agent-controlled side, i.e., Freedonia's opponent (default: Sylvania) @type enemy: str @param model: which model do we use (default is "powell") @type model: powell or slantchev @param web: if C{True}, then create the web-based experiment scenario (default: C{False}) @type web: bool @param fCollapse: the probability that Freedonia collapses (under powell, default: 0.1) or loses battle (under slantchev, default: 0.7) @type fCollapse: float @param sCollapse: the probability that Sylvania collapses, under powell (default: 0.1) @type sCollapse: float @param maxRounds: the maximum number of game rounds (default: 15) @type maxRounds: int @return: the scenario created @rtype: L{World} """ # Handle defaults for battle probabilities, under each model posLo = 0 posHi = 10 if fCollapse is None: if model == 'powell': fCollapse = 0.1 elif model == 'slantchev': fCollapse = 0.7 if sCollapse is None: sCollapse = 0.1 # Create scenario world = World() # Agents free = Agent('Freedonia') world.addAgent(free) sylv = Agent(enemy) world.addAgent(sylv) # User state world.defineState(free.name, 'troops', int, lo=0, hi=50000, description='Number of troops you have left') free.setState('troops', 40000) world.defineState( free.name, 'territory', int, lo=0, hi=100, description='Percentage of disputed territory owned by you') free.setState('territory', 15) world.defineState(free.name, 'cost', int, lo=0, hi=50000, description='Number of troops %s loses in an attack' % (free.name)) free.setState('cost', 2000) world.defineState( free.name, 'position', int, lo=posLo, hi=posHi, description='Current status of war (%d=%s is winner, %d=you are winner)' % (posLo, sylv.name, posHi)) free.setState('position', 5) world.defineState( free.name, 'offered', int, lo=0, hi=100, description= 'Percentage of disputed territory that %s last offered to you' % (sylv.name)) free.setState('offered', 0) if model == 'slantchev': # Compute new value for territory only *after* computing new value for position world.addDependency(stateKey(free.name, 'territory'), stateKey(free.name, 'position')) # Agent state world.defineState(sylv.name, 'troops', int, lo=0, hi=500000, description='Number of troops %s has left' % (sylv.name)) sylv.setState('troops', 30000) world.defineState(sylv.name, 'cost', int, lo=0, hi=50000, description='Number of troops %s loses in an attack' % (sylv.name)) sylv.setState('cost', 2000) world.defineState( sylv.name, 'offered', int, lo=0, hi=100, description= 'Percentage of disputed territory that %s last offered to %s' % (free.name, sylv.name)) sylv.setState('offered', 0) # World state world.defineState(None, 'treaty', bool, description='Have the two sides reached an agreement?') world.setState(None, 'treaty', False) # Stage of negotiation, illustrating the use of an enumerated state feature world.defineState( None, 'phase', list, ['offer', 'respond', 'rejection', 'end', 'paused', 'engagement'], description='The current stage of the negotiation game') world.setState(None, 'phase', 'paused') # Game model, static descriptor world.defineState(None, 'model', list, ['powell', 'slantchev'], description='The model underlying the negotiation game') world.setState(None, 'model', model) # Round of negotiation world.defineState(None, 'round', int, description='The current round of the negotiation') world.setState(None, 'round', 0) if not web: # Relationship value key = world.defineRelation(free.name, sylv.name, 'trusts') world.setFeature(key, 0.) # Game over if there is a treaty world.addTermination( makeTree({ 'if': trueRow(stateKey(None, 'treaty')), True: True, False: False })) # Game over if Freedonia has no territory world.addTermination( makeTree({ 'if': thresholdRow(stateKey(free.name, 'territory'), 1), True: False, False: True })) # Game over if Freedonia has all the territory world.addTermination( makeTree({ 'if': thresholdRow(stateKey(free.name, 'territory'), 99), True: True, False: False })) # Game over if number of rounds exceeds limit world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), maxRounds), True: True, False: False })) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([set(world.agents.keys())]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([free.name, sylv.name]) # User actions freeBattle = free.addAction({'verb': 'attack', 'object': sylv.name}) for amount in range(20, 100, 20): free.addAction({ 'verb': 'offer', 'object': sylv.name, 'amount': amount }) if model == 'powell': # Powell has null stages freeNOP = free.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides receiving offers free.addAction({'verb': 'accept offer', 'object': sylv.name}) free.addAction({'verb': 'reject offer', 'object': sylv.name}) # Agent actions sylvBattle = sylv.addAction({'verb': 'attack', 'object': free.name}) sylvAccept = sylv.addAction({'verb': 'accept offer', 'object': free.name}) sylvReject = sylv.addAction({'verb': 'reject offer', 'object': free.name}) if model == 'powell': # Powell has null stages sylvNOP = sylv.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides making offers for amount in range(10, 100, 10): sylv.addAction({ 'verb': 'offer', 'object': free.name, 'amount': amount }) # Restrictions on when actions are legal, based on phase of game for action in filterActions({'verb': 'offer'}, free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'offer'), True: True, # Offers are legal in the offer phase False: False })) # Offers are illegal in all other phases if model == 'powell': # Powell has a special rejection phase for action in [freeNOP, freeBattle]: free.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'rejection'), True: True, # Attacking and doing nothing are legal only in rejection phase False: False }) ) # Attacking and doing nothing are illegal in all other phases # Once offered, agent can respond if model == 'powell': # Under Powell, only Sylvania has to respond, and it can attack responses = [sylvBattle, sylvAccept, sylvReject] elif model == 'slantchev': # Under Slantchev, only accept/reject responses = filterActions({'verb': 'accept offer'}, free.actions | sylv.actions) responses += filterActions({'verb': 'reject offer'}, free.actions | sylv.actions) for action in responses: agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'respond'), True: True, # Offeree must act in the response phase False: False })) # Offeree cannot act in any other phase if model == 'powell': # NOP is legal in exactly opposite situations to all other actions sylv.setLegal( sylvNOP, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'end'), True: True, # Sylvania does not do anything in the null phase after Freedonia responds to rejection False: False })) # Sylvania must act in its other phases if model == 'slantchev': # Attacking legal only under engagement phase for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'engagement'), True: True, # Attacking legal only in engagement False: False })) # Attacking legal every other phase # Goals for Freedonia goalFTroops = maximizeFeature(stateKey(free.name, 'troops')) free.setReward(goalFTroops, 1.) goalFTerritory = maximizeFeature(stateKey(free.name, 'territory')) free.setReward(goalFTerritory, 1.) # Goals for Sylvania goalSTroops = maximizeFeature(stateKey(sylv.name, 'troops')) sylv.setReward(goalSTroops, 1.) goalSTerritory = minimizeFeature(stateKey(free.name, 'territory')) sylv.setReward(goalSTerritory, 1.) # Possible goals applicable to both goalAgreement = maximizeFeature(stateKey(None, 'treaty')) # Silly goal, provided as an example of an achievement goal goalAchieve = achieveFeatureValue(stateKey(None, 'phase'), 'respond') # Horizons if model == 'powell': free.setAttribute('horizon', 4) sylv.setAttribute('horizon', 4) elif model == 'slantchev': free.setAttribute('horizon', 6) sylv.setAttribute('horizon', 6) # Discount factors free.setAttribute('discount', -1) sylv.setAttribute('discount', -1) # Levels of belief free.setRecursiveLevel(2) sylv.setRecursiveLevel(2) # Dynamics of battle freeTroops = stateKey(free.name, 'troops') freeTerr = stateKey(free.name, 'territory') sylvTroops = stateKey(sylv.name, 'troops') # Effect of fighting for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): # Effect on troops (cost of battle) tree = makeTree( addFeatureMatrix(freeTroops, stateKey(free.name, 'cost'), -1.)) world.setDynamics(freeTroops, action, tree, enforceMin=not web) tree = makeTree( addFeatureMatrix(sylvTroops, stateKey(sylv.name, 'cost'), -1.)) world.setDynamics(sylvTroops, action, tree, enforceMin=not web) if model == 'powell': # Effect on territory (probability of collapse) tree = makeTree({ 'distribution': [ ( { 'distribution': [ (setToConstantMatrix(freeTerr, 100), 1. - fCollapse ), # Sylvania collapses, Freedonia does not (noChangeMatrix(freeTerr), fCollapse) ] }, # Both collapse sCollapse), ( { 'distribution': [ (setToConstantMatrix(freeTerr, 0), fCollapse ), # Freedonia collapses, Sylvania does not (noChangeMatrix(freeTerr), 1. - fCollapse) ] }, # Neither collapses 1. - sCollapse) ] }) world.setDynamics(freeTerr, action, tree) elif model == 'slantchev': # Effect on position pos = stateKey(free.name, 'position') tree = makeTree({ 'distribution': [ (incrementMatrix(pos, 1), 1. - fCollapse), # Freedonia wins battle (incrementMatrix(pos, -1), fCollapse) ] }) # Freedonia loses battle world.setDynamics(pos, action, tree) # Effect on territory tree = makeTree({ 'if': thresholdRow(pos, posHi - .5), True: setToConstantMatrix(freeTerr, 100), # Freedonia won False: { 'if': thresholdRow(pos, posLo + .5), True: noChangeMatrix(freeTerr), False: setToConstantMatrix(freeTerr, 0) } }) # Freedonia lost world.setDynamics(freeTerr, action, tree) # Dynamics of offers for index in range(2): atom = Action({ 'subject': world.agents.keys()[index], 'verb': 'offer', 'object': world.agents.keys()[1 - index] }) if atom['subject'] == free.name or model != 'powell': offer = stateKey(atom['object'], 'offered') amount = actionKey('amount') tree = makeTree({ 'if': trueRow(stateKey(None, 'treaty')), True: noChangeMatrix(offer), False: setToConstantMatrix(offer, amount) }) world.setDynamics(offer, atom, tree, enforceMax=not web) # Dynamics of treaties for action in filterActions({'verb': 'accept offer'}, free.actions | sylv.actions): # Accepting an offer means that there is now a treaty key = stateKey(None, 'treaty') tree = makeTree(setTrueMatrix(key)) world.setDynamics(key, action, tree) # Accepting offer sets territory offer = stateKey(action['subject'], 'offered') territory = stateKey(free.name, 'territory') if action['subject'] == free.name: # Freedonia accepts sets territory to last offer tree = makeTree(setToFeatureMatrix(territory, offer)) world.setDynamics(freeTerr, action, tree) else: # Sylvania accepts sets territory to 1-last offer tree = makeTree( setToFeatureMatrix(territory, offer, pct=-1., shift=100.)) world.setDynamics(freeTerr, action, tree) # Dynamics of phase phase = stateKey(None, 'phase') roundKey = stateKey(None, 'round') # OFFER -> RESPOND for index in range(2): action = Action({ 'subject': world.agents.keys()[index], 'verb': 'offer', 'object': world.agents.keys()[1 - index] }) if action['subject'] == free.name or model != 'powell': tree = makeTree(setToConstantMatrix(phase, 'respond')) world.setDynamics(phase, action, tree) # RESPOND -> REJECTION or ENGAGEMENT for action in filterActions({'verb': 'reject offer'}, free.actions | sylv.actions): if model == 'powell': tree = makeTree(setToConstantMatrix(phase, 'rejection')) elif model == 'slantchev': tree = makeTree(setToConstantMatrix(phase, 'engagement')) world.setDynamics(phase, action, tree) # accepting -> OFFER for action in filterActions({'verb': 'accept offer'}, free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, action, tree) # attacking -> OFFER for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, action, tree) if action['subject'] == sylv.name or model == 'slantchev': tree = makeTree(incrementMatrix(roundKey, 1)) world.setDynamics(roundKey, action, tree) if model == 'powell': # REJECTION -> END for atom in [freeNOP, freeBattle]: tree = makeTree(setToConstantMatrix(phase, 'end')) world.setDynamics(phase, atom, tree) # END -> OFFER atom = Action({'subject': sylv.name, 'verb': 'continue'}) tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, atom, tree) tree = makeTree(incrementMatrix(roundKey, 1)) world.setDynamics(roundKey, atom, tree) if not web: # Relationship dynamics: attacking is bad for trust atom = Action({ 'subject': sylv.name, 'verb': 'attack', 'object': free.name }) key = binaryKey(free.name, sylv.name, 'trusts') tree = makeTree(approachMatrix(key, 0.1, -1.)) world.setDynamics(key, atom, tree) # Handcrafted policy for Freedonia # free.setPolicy(makeTree({'if': equalRow('phase','respond'), # # Accept an offer greater than 50 # True: {'if': thresholdRow(stateKey(free.name,'offered'),50), # True: Action({'subject': free.name,'verb': 'accept offer','object': sylv.name}), # False: Action({'subject': free.name,'verb': 'reject offer','object': sylv.name})}, # False: {'if': equalRow('phase','engagement'), # # Attack during engagement phase # True: Action({'subject': free.name,'verb': 'attack','object': sylv.name}), # # Agent decides how what to do otherwise # False: False}})) # Mental models of enemy # Example of creating a model with incorrect reward all at once (a version of Freedonia who cares about reaching agreement as well) # sylv.addModel('false',R={goalSTroops: 10.,goalSTerritory: 1.,goalAgreement: 1.}, # rationality=1.,selection='distribution',parent=True) # Example of creating a model with incorrect beliefs sylv.addModel('false', rationality=10., selection='distribution', parent=True) key = stateKey(free.name, 'position') # Sylvania believes position to be fixed at 3 sylv.setBelief(key, 3, 'false') # Freedonia is truly unsure about position (50% chance of being 7, 50% of being 3) world.setModel(free.name, True) free.setBelief(key, Distribution({7: 0.5, 3: 0.5}), True) # Observations about military position tree = makeTree({ 'if': thresholdRow(key, 1), True: { 'if': thresholdRow(key, 9), True: { 'distribution': [(KeyedVector({key: 1}), 0.9), (KeyedVector({ key: 1, CONSTANT: -1 }), 0.1)] }, False: { 'distribution': [(KeyedVector({key: 1}), 0.8), (KeyedVector({ key: 1, CONSTANT: -1 }), 0.1), (KeyedVector({ key: 1, CONSTANT: 1 }), 0.1)] } }, False: { 'distribution': [(KeyedVector({key: 1}), 0.9), (KeyedVector({ key: 1, CONSTANT: 1 }), 0.1)] } }) free.defineObservation(key, tree) # Example of setting model parameters separately sylv.addModel('true', parent=True) sylv.setAttribute( 'rationality', 10., 'true') # Override real agent's rationality with this value sylv.setAttribute('selection', 'distribution', 'true') world.setMentalModel(free.name, sylv.name, {'false': 0.9, 'true': 0.1}) # Goal of fooling Sylvania goalDeception = achieveFeatureValue(modelKey(sylv.name), sylv.model2index('false')) return world
def __init__(self, turnOrder, maxRounds, payoff): self.maxRounds = maxRounds self.payoff = payoff print self.payoff self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) # State self.world.defineState(me.name, 'money', int) me.setState('money', 0) mePass = me.addAction({'verb': 'pass', 'object': other.name}) meTake = me.addAction({'verb': 'take', 'object': other.name}) # Parameters me.setHorizon(6) me.setParameter('discount', 1.) # me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(turnOrder) # World state self.world.defineState(None, 'round', int, description='The current round') self.world.setState(None, 'round', 0) self.world.defineState(None, 'gameOver', bool, description='whether game is over') self.world.setState(None, 'gameOver', False) self.world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), self.maxRounds), True: True, False: { 'if': trueRow(stateKey(None, 'gameOver')), True: True, False: False } })) # Dynamics for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None, 'round'), 1)) self.world.setDynamics(None, 'round', action, tree) if (action['verb'] == 'take'): tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', action, tree) agts = ['Stacy', 'David'] for i in range(2): key = stateKey(agts[i], 'money') tree = makeTree( self.buildPayoff(0, key, self.payoff[agts[i]])) self.world.setDynamics(agts[i], 'money', action, tree) elif action['verb'] == 'pass': agts = ['Stacy', 'David'] for i in range(2): key = stateKey(agts[i], 'money') tree = makeTree({ 'if': equalRow(stateKey(None, 'round'), self.maxRounds - 1), True: setToConstantMatrix( key, self.payoff[agts[i]][self.maxRounds]), False: noChangeMatrix(key) }) self.world.setDynamics(agts[i], 'money', action, tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian', R={}, level=2, rationality=10., selection='distribution') agent.addModel('Capitalist', R={}, level=2, rationality=10., selection='distribution')
return { 'distribution': [(setTrueMatrix(key), prob), (setFalseMatrix(key), 1. - prob)] } def noisyOr(onCount, onProb, leak=0.): return 1. - (1. - leak) * pow(1. - onProb, onCount) if __name__ == '__main__': world = World() world.diagram = diagram.Diagram() world.diagram.setColor(None, 'ivory') resident = Agent('resident') world.diagram.setColor(resident.name, 'palegreen') world.addAgent(resident) # family = Agent('family') # world.diagram.setColor(family.name,'mediumseagreen') # world.addAgent(family) gov = Agent('government') world.diagram.setColor(gov.name, 'cornflowerblue') world.addAgent(gov) world.setOrder([resident.name]) # Keep track of orthogonal dimensions of decision-making phase = world.defineState( None, 'phase',
# prob = noisyOr(tree[True],.75,.1) # return {'distribution': [(setTrueMatrix(key),prob),(setFalseMatrix(key),1.-prob)]} # # # # # def noisyOr(onCount,onProb,leak=0.): # return 1.- (1.-leak)*pow(1.-onProb,onCount) if __name__ == '__main__': # State world = World() world.diagram = diagram.Diagram() world.diagram.setColor(None, 'ivory') resident = Agent('resident') world.diagram.setColor(resident.name, 'palegreen') world.addAgent(resident) world.defineState(resident.name, 'sea_level_house', list, ['low', 'med', 'hi']) world.defineState(resident.name, 'home_structure', list, ['mobile', 'other']) world.defineState(resident.name, 'storm_category', list, ['1', '2', '3', '4', '5']) world.defineState(resident.name, 'gov_evac', list, ['strong', 'none']) world.defineState(resident.name, 'loc_evac_phone', bool) world.defineState(resident.name, 'peer_evac_info', bool) world.defineState(resident.name, 'expect_prop_risk', bool) world.defineState(resident.name, 'expect_personal_risk', bool) bel_seq = [
DEBUG = False def get_fake_model_name(agent): return 'fake {} model'.format(agent.name) if __name__ == '__main__': # sets up log to screen logging.basicConfig(format='%(message)s', level=logging.DEBUG if DEBUG else logging.INFO) # create world and add agents world = World() ag_producer = Agent('Producer') world.addAgent(ag_producer) ag_consumer = Agent('Consumer') world.addAgent(ag_consumer) agents = [ag_producer, ag_consumer] # agent settings ag_producer.setAttribute('discount', 1) ag_producer.setHorizon(HORIZON) ag_consumer.setAttribute('discount', 1) ag_consumer.setHorizon(HORIZON) # add variables (capacity and asked/received amounts) var_half_cap = world.defineState(ag_producer.name, 'half capacity', bool) world.setFeature(var_half_cap, False) var_ask_amnt = world.defineState(ag_producer.name,
if __name__ == '__main__': # Create scenario world = World() totals = {'exiter':3,'follower':4, 'avoider':3} # # there are a mix of agent types that have different reward preferences for heading towards door, # following someone who is closest or avoiding the fire rewardWeights = {'exiter':{'fire':.4,'door':.5,'follow':.1},'follower':{'fire':.2,'door':.2,'follow':.6},'avoider':{'fire':.6,'door':.3,'follow':.1}} # the fire and door are modeled as agents with no actions - they only have a fixed location me = Agent('door') world.addAgent(me) world.defineState(me.name,'x',float) world.setState(me.name,'x',5) world.defineState(me.name,'y',float) world.setState(me.name,'y',5) me.setHorizon(0) me = Agent('fire') world.addAgent(me) world.defineState(me.name,'x',float) world.setState(me.name,'x',1) world.defineState(me.name,'y',float) world.setState(me.name,'y',1) me.setHorizon(0)
def __init__(self): self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] totalAmt = 4 # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) self.world.defineState(me.name, 'offered', int, lo=0, hi=totalAmt) self.world.defineState(me.name, 'money', int, lo=0, hi=totalAmt) me.setState('offered', 0) me.setState('money', 0) if (me.name == 'Stacy'): for amt in range(totalAmt + 1): me.addAction({ 'verb': 'offer', 'object': other.name, 'amount': amt }) else: mePass = me.addAction({'verb': 'accept', 'object': other.name}) mePass = me.addAction({'verb': 'reject', 'object': other.name}) # Parameters me.setHorizon(2) me.setParameter('discount', 0.9) # me.setParameter('discount',1.0) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(['Stacy', 'David']) # World state self.world.defineState(None, 'gameOver', bool, description='The current round') self.world.setState(None, 'gameOver', False) self.world.addTermination( makeTree({ 'if': trueRow(stateKey(None, 'gameOver')), True: True, False: False })) # offer dynamics atom = Action({'subject': 'Stacy', 'verb': 'offer', 'object': 'David'}) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j], 'offered') amount = actionKey('amount') if j == 1 else '%d-%s' % ( totalAmt, actionKey('amount')) tree = makeTree(setToConstantMatrix(offer, amount)) self.world.setDynamics(parties[j], 'offered', atom, tree) # accept dynamics atom = Action({ 'subject': 'David', 'verb': 'accept', 'object': 'Stacy' }) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j], 'offered') money = stateKey(parties[j], 'money') tree = makeTree(setToFeatureMatrix(money, offer)) self.world.setDynamics(parties[j], 'money', atom, tree) tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', atom, tree) # reject dynamics atom = Action({ 'subject': 'David', 'verb': 'reject', 'object': 'Stacy' }) tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', atom, tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian', R={}, level=2, rationality=25., selection='distribution') agent.addModel('Capitalist', R={}, level=2, rationality=25., selection='distribution')
AGENT1_ID = 'Agent 1' AGENT2_ID = 'Agent 2' if __name__ == '__main__': # turn orders turn_orders = { 'First increment, then copy': [AGENT1_ID, AGENT2_ID], 'First copy, then increment': [AGENT2_ID, AGENT1_ID], 'Simult. increment and copy': [{AGENT1_ID, AGENT2_ID}] } for label, turn_order in turn_orders.items(): agent1 = Agent(AGENT1_ID) agent2 = Agent(AGENT2_ID) # create world and add agents world = World() world.addAgent(agent1) world.addAgent(agent2) # add variables var_counter = world.defineState(agent1.name, 'counter', int, lo=0, hi=3) var_copy = world.defineState(agent2.name, 'counter_copy',
} } }) if __name__ == '__main__': random.seed(0) # sets up log to screen logging.basicConfig(format='%(message)s', level=logging.DEBUG if DEBUG else logging.INFO) # create world and add agent world = World() agent1 = Agent('Agent 1') world.addAgent(agent1) agent2 = Agent('Agent 2') world.addAgent(agent2) agents_dec = [] agents = [agent1, agent2] for agent in agents: # set agent's params agent.setAttribute('discount', 1) agent.setAttribute('selection', TIEBREAK) # agent.setRecursiveLevel(1) # add "decision" variable (0 = didn't decide, 1 = Defected, 2 = Cooperated) dec = world.defineState(agent.name, 'decision', list, [NOT_DECIDED, DEFECTED, COOPERATED])
def __init__(self, turnOrder): self.maxRounds = 8 self.world = World() totals = {'apple': 1, 'pear': 2} batna_prePref = totals['apple'] + totals['pear'] stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) # State self.world.defineState(me.name, 'appleOwned', int, lo=0, hi=totals['apple']) me.setState('appleOwned', 0) self.world.defineState(me.name, 'appleOffered', int, lo=0, hi=totals['apple']) me.setState('appleOffered', 0) self.world.defineState(me.name, 'pearOwned', int, lo=0, hi=totals['pear']) me.setState('pearOwned', 0) self.world.defineState(me.name, 'pearOffered', int, lo=0, hi=totals['pear']) me.setState('pearOffered', 0) self.world.defineState(me.name, 'Batna', int, lo=0, hi=10) me.setState('Batna', batna_prePref) self.world.defineState(me.name, 'BatnaOwned', int, lo=0, hi=10) me.setState('BatnaOwned', 0) self.world.defineState(me.name, 'agree', bool) me.setState('agree', False) # Actions me.addAction({'verb': 'do nothing'}) for amt in range(totals['apple'] + 1): tmp = me.addAction({ 'verb': 'offerApple', 'object': other.name, 'amount': amt }) me.setLegal( tmp, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) for amt in range(totals['pear'] + 1): tmp = me.addAction({ 'verb': 'offerPear', 'object': other.name, 'amount': amt }) me.setLegal( tmp, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) meReject = me.addAction({ 'verb': 'rejectNegotiation', 'object': other.name }) me.setLegal( meReject, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) meAccept = me.addAction({ 'verb': 'accept offer', 'object': other.name }) me.setLegal( meAccept, makeTree({ 'if': trueRow(stateKey(None, 'appleOffer')), True: { 'if': trueRow(stateKey(None, 'pearOffer')), True: { 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False }, False: False }, False: False })) # Parameters me.setHorizon(6) me.setParameter('discount', 0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially self.world.setOrder(turnOrder) # World state self.world.defineState(None, 'agreement', bool) self.world.setState(None, 'agreement', False) self.world.defineState(None, 'appleOffer', bool) self.world.setState(None, 'appleOffer', False) self.world.defineState(None, 'pearOffer', bool) self.world.setState(None, 'pearOffer', False) self.world.defineState( None, 'round', int, description='The current round of the negotiation') self.world.setState(None, 'round', 0) self.world.defineState( None, 'rejectedNegotiation', bool, description='Have one of the players walked out?') self.world.setState(None, 'rejectedNegotiation', False) # dont terminate so agent sees benefit of early agreement # world.addTermination(makeTree({'if': trueRow(stateKey(None,'agreement')), # True: True, # False: False})) # world.addTermination(makeTree({'if': trueRow(stateKey(None,'rejectedNegotiation')), # True: True, # False: False})) self.world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), self.maxRounds), True: True, False: False })) # Dynamics of offers agents = [david.name, stacy.name] for i in range(2): for fruit in ['apple', 'pear']: atom = Action({ 'subject': agents[i], 'verb': 'offer%s' % (fruit.capitalize()), 'object': agents[1 - i] }) parties = [atom['subject'], atom['object']] for j in range(2): # Set offer amount offer = stateKey(parties[j], '%sOffered' % (fruit)) amount = actionKey('amount') if j == 1 else '%d-%s' % ( totals[fruit], actionKey('amount')) tree = makeTree(setToConstantMatrix(offer, amount)) self.world.setDynamics(parties[j], '%sOffered' % (fruit), atom, tree) # reset agree flags whenever an offer is made agreeFlag = stateKey(parties[j], 'agree') tree = makeTree(setFalseMatrix(agreeFlag)) self.world.setDynamics(parties[j], 'agree', atom, tree) # Offers set offer flag in world state tree = makeTree( setTrueMatrix(stateKey(None, '%sOffer' % (fruit)))) self.world.setDynamics(None, '%sOffer' % (fruit), atom, tree) # agents = [david.name,stacy.name] # Dynamics of agreements for i in range(2): atom = Action({ 'subject': agents[i], 'verb': 'accept offer', 'object': agents[1 - i] }) # accept offer sets accept tree = makeTree(setTrueMatrix(stateKey(atom['subject'], 'agree'))) self.world.setDynamics(atom['subject'], 'agree', atom, tree) # accept offer sets agreement if object has accepted tree = makeTree({ 'if': trueRow(stateKey(atom['object'], 'agree')), True: setTrueMatrix(stateKey(None, 'agreement')), False: noChangeMatrix(stateKey(None, 'agreement')) }) self.world.setDynamics(None, 'agreement', atom, tree) # Accepting offer sets ownership parties = [atom['subject'], atom['object']] for fruit in ['apple', 'pear']: # atom = Action({'subject': agents[i],'verb': 'accept offer', 'object': agents[1-i]}) for j in range(2): offer = stateKey(parties[j], '%sOffered' % (fruit)) owned = stateKey(parties[j], '%sOwned' % (fruit)) tree = makeTree({ 'if': trueRow(stateKey(atom['object'], 'agree')), False: noChangeMatrix(owned), True: setToFeatureMatrix(owned, offer) }) self.world.setDynamics(parties[j], '%sOwned' % (fruit), atom, tree) # rejecting give us batna and ends negotiation atom = Action({ 'subject': agents[i], 'verb': 'rejectNegotiation', 'object': agents[1 - i] }) tree = makeTree( setToFeatureMatrix(stateKey(atom['subject'], 'BatnaOwned'), stateKey(atom['subject'], 'Batna'))) self.world.setDynamics(atom['subject'], 'BatnaOwned', atom, tree) tree = makeTree( setToFeatureMatrix(stateKey(atom['object'], 'BatnaOwned'), stateKey(atom['object'], 'Batna'))) self.world.setDynamics(atom['object'], 'BatnaOwned', atom, tree) tree = makeTree( setTrueMatrix(stateKey(None, 'rejectedNegotiation'))) self.world.setDynamics(None, 'rejectedNegotiation', atom, tree) for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None, 'round'), 1)) self.world.setDynamics(None, 'round', action, tree) for agent in self.world.agents.values(): agent.addModel('pearLover', R={}, level=2, rationality=0.01) agent.addModel('appleLover', R={}, level=2, rationality=0.01)
def setup(): global args np.random.seed(args.seed) # create world and add agents world = World() world.memory = False world.parallel = args.parallel agents = [] agent_features = {} for ag in range(args.agents): agent = Agent('Agent' + str(ag)) world.addAgent(agent) agents.append(agent) # set agent's params agent.setAttribute('discount', 1) agent.setHorizon(args.horizon) # add features, initialize at random features = [] agent_features[agent] = features for f in range(args.features_agent): feat = world.defineState(agent.name, 'Feature{}'.format(f), int, lo=0, hi=1000) world.setFeature(feat, np.random.randint(0, MAX_FEATURE_VALUE)) features.append(feat) # set random reward function agent.setReward(maximizeFeature(np.random.choice(features), agent.name), 1) # add mental copy of true model and make it static (we do not have beliefs in the models) agent.addModel(get_fake_model_name(agent), parent=get_true_model_name(agent)) agent.setAttribute('static', True, get_fake_model_name(agent)) # add actions for ac in range(args.actions): action = agent.addAction({'verb': '', 'action': 'Action{}'.format(ac)}) i = ac while i + args.features_action < args.features_agent: weights = {} for j in range(args.features_action): weights[features[i + j + 1]] = 1 tree = makeTree(multi_set_matrix(features[i], weights)) world.setDynamics(features[i], action, tree) i += args.features_action # define order world.setOrder([set(ag.name for ag in agents)]) for agent in agents: # test belief update: # - set a belief in one feature to the actual initial value (should not change outcomes) # world.setModel(agent.name, Distribution({True: 1.0})) rand_feat = np.random.choice(agent_features[agent]) agent.setBelief(rand_feat, world.getValue(rand_feat)) print('{} will always observe {}={}'.format(agent.name, rand_feat, world.getValue(rand_feat))) # set mental model of each agent in all other agents for i in range(args.agents): for j in range(i + 1, args.agents): world.setMentalModel(agents[i].name, agents[j].name, Distribution({get_fake_model_name(agents[j]): 1})) world.setMentalModel(agents[j].name, agents[i].name, Distribution({get_fake_model_name(agents[i]): 1})) return world