def costHonor(self, offering, DifferentialCosts=False, patriotism=0): basic_cost = offering * percent(self.Parameter('HonoringCost')) if not DifferentialCosts: # MaxOffer mode: non-patriots face the same cost as patriots return basic_cost else: # DiffCosts mode: NonPatriots face a premium for honoring return basic_cost + basic_cost * (1 - patriotism) * percent( self.Parameter('DishonestPremium'))
def costHonor(self, offering, DifferentialCosts = False, patriotism = 0): basic_cost = offering * percent(self.Parameter('HonoringCost')) if not DifferentialCosts: #print('Offer max') return basic_cost else: # NonPatriots face a premium for honoring #print('diff cost') return basic_cost + basic_cost * (1 - patriotism) * (1+ percent(self.Parameter('DishonestPremium')))
def Signal(self, Feature=None, Transparent=False): " returns the actual quality of an individual or its displayed version " if Transparent: return self.Quality BC = Gbl.Param('BottomCompetence') Comp = percent(100 - BC) * self.Quality + BC # Comp = BC + self.Quality VisibleCompetence = percent(Comp * self.feature(Feature)) return self.Limitate(VisibleCompetence, 0, 100)
def assessment(self): self.Points -= percent(Gbl.Param('SignallingCost') * self.Features['SignalInvestment']) # self.restore_symmetry() # Checks that self is its friends' friend for (Rank,Friend) in enumerate(self.Friends()): AgentSocialOffer = Gbl.InterActions.SocialOffer(Gbl.InterActions.FCompetence(self, Apparent=False), Rank, self.nbFriends()) Friend.Risk = percent(Friend.Risk * (100 - percent(Gbl.Param('CompetenceImpact') * AgentSocialOffer)))
def signalCost(self, sgl, DifferentialCosts=False, patriotism=0): basic_cost = sgl * percent(self.Scenario.Parameter('HonoringCost')) if not DifferentialCosts: #print('Offer max') self.score(-basic_cost) else: # NonPatriots face a premium for honoring #print('diff cost') self.score(-basic_cost + basic_cost * (1 - patriotism) * percent(self.Parameter('DishonestPremium')))
def Quality(self, Indiv, Apparent=False): " Adds a bottom value to Quality " BC = self.Parameter('BottomQuality') Comp = percent(100-BC) * Indiv.Phene_relative_value('Quality') + BC VisibleQuality = percent(Comp * Indiv.Phene_relative_value('SignalInvestment')) if Apparent: return VisibleQuality else: return Comp
def evaluation(self,indiv): """ Implements the computation of individuals' scores - - Used in 'life_game' """ ################################ # computing individual benefit # ################################ Bonus = percent(indiv.gene_relative_intensity('favourable') * self.Parameter('IndividualBenefit')) Bonus += percent(self.CollectiveAsset * self.Parameter('CollectiveBenefit')) indiv.score(Bonus, FlagSet=False) # Bonus is added to Score
def Quality(self, Indiv, Apparent=False): " Adds a bottom value to Quality " BC = self.Parameter('BottomQuality') Comp = percent(100-BC) * Indiv.Phene_relative_value('Quality') + BC VisibleQuality = percent(Comp * Indiv.Phene_relative_value('SignalInvestment')) if Apparent: return VisibleQuality else: return Comp
def deathProbability(self, indiv): """ Converts an individual's genetic propensity to self-sacrifice into a probability MODIF: now dpeends on type --- fail MODIF2: now = probability of being a hero... """ r = percent(indiv.gene_relative_value('Hero')) if r > random(): return percent(self.Parameter('SacrificeProbability')) else: return 0
def deathProbability(self, indiv): """ Depending on an individual's patriotism and genetic readiness to display it, the individual may engage in self-sacrifice """ r = percent (indiv.gene_relative_value('Readiness')) \ * percent (indiv.Phene_value('Patriotism')) #r = r/5 # pour comme JLD return r
def Competence(self, Apparent=False): " returns the actual quality of an individual or its displayed version " if Apparent: BC = Gbl.Param('BottomCompetence') Comp = percent(100-BC) * self.Quality + BC # Comp = BC + self.Quality VisibleCompetence = percent(Comp * self.Features['SignalInvestment']) return self.Limitate(VisibleCompetence, 0, 100) else: # return Comp return self.Quality
def Competence(self, Indiv, Apparent=False): " returns the actual quality of an individual or its displayed version " BC = self.Parameter('BottomCompetence') Comp = percent(100-BC) * Indiv.Quality + BC # Comp = BC + Indiv.Quality VisibleCompetence = percent(Comp * Indiv.SignalInvestment) if Apparent: return Limitate(VisibleCompetence, 0, 100) else: # return Comp return Indiv.Quality
def evaluation(self,indiv): """ Implements the computation of individuals' scores - - Used in 'life_game' """ ################################ # computing individual benefit # ################################ IndividualValue = indiv.gene_relative_value('favourable') # between 0 and 100 # Bonus = <individual value> * <Individual benefit parameter> / 100 Bonus = percent(IndividualValue * self.Parameter('IndividualBenefit')) # Collective profit is merely added Bonus += percent(self.CollectiveAsset * self.Parameter('CollectiveBenefit')) indiv.score(Bonus, FlagSet=False) # Bonus is added to Score
def Competence(self, Indiv, Apparent=False): " Adds a bottom value to competence " BC = self.Parameter('BottomCompetence') Comp = percent(100-BC) * Indiv.Phene_relative_value('Competence') + BC VisibleCompetence = percent(Comp * Indiv.Phene_relative_value('SignalInvestment')) CompSign = self.Parameter('CompetenceSignificance') Attractiveness = percent(100-CompSign) * Indiv.Phene_relative_value('Strength') \ + percent(CompSign) * VisibleCompetence if Apparent: return Attractiveness ## return VisibleCompetence else: return Comp
def assessment(self): self.Points -= percent(MyScenario.Parameter('SignallingCost') * self.SignalInvestment) if MyScenario.Parameter('InteractionScenario') == MyScenario.Parameter('CostlySignal'): if self.best_friend() is not None: self.best_friend().Points += MyScenario.Parameter('JoiningBonus') elif MyScenario.Parameter('InteractionScenario') == MyScenario.Parameter('Grooming'): self.restore_symmetry() # Checks that self is its friends' friend for (Rank,Friend) in enumerate(self.friends()): AgentSocialOffer = InterActions.SocialOffer(InterActions.FCompetence(self, Apparent=False), Rank, self.nbFriends()) Friend.Risk = percent(Friend.Risk * (100 - percent(MyScenario.Parameter('CompetenceImpact') * AgentSocialOffer)))
def evaluation(self, indiv): #print('indiv has {} friends'.format(indiv.nbFriends())) #print('indiv has {} friends and {} followers'.format(indiv.nbFriends(), indiv.nbFollowers())) ##################### version coll semble marche bien meme si mauss # et que depend pas mal des parametres... # # + add a Judas version ===> can even become dishonest signal... --> put a max on demand ? indiv.score( + self.Parameter('FriendshipValue') * indiv.nbFollowers() ) #indiv.score( + self.Parameter('FriendshipValue') * indiv.nbFollowers() ) # symmetrical version ... if indiv.Patriotism ==0 and random() < percent(self.Parameter('NbTraitors')): # indiv is a traitor who betrays its friends for follower in indiv.followers: follower.score(- self.Parameter('DenunciationCost')) indiv.score(+ self.Parameter('Judas')) # 0 by default # Alt version ---> dishonest signaling could emerge ?? / Only with extreme values it seems, more like no sgl elif indiv.Patriotism ==1: for follower in indiv.followers: follower.score(+ self.Parameter('PatriotFriendBonus')) #else: # for follower in indiv.followers: # follower.score(+ self.Parameter('FriendshipValue')) return ################### version indiv marche bof... if indiv.nbFollowers() == 0: return indiv.score( + self.Parameter('JoiningBonus')) # OK si JB > FV en gros... Friend = choice(indiv.followers.names()) if indiv.Patriotism == 0 and random() < percent(self.Parameter('NbTraitors')): # indiv is a traitor who betrays Friend Friend.score( - self.Parameter('DenunciationCost')) Friend.Executed = (self.Parameter('DenunciationCost') == 0) else: # Friend benefits from having befriended a true patriot Friend.score(+ self.Parameter('FriendshipValue')) return
def evaluation(self, indiv): """ Implements the computation of individuals' scores - - Used in 'life_game' """ ################################ # computing individual benefit # ################################ IndividualValue = indiv.gene_relative_value( 'favourable') # between 0 and 100 # Bonus = <individual value> * <Individual benefit parameter> / 100 Bonus = percent(IndividualValue * self.Parameter('IndividualBenefit')) # Collective profit is merely added Bonus += percent(self.CollectiveAsset * self.Parameter('CollectiveBenefit')) indiv.score(Bonus, FlagSet=False) # Bonus is added to Score
def start_game(self,members): """ defines what is to be done at the group level before interactions occur """ for Indiv in members: Indiv.score(self.Parameter('SignallingCost'), FlagSet=True) # resetting scores SigInv = Indiv.Phene_value('SignalInvestment') self.GlobalComm += SigInv SignalCost = percent(SigInv * self.Parameter('SignallingCost')) Indiv.score(-SignalCost) # friendship links (lessening with time) are updated #Indiv.lessening_friendship() # links are reset #Indiv.detach() # Monitoring competence distribution self.CompetenceHistogram[self.CompetenceRange(Indiv)][0] += SigInv self.CompetenceHistogram[self.CompetenceRange(Indiv)][1] += 1 self.PopSize += len(members) # number of individuals currently present # Individuals first interact one more time with their current friends for Indiv in members: ## Offers = Indiv.gurus.performances() ## histogram = [(O,Offers.count(O)) for O in list(set(Offers))] ## histogram.sort(key=lambda x: x[1], reverse=True) ## histogram = dict(histogram) for Friend in Indiv.friends(): self.Interactions.groom(Indiv, Friend)
def interaction(self, indiv, Partner): """ Dyadic cooperative interaction: one player (indiv) makes the first step by offering a 'gift' to a partner. The latter then returns the favour. Both the gift and the returned reward are controlled by genes. Both involve costs. """ # First step: initial gift gift = percent(self.Parameter('FirstStep') * indiv.gene_relative_value('Cooperativeness')) Partner.score(noise_mult(gift,self.Parameter('Noise'))) # multiplicative noise # First player pays associated cost # Cost is a function of investment cost = percent(gift * self.Parameter('FirstStepCost')) indiv.score(-cost) # Receiver remembers who gave the gift Partner.follow(indiv, gift)
def assessment(self): " computing social payoff " global SocialValue # first, pay the cost for signalling self.Points -= self.Cost() # self.restore_symmetry() # Checks that self is its friends' friend # being acquainted provides benefit to friend for (Rank, Friend) in enumerate(self.Friends()): # computing real friendship effect # AgentSocialOffer = SocialValue.SocialOffer(Gbl.InterActions.FCompetence(self, Transparent=True), Rank, self.nbFriends()) AgentSocialEffect = SocialValue.SocialOffer( self.Quality, Rank, self.nbFriends()) Friend.Risk = percent( Friend.Risk * (100 - percent(Gbl.Param('CompetenceImpact') * AgentSocialEffect)))
def reproduction(self): """ Reproduction within the group Uses 'parenthood' (in Scenario) and 'couples' (not reproduced here - from Group module) 'couples' returns as many couples as children are to be born """ # The probability of parents to beget children depends on their rank within the group # (Except if Selectivity = 0, for which rank becomes random) self.update_(flagRanking=True) # updates individual ranks for C in self.Scenario.couples(self.ranking): # Making of the child child = Individual(self.Scenario, ID=self.free_ID(), Newborn=True) if child: child.hybrid( C[0], C[1]) # Child's DNA results from parents' DNA crossover child.mutate() # Child inherits shares: thus grand-children (and so on) also indirectly benefit from self-sacrifice child.inherit_share( C[0], C[1], heredity=percent( self.Scenario.Parameter('SacrificeHeredity'))) child.update( ) # Computes the value of genes, as DNA is available only now if self.Scenario.new_agent( child, C ): # Let scenario decide something about the newcomer (not used here) # Child is added to parents' children lists C[0].addChild(child) C[1].addChild(child) self.receive(child) # Adds child to the group
def evaluation(self, indiv): #print('indiv has {} friends'.format(indiv.nbFriends())) #print('indiv has {} friends and {} followers'.format(indiv.nbFriends(), indiv.nbFollowers())) if indiv.nbFollowers() == 0: # indiv is alone in the world self.alone(indiv, penalty=self.Parameter('AlonePenalty')) else: indiv.score(+self.Parameter('JoiningBonus') * indiv.nbFollowers()) # 0 by default # Sert vraiment a rien en principe... for follower in indiv.followers: follower.score(+self.Parameter('FriendshipValue')) # Friendship is beneficial no matter what if not indiv.patriot() == 0 and random() < percent( self.Parameter('NbTraitors')): # indiv is a traitor who betrays its friends for follower in indiv.followers: self.betrayed(follower, cost=self.Parameter('DenunciationCost')) indiv.score(+self.Parameter('Judas')) elif indiv.patriot(): # indiv is a true patriot : bonus (0 by default) for follower in indiv.followers: follower.score(+self.Parameter('PatriotFriendBonus')) return
def reproduction(self): """ Reproduction within the group (see Exogene) for details Calls local class 'Patriotic_Individual' """ self.update_(flagRanking=True) # updates individual ranks for C in self.Scenario.couples(self.ranking): # Making of the child child = Patriotic_Individual(self.Scenario, ID=self.free_ID(), Newborn=True) if child: child.hybrid( C[0], C[1]) # Child's DNA results from parents' DNA crossover child.mutate() child.inherit_share( C[0], C[1], heredity=percent( self.Scenario.Parameter('SacrificeHeredity'))) child.update( ) # Computes the value of genes, as DNA is available only now if self.Scenario.new_agent( child, C ): # Let scenario decide something about the newcomer (not used here) # Child is added to parents' children lists C[0].addChild(child) C[1].addChild(child) self.receive(child) # Adds child to the group
def interaction(self, indiv, Partner): """ Dyadic cooperative interaction: one player (indiv) makes the first step by offering a 'gift' to a partner. The latter then returns the favour. Both the gift and the returned reward are controlled by genes. Both involve costs. """ # First step: initial gift gift = percent(self.Parameter('FirstStep') * indiv.gene_relative_value('Cooperativeness')) Partner.score(noise_mult(gift,self.Parameter('Noise'))) # multiplicative noise # First player pays associated cost # Cost is a function of investment cost = percent(gift * self.Parameter('FirstStepCost')) indiv.score(-cost) # Receiver remembers who gave the gift Partner.follow(indiv, gift)
def new_agent(self, child, parents): child.inherit_share(parents[0], parents[1], heredity=percent( self.Parameter('SacrificeHeredity'))) for P in parents: P.addChild(child) return True
def end_game(self, members): """ Individuals get benefit from their alliances """ # Followees get benefit from being followed # Followers get benefit from following high quality individuals for Follower in members: for Friend in Follower.friends(): Friend.score(self.Parameter('FollowerSupport')) Follower.score(percent(self.Parameter('FollowerBenefit') * self.Quality(Friend, Apparent=False)))
def end_game(self, members): """ Individuals get benefit from their alliances """ # Followees get benefit from being followed # Followers get benefit from following high quality individuals for Follower in members: for Friend in Follower.friends(): Friend.score(self.Parameter('FollowerSupport')) Follower.score(percent(self.Parameter('FollowerBenefit') * self.Quality(Friend, Apparent=False)))
def memo_heroes(self, new_heroes, members, threshold=5): " Society, through its (alive)_ individuals, remembers its heroes " members.sort(key=lambda x: x.HeroesWitnessed, reverse=True) past_heroes = members[int(percent(threshold) * len(members))].HeroesWitnessed # Heroes pass off to posterity if they are "remembered" by a sufficient amount of alive individuals (threshold %) for indiv in members: indiv.HeroesWitnessed += new_heroes return past_heroes + new_heroes
def interactions(self, members, nb_interactions=1): """ Defines how the (alive) population interacts Used in 'life_game' """ for inter in range(nb_interactions): if not members: return Fan = choice(members) # Fan chooses friends from a sample of Partners Partners = self.partners(Fan, members, int(percent(self.Parameter('SampleSize')\ * (len(members)-1) ))) self.interact(Fan, Partners)
def end_game(self, members): """ Individuals get benefit from their alliances """ # computing inclusive strength # Followers get benefit from following; that benefit is # correlated with the competence of the signaller. for Agent in members: # self-service #Agent.Phene_value('Risk',100-self.SocialOffer(Agent, 0, Apparent=False)) Agent.Phene_value('Risk',100) for Agent in members: ## print 'end game', '%s(%d)' % (Agent.id, self.Competence(Agent,Apparent=False)), ## print Agent.gurus for (Rank,Friend) in enumerate(Agent.friends()): ## Friend.score(self.SocialOffer(Agent, Rank, Apparent=False)) AgentSocialOffer = self.Interactions.SocialOffer(self.Competence(Agent, Apparent=False), Rank, Agent.nbFriends()) Risk = percent(Friend.Phene_value('Risk') * (100 - percent(self.Parameter('CompetenceImpact') * AgentSocialOffer))) Friend.Phene_value('Risk',Risk) ## print 'Friend', Friend.id, 'gets protection', self.SocialOffer(Agent, Rank, Apparent=False) ## raw_input('.') for Agent in members: # agent get scores depending on their risk, # i.e. that grow with their accumulated protection Agent.score((100 - Agent.Phene_value('Risk'))) # Monitoring average distance between best friends Friend = Agent.best_friend() if Friend is not None: self.CompetenceAvgDistance += abs(Friend.Phene_value('Competence')-Agent.Phene_value('Competence')) # monitoring scores depending on competence for Agent in members: CR = self.CompetenceRange(Agent) self.RiskByCompetence[CR][0] += 1 self.RiskByCompetence[CR][1] += Agent.Phene_value('Risk')
def evaluation(self, indiv): indiv.score(+self.Parameter('JoiningBonus') * indiv.nbFollowers()) if indiv.Patriotism == 0 and random() < percent( self.Parameter('NbTraitors')): # indiv is a traitor who betrays its friends for follower in indiv.followers: follower.score(-self.Parameter('DenunciationCost') ) # The betrayed pay a cost indiv.score(+self.Parameter('Judas') ) # Betrayer obtains payment for betrayal else: for follower in indiv.followers: follower.score(+self.Parameter('FriendshipValue')) return
def interaction(self, gazelle, lion): if self.gazelle(gazelle) and lion: # a partner has been found - Hunt may begin if self.gazelle(lion): error("Gazelle scenario:", "Hunting gazelle") # the lion decides whether the gazelle is worth chasing chase = True if random.randint(1,100) < lion.gene_relative_intensity('LionSensitivityToSignal'): # this lion pays attention to jumps jump = self.jump(gazelle) # the gazelle pays the price gazelle.score(-percent(self.Parameter('JumpCost')*jump)) if jump > self.Parameter('Noise'): chase = False # This wise lion will consider another prey # Now the lion gets the benefit or cost of the chase if chase: if self.strongGazelle(gazelle): # SOMETHING'S MISSING HERE . . . lion.score(-self.Parameter('LostPreyCost')) else: lion.score(self.Parameter('HunterReward')) gazelle.score(-self.Parameter('PreyCost'))
def One_Step(self): " Interactions take place, then learning " # This procedure is repeatedly called by the simulation thread # Social interactions for agent in self.Pop: agent.Points = 0 agent.Risk = 100 # maximum risk # agent.lessening_friendship() # eroding past gurus performances ## for agent in self.Pop: ## # first interact with current friends ## for Partner in agent.friends(): ## agent.Interact([Partner]) for Run in range(Gbl.Parameters.Parameter('NbRuns')): if Gbl.ScenarioName == 'CostlySignal': Fan = choice(self.Pop) # Fan chooses from a sample Fan.Interact(sample(self.Pop, Gbl.Parameters.Parameter('SampleSize'))) elif Gbl.ScenarioName == 'Grooming': (Player, Partner) = sample(self.Pop, 2) Partner.Interact([Player]) for agent in self.Pop: # one looks whether interactions were profitable agent.assessment() for agent in self.Pop: agent.wins() # memorizes success #if self.Obs.Visible() and agent.Quality == 99: # print agent, '>>>', agent.Benefits, '{%d}' % agent.Points # print "%s --> %s" % (agent, agent.Benefits) # Learning occurs for one agent every NbRuns interactions Learner = choice(self.Pop) Children = self.Obs.StepId < percent(self.Obs.TimeLimit * Gbl.Parameters.Parameter('LearnHorizon')) Learner.Learns(self.neighbours(Learner), Children) # Learner should re-interact with its followers for Partner in Learner.followers.names(): Partner.Interact([Learner]) self.Obs.Positions[Learner.id] = Learner.Position if self.Obs.Visible(): ## self.Obs.Alliances = [(agent.id,[(agent.best_friend().id,0)]) ## for agent in self.Pop if agent.best_friend() is not None] ## self.Obs.Alliances += [(agent.id,[]) ## for agent in self.Pop if agent.best_friend() == None] self.Obs.Alliances = [(agent.id, [T.id for T in Alliances.signature(agent)]) for agent in self.Pop] return True # This value is forwarded to "ReturnFromThread"
def start_game(self,members): """ defines what is to be done at the group level before interactions occur """ for Indiv in members: # resetting scores so that scors remain positive Indiv.score(self.Parameter('CostlySignalCost'), FlagSet=True) SigInv = Indiv.Phene_value('SignalInvestment') SignalCost = percent(SigInv * self.Parameter('CostlySignalCost')) Indiv.score(-SignalCost) # Monitoring Quality distribution self.GlobalComm += SigInv self.QualityHistogram[self.QualityRange(Indiv)][0] += SigInv self.QualityHistogram[self.QualityRange(Indiv)][1] += 1 self.PopSize += len(members) # number of individuals currently present # Individuals first interact one more time with their current friends for Indiv in members: for Friend in Indiv.friends(): self.interaction(Indiv, Friend)
def start_game(self,members): """ defines what is to be done at the group level before interactions occur """ for Indiv in members: # resetting scores so that scors remain positive Indiv.score(self.Parameter('CostlySignalCost'), FlagSet=True) SigInv = Indiv.Phene_value('SignalInvestment') SignalCost = percent(SigInv * self.Parameter('CostlySignalCost')) Indiv.score(-SignalCost) # Monitoring Quality distribution self.GlobalComm += SigInv self.QualityHistogram[self.QualityRange(Indiv)][0] += SigInv self.QualityHistogram[self.QualityRange(Indiv)][1] += 1 self.PopSize += len(members) # number of individuals currently present # Individuals first interact one more time with their current friends for Indiv in members: for Friend in Indiv.friends(): self.interaction(Indiv, Friend)
def One_Step(self): " Interactions take place, then learning " # This procedure is repeatedly called by the simulation thread # Social interactions for agent in self.Pop: agent.Points = 0 agent.Risk = 100 # maximum risk ## for agent in self.Pop: ## # first interact with current friends ## for Partner in agent.friends(): ## agent.Interact(Partner) for Run in range(MyScenario.Parameter('NbRuns')): (Player, Partner) = sample(self.Pop, 2) Partner.Interact(Player) for agent in self.Pop: # one looks whether interactions were profitable agent.assessment() for agent in self.Pop: agent.wins() # memorizes success #if self.Obs.Visible() and agent.id == 99: # print agent, '>>>', agent.Benefits, '{%d}' % agent.Points # print "%s --> %s" % (agent, agent.Benefits) # Learning occurs for one agent every NbRuns interactions Learner = choice(self.Pop) Children = self.Obs.StepId < percent(self.Obs.TimeLimit * MyScenario.Parameter('LearnHorizon')) Learner.Learns(self.neighbours(Learner), Children) # Learner should re-interact with its followers for Partner in Learner.followers.names(): Partner.Interact(Learner) self.Obs.Positions[Learner.id] = Learner.Position if self.Obs.Visible(): ## self.Obs.Alliances = [(agent.id,[(agent.best_friend().id,0)]) ## for agent in self.Pop if agent.best_friend() is not None] ## self.Obs.Alliances += [(agent.id,[]) ## for agent in self.Pop if agent.best_friend() == None] self.Obs.Alliances = [(agent.id,Alliances.signature(agent)) for agent in self.Pop] return 0 # This value is forwarded to "ReturnFromThread"
def adult(self): return self.Age > percent(Gbl.Parameters.Parameter('AgeMax') * Gbl.Parameters.Parameter('Infancy'))
def adult(self): return self.Age > percent(MyScenario.Parameter('AgeMax') * MyScenario.Parameter('Infancy'))
def Cost(self, Feature=None): return percent(Gbl.Param('SignallingCost') * self.feature(Feature))