Moran Process

The strategies in the library can be pitted against one another in the Moran process, a population process simulating natural selection.

The process works as follows. Given an initial population of players, the population is iterated in rounds consisting of:

  • matches played between each pair of players, with the cumulative total scores recorded

  • a player is chosen to reproduce proportional to the player’s score in the round

  • a player is chosen at random to be replaced

The process proceeds in rounds until the population consists of a single player type. That type is declared the winner. To run an instance of the process with the library, proceed as follows:

>>> import axelrod as axl
>>> players = [axl.Cooperator(), axl.Defector(),
...            axl.TitForTat(), axl.Grudger()]
>>> mp = axl.MoranProcess(players, seed=1)
>>> populations = mp.play()
>>> mp.winning_strategy_name
'Tit For Tat'

You can access some attributes of the process, such as the number of rounds:

>>> len(mp)
15

The sequence of populations:

>>> import pprint
>>> pprint.pprint(populations)  
[Counter({'Defector': 1, 'Tit For Tat': 1, 'Grudger': 1, 'Cooperator': 1}),
 Counter({'Defector': 1, 'Tit For Tat': 1, 'Grudger': 1, 'Cooperator': 1}),
 Counter({'Cooperator': 2, 'Defector': 1, 'Tit For Tat': 1}),
 Counter({'Defector': 2, 'Cooperator': 2}),
 Counter({'Cooperator': 3, 'Defector': 1}),
 Counter({'Cooperator': 3, 'Defector': 1}),
 Counter({'Defector': 2, 'Cooperator': 2}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 3, 'Cooperator': 1}),
 Counter({'Defector': 4})]

The scores in each round:

>>> for row in mp.score_history:
...     print([round(element, 1) for element in row])
[6.0, 7.0, 7.0, 7.0]
[7.0, 3.1, 7.0, 7.0]
[7.0, 3.1, 7.0, 7.0]
[7.0, 3.1, 7.0, 7.0]
[7.0, 3.1, 7.0, 7.0]
[3.0, 3.0, 5.0, 5.0]
[3.0, 3.0, 5.0, 5.0]
[3.1, 7.0, 7.0, 7.0]
[3.1, 7.0, 7.0, 7.0]
[9.0, 9.0, 9.0, 9.0]
[9.0, 9.0, 9.0, 9.0]
[9.0, 9.0, 9.0, 9.0]
[9.0, 9.0, 9.0, 9.0]
[9.0, 9.0, 9.0, 9.0]

We can plot the results of a Moran process with mp.populations_plot(). Let’s use a larger population to get a bit more data:

>>> import random
>>> import matplotlib.pyplot as plt
>>> players = [axl.Defector(), axl.Defector(), axl.Defector(),
...        axl.Cooperator(), axl.Cooperator(), axl.Cooperator(),
...        axl.TitForTat(), axl.TitForTat(), axl.TitForTat(),
...        axl.Random()]
>>> mp = axl.MoranProcess(players=players, turns=200, seed=2)
>>> populations = mp.play()
>>> mp.winning_strategy_name
'Tit For Tat'
>>> ax = mp.populations_plot()
>>> plt.show()
../../_images/moran_example.svg

Moran Process with Mutation

The MoranProcess class also accepts an argument for a mutation rate. Nonzero mutation changes the Markov process so that it no longer has absorbing states, and will iterate forever. To prevent this, iterate with a loop (or function like takewhile from itertools):

>>> import axelrod as axl
>>> players = [axl.Cooperator(), axl.Defector(),
...            axl.TitForTat(), axl.Grudger()]
>>> mp = axl.MoranProcess(players, mutation_rate=0.1, seed=10)
>>> for _ in mp:
...     if len(mp.population_distribution()) == 1:
...         break
>>> mp.population_distribution()
Counter({'Defector': 4})

It is possible to pass a fitness function that scales the utility values. A common one used in the literature, [Ohtsuki2006], is \(f(s) = 1 - w + ws\) where \(w\) denotes the intensity of selection:

>>> players = (axl.Cooperator(), axl.Defector(), axl.Defector(), axl.Defector())
>>> w = 0.95
>>> fitness_transformation = lambda score: 1 - w + w * score
>>> mp = axl.MoranProcess(players, turns=10, fitness_transformation=fitness_transformation, seed=3)
>>> populations = mp.play()
>>> mp.winning_strategy_name
'Defector'

Other types of implemented Moran processes: