def test_init_from_resulsetfromfile(self):
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
tournament = axelrod.Tournament(players=[
axelrod.Cooperator(),
axelrod.TitForTat(),
axelrod.Defector()
],
turns=2,
repetitions=2)
tournament.play(filename=tmp_file.name, progress_bar=False)
tmp_file.close()
rs = axelrod.ResultSetFromFile(tmp_file.name, progress_bar=False)
plot = axelrod.Plot(rs)
self.assertEqual(plot.result_set, rs)
def test_init(self):
tournament = axelrod.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=self.test_turns,
processes=4,
noise=0.2)
self.assertEqual(len(tournament.players), len(test_strategies))
self.assertIsInstance(
tournament.players[0].match_attributes['game'], axelrod.Game
)
self.assertEqual(tournament.game.score(('C', 'C')), (3, 3))
self.assertEqual(tournament.turns, self.test_turns)
self.assertEqual(tournament.repetitions, 10)
self.assertEqual(tournament.name, 'test')
self.assertEqual(tournament._processes, 4)
self.assertTrue(tournament._with_morality)
self.assertIsInstance(tournament._logger, logging.Logger)
self.assertEqual(tournament.deterministic_cache, {})
self.assertEqual(tournament.noise, 0.2)
self.assertEqual(tournament._parallel_repetitions, 10)
anonymous_tournament = axelrod.Tournament(players=self.players)
self.assertEqual(anonymous_tournament.name, 'axelrod')
# Test init when passing a cache:
cache = axelrod.DeterministicCache()
tournament = axelrod.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=self.test_turns,
processes=4,
noise=0.2,
deterministic_cache=cache)
self.assertEqual(tournament.deterministic_cache, cache)
def test_complete_tournament(self, strategies, turns, repetitions,
noise, seed):
"""
A test to check that a spatial tournament on the complete multigraph
gives the same results as the round robin.
"""
players = [s() for s in strategies]
# edges
edges = []
for i in range(0, len(players)):
for j in range(i, len(players)):
edges.append((i, j))
# create a round robin tournament
tournament = axelrod.Tournament(players, repetitions=repetitions,
turns=turns, noise=noise)
# create a complete spatial tournament
spatial_tournament = axelrod.SpatialTournament(players,
repetitions=repetitions,
turns=turns,
noise=noise,
edges=edges)
axelrod.seed(seed)
results = tournament.play(progress_bar=False)
axelrod.seed(seed)
spatial_results = spatial_tournament.play(progress_bar=False)
self.assertEqual(results.ranked_names, spatial_results.ranked_names)
self.assertEqual(results.nplayers, spatial_results.nplayers)
self.assertEqual(results.repetitions, spatial_results.repetitions)
self.assertEqual(results.payoff_diffs_means,
spatial_results.payoff_diffs_means)
self.assertEqual(results.payoff_matrix, spatial_results.payoff_matrix)
self.assertEqual(results.payoff_stddevs, spatial_results.payoff_stddevs)
self.assertEqual(results.payoffs, spatial_results.payoffs)
self.assertEqual(results.cooperating_rating,
spatial_results.cooperating_rating)
self.assertEqual(results.cooperation, spatial_results.cooperation)
self.assertEqual(results.normalised_cooperation,
spatial_results.normalised_cooperation)
self.assertEqual(results.normalised_scores,
spatial_results.normalised_scores)
self.assertEqual(results.good_partner_matrix,
spatial_results.good_partner_matrix)
self.assertEqual(results.good_partner_rating,
spatial_results.good_partner_rating)
def test_write_to_csv(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=2,
repetitions=2)
tournament.play(filename=self.filename, progress_bar=False)
with open(self.filename, 'r') as f:
written_data = [[int(r[0]), int(r[1])] + r[2:]
for r in csv.reader(f)]
expected_data = [
[0, 1, 'Cooperator', 'Tit For Tat', 'CC', 'CC'],
[0, 1, 'Cooperator', 'Tit For Tat', 'CC', 'CC'],
[1, 2, 'Tit For Tat', 'Defector', 'CD', 'DD'],
[1, 2, 'Tit For Tat', 'Defector', 'CD', 'DD'],
[0, 0, 'Cooperator', 'Cooperator', 'CC', 'CC'],
[0, 0, 'Cooperator', 'Cooperator', 'CC', 'CC'],
[3, 3, 'Grudger', 'Grudger', 'CC', 'CC'],
[3, 3, 'Grudger', 'Grudger', 'CC', 'CC'],
[2, 2, 'Defector', 'Defector', 'DD', 'DD'],
[2, 2, 'Defector', 'Defector', 'DD', 'DD'],
[
4, 4, 'Soft Go By Majority', 'Soft Go By Majority', 'CC',
'CC'
],
[
4, 4, 'Soft Go By Majority', 'Soft Go By Majority', 'CC',
'CC'
], [1, 4, 'Tit For Tat', 'Soft Go By Majority', 'CC', 'CC'],
[1, 4, 'Tit For Tat', 'Soft Go By Majority', 'CC', 'CC'],
[1, 1, 'Tit For Tat', 'Tit For Tat', 'CC', 'CC'],
[1, 1, 'Tit For Tat', 'Tit For Tat', 'CC', 'CC'],
[1, 3, 'Tit For Tat', 'Grudger', 'CC', 'CC'],
[1, 3, 'Tit For Tat', 'Grudger', 'CC', 'CC'],
[2, 3, 'Defector', 'Grudger', 'DD', 'CD'],
[2, 3, 'Defector', 'Grudger', 'DD', 'CD'],
[0, 4, 'Cooperator', 'Soft Go By Majority', 'CC', 'CC'],
[0, 4, 'Cooperator', 'Soft Go By Majority', 'CC', 'CC'],
[2, 4, 'Defector', 'Soft Go By Majority', 'DD', 'CD'],
[2, 4, 'Defector', 'Soft Go By Majority', 'DD', 'CD'],
[0, 3, 'Cooperator', 'Grudger', 'CC', 'CC'],
[0, 3, 'Cooperator', 'Grudger', 'CC', 'CC'],
[3, 4, 'Grudger', 'Soft Go By Majority', 'CC', 'CC'],
[3, 4, 'Grudger', 'Soft Go By Majority', 'CC', 'CC'],
[0, 2, 'Cooperator', 'Defector', 'CC', 'DD'],
[0, 2, 'Cooperator', 'Defector', 'CC', 'DD']
]
self.assertEqual(sorted(written_data), sorted(expected_data))
def simulate_tournament_utility(player, opponents, turns=500, repetitions=200):
"""
Returns the simulated utility of a memory one strategy in a tournament.
"""
strategies = [axl.MemoryOnePlayer(p)
for p in opponents] + [axl.MemoryOnePlayer(player)]
number_of_players = len(strategies)
edges = [(i, number_of_players - 1) for i in range(number_of_players - 1)]
tournament = axl.Tournament(players=strategies,
turns=turns,
repetitions=repetitions,
edges=edges)
results = tournament.play(progress_bar=False)
return np.mean(results.normalised_scores[-1])
def test_run_parallel_repetitions(self):
outcome = {'payoff': [], 'cooperation': []}
tournament = axelrod.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions,
processes=2)
tournament._run_parallel_repetitions(outcome)
self.assertEqual(len(outcome['payoff']), self.test_repetitions)
self.assertEqual(len(outcome['cooperation']), self.test_repetitions)
for r in range(self.test_repetitions):
self.assertEqual(outcome['payoff'][r], self.expected_payoff)
self.assertEqual(
outcome['cooperation'][r], self.expected_cooperation)
def test_property_serial_play(self, s, turns, repetitions, rm):
"""Test serial play using hypothesis"""
# Test that we get an instance of ResultSet
players = [strat() for strat in s]
tournament = axelrod.Tournament(
name=self.test_name,
players=players,
game=self.game,
turns=turns,
repetitions=repetitions)
results = tournament.play()
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(len(results.cooperation), len(players))
self.assertEqual(results.nplayers, len(players))
self.assertEqual(results.players, players)
def main(players=players):
# Deleting the file if it exists
try:
os.remove(filename)
except OSError:
pass
axl.seed(seed) # Setting a seed
tournament = axl.Tournament(players,
prob_end=prob_end,
repetitions=repetitions)
results = tournament.play(filename=filename, processes=processes)
utils.obtain_assets(results, "strategies", "probend", lengthplot=True)
results.write_summary('assets/probend_summary.csv')
def test_read_interactions_from_file(self):
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
players = [axelrod.Cooperator(),
axelrod.Defector()]
tournament = axelrod.Tournament(players=players, turns=2, repetitions=3)
tournament.play(filename=tmp_file.name)
tmp_file.close()
expected_interactions = {(0, 0): [[('C', 'C'), ('C', 'C')] for _ in
range(3)],
(0, 1): [[('C', 'D'), ('C', 'D')] for _ in
range(3)],
(1, 1): [[('D', 'D'), ('D', 'D')] for _ in
range(3)]}
interactions = iu.read_interactions_from_file(tmp_file.name,
progress_bar=False)
self.assertEqual(expected_interactions, interactions)
def test_matches_have_different_length(self):
"""
A match between two players should have variable length across the
repetitions
"""
p1 = axl.Cooperator()
p2 = axl.Cooperator()
p3 = axl.Cooperator()
players = [p1, p2, p3]
tournament = axl.Tournament(players,
prob_end=0.5,
repetitions=2,
seed=3)
results = tournament.play(progress_bar=False)
# Check that match length are different across the repetitions
self.assertNotEqual(results.match_lengths[0], results.match_lengths[1])
def test_no_build_result_set(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions)
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
results = tournament.play(build_results=False,
filename=tmp_file.name,
progress_bar=False)
self.assertIsNone(results)
# Checking that results were written properly
results = axelrod.ResultSetFromFile(tmp_file.name)
self.assertIsInstance(results, axelrod.ResultSet)
def test_run_serial(self):
tournament = axl.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=axl.DEFAULT_TURNS,
repetitions=self.test_repetitions,
)
tournament._write_interactions_to_file = MagicMock(
name="_write_interactions_to_file"
)
self.assertTrue(tournament._run_serial())
# Get the calls made to write_interactions
calls = tournament._write_interactions_to_file.call_args_list
self.assertEqual(len(calls), 15)
def test_write_to_csv_without_results(self):
tournament = axl.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=2,
repetitions=2,
)
tournament.play(filename=self.filename,
progress_bar=False,
build_results=False)
df = pd.read_csv(self.filename)
path = pathlib.Path(
"test_outputs/expected_test_tournament_no_results.csv")
expected_df = pd.read_csv(axl_filename(path))
self.assertTrue(df.equals(expected_df))
def test_process_done_queue(self):
workers = 2
done_queue = Queue()
matches = []
tournament = axelrod.Tournament(
name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions)
for r in range(self.test_repetitions):
done_queue.put({})
for w in range(workers):
done_queue.put('STOP')
tournament._process_done_queue(workers, done_queue, matches)
self.assertEqual(len(matches), self.test_repetitions)
def test_specific_set_of_results(self):
"""
This tests specific reported results as discussed in
https://github.com/Axelrod-Python/Axelrod/issues/1294
The results there used a version of mistrust with a bug that corresponds
to a memory one player that start by defecting and only cooperates if
both players cooperated in the previous round.
"""
mistrust_with_bug = axl.MemoryOnePlayer(
initial=D,
four_vector=(1, 0, 0, 0),
)
players = [
self.player(),
axl.TitForTat(),
axl.GoByMajority(),
axl.Grudger(),
axl.WinStayLoseShift(),
axl.Prober(),
axl.Defector(),
mistrust_with_bug,
axl.Cooperator(),
axl.CyclerCCD(),
axl.CyclerDDC(),
]
axl.seed(1)
tournament = axl.Tournament(players, turns=1000, repetitions=1)
results = tournament.play(progress_bar=False)
scores = [
round(average_score_per_turn * 1000, 1)
for average_score_per_turn in results.payoff_matrix[0]
]
expected_scores = [
3000.0,
3000.0,
3000.0,
3000.0,
3000.0,
2999.0,
983.0,
983.0,
3000.0,
3596.0,
2302.0,
]
self.assertEqual(scores, expected_scores)
def playWithHete(TD, DP, MC):
ccPercent = [[0], [0], [0]]
ccCnt = 0
players = [TD, DP]
match = axl.Match(players, turns=10000)
result = match.play()
# print result
for i in range(1, 10000):
if result[i] == ('C', 'C'):
ccCnt += 1
ccPercent[0].append(ccCnt / i)
ccCnt = 0
players = [TD, MC]
match = axl.Match(players, turns=10000)
result = match.play()
# print result
for i in range(1, 10000):
if result[i] == ('C', 'C'):
ccCnt += 1
ccPercent[1].append(ccCnt / i)
ccCnt = 0
players = [DP, MC]
match = axl.Match(players, turns=10000)
result = match.play()
# print result
for i in range(1, 10000):
if result[i] == ('C', 'C'):
ccCnt += 1
ccPercent[2].append(ccCnt / i)
print ccPercent[0]
print len(ccPercent[0])
print ccPercent[1]
print len(ccPercent[1])
print ccPercent[2]
print len(ccPercent[2])
drawCCPercent(ccPercent, False)
# heat graph
players = [TD, DP, MC]
tournament = axl.Tournament(players, turns=10000)
results = tournament.play()
plot = axl.Plot(results)
p = plot.payoff()
p.savefig("heat graph")
def prob_end_tournaments(
draw,
strategies=axl.short_run_time_strategies,
min_size=1,
max_size=10,
min_prob_end=0,
max_prob_end=1,
min_noise=0,
max_noise=1,
min_repetitions=1,
max_repetitions=20,
):
"""
A hypothesis decorator to return a tournament,
Parameters
----------
min_size : integer
The minimum number of strategies to include
max_size : integer
The maximum number of strategies to include
min_prob_end : float
The minimum probability of a match ending
max_prob_end : float
The maximum probability of a match ending
min_noise : float
The minimum noise value
max_noise : float
The maximum noise value
min_repetitions : integer
The minimum number of repetitions
max_repetitions : integer
The maximum number of repetitions
"""
strategies = draw(
strategy_lists(strategies=strategies, min_size=min_size, max_size=max_size)
)
players = [s() for s in strategies]
prob_end = draw(floats(min_value=min_prob_end, max_value=max_prob_end))
repetitions = draw(integers(min_value=min_repetitions, max_value=max_repetitions))
noise = draw(floats(min_value=min_noise, max_value=max_noise))
tournament = axl.Tournament(
players, prob_end=prob_end, repetitions=repetitions, noise=noise
)
return tournament
def test_one_turn_tournament(self, tournament, seed):
"""
Tests that gives same result as the corresponding spatial round robin
spatial tournament
"""
prob_end_tour = axelrod.Tournament(tournament.players,
prob_end=1,
edges=tournament.edges,
repetitions=tournament.repetitions)
axelrod.seed(seed)
prob_end_results = prob_end_tour.play(progress_bar=False)
axelrod.seed(seed)
one_turn_results = tournament.play(progress_bar=False)
self.assertEqual(prob_end_results.scores, one_turn_results.scores)
self.assertEqual(prob_end_results.wins, one_turn_results.wins)
self.assertEqual(prob_end_results.cooperation,
one_turn_results.cooperation)
def test_no_build_result_set(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=axelrod.DEFAULT_TURNS,
repetitions=self.test_repetitions)
tournament._calculate_results = MagicMock(name='_calculate_results')
# Mocking this as it is called by play
self.assertIsNone(
tournament.play(filename=self.filename,
progress_bar=False,
build_results=False))
# Get the calls made to write_interactions
calls = tournament._calculate_results.call_args_list
self.assertEqual(len(calls), 0)
def test_write_interactions(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=2,
repetitions=2)
tournament._write_interactions_to_file = MagicMock(
name='_write_interactions_to_file')
# Mocking this as it is called by play
self.assertIsNone(
tournament.play(filename=self.filename,
progress_bar=False,
build_results=False))
# Get the calls made to write_interactions
calls = tournament._write_interactions_to_file.call_args_list
self.assertEqual(len(calls), 15)
def test_init(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
prob_end=self.test_prob_end,
edges=self.test_edges,
noise=0.2)
self.assertEqual(tournament.match_generator.edges, tournament.edges)
self.assertEqual(len(tournament.players), len(test_strategies))
self.assertEqual(tournament.game.score((C, C)), (3, 3))
self.assertIsNone(tournament.turns)
self.assertEqual(tournament.repetitions, 10)
self.assertEqual(tournament.name, 'test')
self.assertIsInstance(tournament._logger, logging.Logger)
self.assertEqual(tournament.noise, 0.2)
self.assertEqual(tournament.match_generator.noise, 0.2)
self.assertEqual(tournament.prob_end, self.test_prob_end)
def get_test_outcome(cls, outcome, turns=10):
# Extract the name of players from the outcome tuples,
# and initiate the players by getting the classes from axelrod.
names = [out[0] for out in outcome]
players = [getattr(axl, n)() for n in names]
# Play the tournament and build the actual outcome tuples.
tournament = axl.Tournament(players=players,
game=cls.game,
turns=turns,
repetitions=1)
results = tournament.play(progress_bar=False)
scores = [score[0] for score in results.scores]
outcome = zip(names, scores)
# Return the outcome sorted by score
return sorted(outcome, key=lambda k: k[1])
def main(players=players):
# Deleting the file if it exists
try:
os.remove(filename)
except OSError:
pass
axl.seed(seed) # Setting a seed
tournament = axl.Tournament(players,
turns=turns,
repetitions=repetitions,
noise=noise)
results = tournament.play(filename=filename, processes=processes)
utils.obtain_assets(results, "strategies", "noisy")
results.write_summary('assets/noisy_summary.csv')
def playWithFixed(TD, DP, MC):
C = axl.Cooperator()
D = axl.Defector()
TFT = axl.TitForTat()
BUL = axl.Bully()
PAV = Pavlov()
APAV = axl.APavlov2011()
for learner in [TD,DP,MC]:
players = [C, D, TFT, BUL, PAV, APAV, learner]
tournament = axl.Tournament(players, turns=10000)
results = tournament.play()
title = learner.name + " VS Fixed Strategy Players"
plot = axl.Plot(results)
p = plot.boxplot(title)
p.savefig(learner.name)
def test_repeat_tournament_stochastic(self):
"""
A test to check that tournament gives same results when setting seed.
"""
files = []
for _ in range(2):
axelrod.seed(0)
stochastic_players = [s() for s in axelrod.strategies
if s().classifier['stochastic']]
tournament = axelrod.Tournament(name='test',
players=stochastic_players,
game=self.game, turns=2,
repetitions=2)
files.append("test_outputs/stochastic_tournament_{}.csv".format(_))
tournament.play(progress_bar=False, filename=files[-1],
build_results=False)
self.assertTrue(filecmp.cmp(files[0], files[1]))
def test_write_interactions(self):
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=2,
repetitions=2)
tournament._write_interactions = MagicMock(name='_write_interactions')
tournament._build_result_set = MagicMock(
name='_build_result_set') # Mocking this as it is called by play
self.assertTrue(
tournament.play(filename=tmp_file.name, progress_bar=False))
tournament.outputfile.close(
) # This is normally closed by `build_result_set`
# Get the calls made to write_interactions
calls = tournament._write_interactions.call_args_list
self.assertEqual(len(calls), 15)
def test_init(self):
tournament = axelrod.ProbEndTournament(name=self.test_name,
players=self.players,
game=self.game,
prob_end=self.test_prob_end,
noise=0.2)
self.assertEqual(tournament.match_generator.prob_end,
tournament.prob_end)
self.assertEqual(len(tournament.players), len(test_strategies))
self.assertEqual(tournament.game.score(('C', 'C')), (3, 3))
self.assertEqual(tournament.turns, float("inf"))
self.assertEqual(tournament.repetitions, 10)
self.assertEqual(tournament.name, 'test')
self.assertTrue(tournament._with_morality)
self.assertIsInstance(tournament._logger, logging.Logger)
self.assertEqual(tournament.noise, 0.2)
anonymous_tournament = axelrod.Tournament(players=self.players)
self.assertEqual(anonymous_tournament.name, 'axelrod')
def tournaments(
draw,
strategies=axl.short_run_time_strategies,
min_size=1,
max_size=10,
min_turns=1,
max_turns=200,
min_noise=0,
max_noise=1,
min_repetitions=1,
max_repetitions=20,
):
"""
A hypothesis decorator to return a tournament.
Parameters
----------
min_size : integer
The minimum number of strategies to include
max_size : integer
The maximum number of strategies to include
min_turns : integer
The minimum number of turns
max_turns : integer
The maximum number of turns
min_noise : float
The minimum noise value
min_noise : float
The maximum noise value
min_repetitions : integer
The minimum number of repetitions
max_repetitions : integer
The maximum number of repetitions
"""
strategies = draw(
strategy_lists(strategies=strategies, min_size=min_size, max_size=max_size)
)
players = [s() for s in strategies]
turns = draw(integers(min_value=min_turns, max_value=max_turns))
repetitions = draw(integers(min_value=min_repetitions, max_value=max_repetitions))
noise = draw(floats(min_value=min_noise, max_value=max_noise))
tournament = axl.Tournament(players, turns=turns, repetitions=repetitions, noise=noise)
return tournament
def test_build_cache_required(self):
# Noisy, no prebuilt cache, empty deterministic cache
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
processes=4,
noise=0.2,
prebuilt_cache=False)
self.assertFalse(tournament._build_cache_required())
# Noisy, with prebuilt cache, empty deterministic cache
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
processes=4,
noise=0.2,
prebuilt_cache=True)
self.assertFalse(tournament._build_cache_required())
# Not noisy, with prebuilt cache, deterministic cache has content
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
processes=4,
prebuilt_cache=True)
tournament.deterministic_cache = {'test': 100}
self.assertFalse(tournament._build_cache_required())
# Not noisy, no prebuilt cache, deterministic cache has content
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
processes=4,
prebuilt_cache=False)
tournament.deterministic_cache = {'test': 100}
self.assertTrue(tournament._build_cache_required())
# Not noisy, with prebuilt cache, empty deterministic cache
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
processes=4,
prebuilt_cache=True)
self.assertTrue(tournament._build_cache_required())
# Not noisy, no prebuilt cache, empty deterministic cache
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
processes=4,
prebuilt_cache=False)
self.assertTrue(tournament._build_cache_required())
def test_repeat_tournament_deterministic(self):
"""A test to check that tournament gives same results."""
deterministic_players = [
s()
for s in axelrod.short_run_time_strategies
if not s().classifier["stochastic"]
]
files = []
for _ in range(2):
tournament = axelrod.Tournament(
name="test",
players=deterministic_players,
game=self.game,
turns=2,
repetitions=2,
)
files.append("test_outputs/stochastic_tournament_{}.csv".format(_))
tournament.play(progress_bar=False, filename=files[-1], build_results=False)
self.assertTrue(filecmp.cmp(files[0], files[1]))
