Re write the result set

At present the result set plays the matches in parallel followed by a
(sometimes computationally expensive) single process of reading in and
analysing the interactions.

TLDR: This changes how the internal result set calculations are being
done. They are more efficiently calculated.

This happens by doing the following:

1. The various match by match calculations are done by the tournament
   (the winner of a match, the cooperation count, the score etc...).
2. This calculations are written to file (at present we just write the
  actual actions of an interaction).
3. The form of this file has also changed: for every match there are 2
   rows. One row corresponds to each player. This might seem costly storage
   wise but is done to enable faster analysis (more on that later).
4. The analysis is now done entirely using `dask`: "Dask is a flexible
   parallel computing library for analytic computing."
   (https://dask.pydata.org/). This ensures all calculations are done on
   disk (so no huge memory problems) but also that they can be done **in
   parallel**. This is all done using the nice Pandas-like API that dask
   has so essentially all calculations for the result set are just done
   by a few `groupby` statements.
5. There is *some* work being done outside of dask but that's just
   reshaping data. `dask` outputs `pandas.Series` and to be consistent
   with our current setup these are changes to be lists of list etc...

**Some user facing changes** (which is why I suggest this would be for a
`v4.0.0` release):

- The `result_set.interactions` is no longer possible. This is a choice
  and not forced by the redesign: I don't think this is ever necessary or
  helpful. The data file can always be read in.
- The ability to `tournament.play(in_memory=True)` has been removed.
  Again, not entirely a forced change (although it would be a tiny bit
  of work to allow this). Given the recent work to make everything work
  on Windows I don't think this is necessary and has allowed for a big
  deletion of code (which is a good thing re maintenance).
- The interactions data file is now in a different format, this is
  forced by the design choice.
- I have made a slight modification to `result_set.cooperation`.
  Currently this sets all self interactions to be 0 but I think that's not
  the right way to display it (note that the cooperation rates were all
  being done correctly).

**As well as ensuring the work done in series is reduced and the parallel
workers also calculate the scores (which I think is more efficient)**
this also seems to be faster:

On this branch:

```python
import axelrod as axl
players = [s() for s in axl.strategies if s.classifier["memory_depth"] == 1]
tournament = axl.Tournament(players, turns=200, repetitions=100)
results = tournament.play(processes=4)
```

Took: 1min 49s

```python
import axelrod as axl
players = [s() for s in axl.short_run_time_strategies]
tournament = axl.Tournament(players, turns=200, repetitions=20)
results = tournament.play(processes=4)
```

Took: 21min 2s

On current master;

```python
import axelrod as axl
players = [s() for s in axl.strategies if s.classifier["memory_depth"] == 1]
tournament = axl.Tournament(players, turns=200, repetitions=100)
results = tournament.play(processes=4)
```

Took: 2min 36s

```python
import axelrod as axl
players = [s() for s in axl.short_run_time_strategies]
tournament = axl.Tournament(players, turns=200, repetitions=20)
results = tournament.play(processes=4)
```

Took: 28min 8s

**One final aspect to consider** (I think) is that adding `dask` as a
dependency open up the potential to use it's `delayed` decorator to do
all our parallel processing. This would have the benefit of being able
to use a distributed scheduler that `dask` has. (We'd have to
investigate if this actually works based on our parallelisation but at
least the possibility is there).

Author: drvinceknight

.gitignore

@@ -4,7 +4,7 @@ cache.txt
 test.csv
 summary.csv
 basic_tournament.csv
-test_outputs/*csv
+test_outputs/*csv.summary
 test_outputs/*svg
 test_outputs/*cache
 
@@ -118,3 +118,12 @@ docker-compose.yml
 
 # Mypy files
 .mypy_cache/
+
+test_outputs/stochastic_tournament_0.csv
+test_outputs/stochastic_tournament_1.csv
+test_outputs/test_fingerprint.csv
+test_outputs/test_fingerprint_tmp.csv
+test_outputs/test_results_from_file.csv
+test_outputs/test_results_from_file_tmp.csv
+test_outputs/test_tournament.csv
+test_outputs/tran_fin.csv

axelrod/__init__.py

@@ -18,7 +18,7 @@
 from .deterministic_cache import DeterministicCache
 from .match_generator import *
 from .tournament import Tournament
-from .result_set import ResultSet, ResultSetFromFile
+from .result_set import ResultSet
 from .ecosystem import Ecosystem
 from .fingerprint import AshlockFingerprint, TransitiveFingerprint
 

axelrod/ecosystem.py

@@ -12,7 +12,7 @@ def __init__(self, results: ResultSet,
                  population: List[int] = None) -> None:
 
         self.results = results
-        self.nplayers = self.results.nplayers
+        self.num_players = self.results.num_players
         self.payoff_matrix = self.results.payoff_matrix
         self.payoff_stddevs = self.results.payoff_stddevs
 
@@ -27,15 +27,15 @@ def __init__(self, results: ResultSet,
             if min(population) < 0:
                 raise TypeError(
                     "Minimum value of population vector must be non-negative")
-            elif len(population) != self.nplayers:
+            elif len(population) != self.num_players:
                 raise TypeError(
                     "Population vector must be same size as number of players")
             else:
                 norm = sum(population)
                 self.population_sizes = [[p / norm for p in population]]
         else:
             self.population_sizes = [
-                [1 / self.nplayers for _ in range(self.nplayers)]]
+                [1 / self.num_players for _ in range(self.num_players)]]
 
         # This function is quite arbitrary and probably only influences the
         # kinetics for the current code.
@@ -47,7 +47,7 @@ def __init__(self, results: ResultSet,
     def reproduce(self, turns: int):
 
         for iturn in range(turns):
-            plist = list(range(self.nplayers))
+            plist = list(range(self.num_players))
             pops = self.population_sizes[-1]
 
             # The unit payoff for each player in this turn is the sum of the

axelrod/fingerprint.py

@@ -6,6 +6,8 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import tqdm
+import dask.dataframe as dd
+import dask as da
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 import axelrod as axl
@@ -266,7 +268,7 @@ def construct_tournament_elements(self, step: float,
 
     def fingerprint(
         self, turns: int = 50, repetitions: int = 10, step: float = 0.01,
-        processes: int=None, filename: str = None, in_memory: bool = False,
+        processes: int=None, filename: str = None,
         progress_bar: bool = True
 ) -> dict:
         """Build and play the spatial tournament.
@@ -290,10 +292,7 @@ def fingerprint(
             The number of processes to be used for parallel processing
         filename: str, optional
             The name of the file for self.spatial_tournament's interactions.
-            if None and in_memory=False, will auto-generate a filename.
-        in_memory: bool
-            Whether self.spatial_tournament keeps interactions_dict in memory or
-            in a file.
+            if None, will auto-generate a filename.
         progress_bar : bool
             Whether or not to create a progress bar which will be updated
 
@@ -305,7 +304,7 @@ def fingerprint(
         """
 
         temp_file_descriptor = None
-        if not in_memory and filename is None:
+        if filename is None:
             temp_file_descriptor, filename = mkstemp()
 
         edges, tourn_players = self.construct_tournament_elements(
@@ -318,13 +317,10 @@ def fingerprint(
         self.spatial_tournament.play(build_results=False,
                                      filename=filename,
                                      processes=processes,
-                                     in_memory=in_memory,
                                      progress_bar=progress_bar)
-        if in_memory:
-            self.interactions = self.spatial_tournament.interactions_dict
-        else:
-            self.interactions = read_interactions_from_file(
-                filename, progress_bar=progress_bar)
+
+        self.interactions = read_interactions_from_file(
+            filename, progress_bar=progress_bar)
 
         if temp_file_descriptor is not None:
             os.close(temp_file_descriptor)
@@ -483,17 +479,19 @@ def analyse_cooperation_ratio(filename):
             opponent in each turn. The ith row corresponds to the ith opponent
             and the jth column the jth turn.
         """
-        did_c = np.vectorize(lambda action: int(action == 'C'))
+        did_c = np.vectorize(lambda actions: [int(action == 'C')
+                                              for action in actions])
 
         cooperation_rates = {}
-        with open(filename, "r") as f:
-            reader = csv.reader(f)
-            for row in reader:
-                opponent_index, player_history = int(row[1]), list(row[4])
-                if opponent_index in cooperation_rates:
-                    cooperation_rates[opponent_index].append(did_c(player_history))
-                else:
-                    cooperation_rates[opponent_index] = [did_c(player_history)]
+        df = dd.read_csv(filename)
+        df = df[df["Player index"] == 0][["Opponent index", "Actions"]]
+
+        for _, row in df.iterrows():
+            opponent_index, player_history = row["Opponent index"], row["Actions"]
+            if opponent_index in cooperation_rates:
+                cooperation_rates[opponent_index].append(did_c(player_history))
+            else:
+                cooperation_rates[opponent_index] = [did_c(player_history)]
 
         for index, rates in cooperation_rates.items():
             cooperation_rates[index] = np.mean(rates, axis=0)

axelrod/interaction_utils.py

@@ -10,6 +10,7 @@
 from collections import Counter
 import csv
 import tqdm
+import pandas as pd
 
 from axelrod.action import Action, str_to_actions
 from .game import Game
@@ -239,36 +240,27 @@ def compute_sparklines(interactions, c_symbol='█', d_symbol=' '):
         sparkline(histories[1], c_symbol, d_symbol))
 
 
-def read_interactions_from_file(filename, progress_bar=True,
-                                num_interactions=False):
+def read_interactions_from_file(filename,
+                                progress_bar=True,
+                                ):
     """
     Reads a file and returns a dictionary mapping tuples of player pairs to
     lists of interactions
     """
+    df = pd.read_csv(filename)[["Interaction index", "Player index",
+                                "Opponent index", "Actions"]]
+    groupby = df.groupby("Interaction index")
     if progress_bar:
-        if not num_interactions:
-            with open(filename) as f:
-                num_interactions = sum(1 for line in f)
-        progress_bar = tqdm.tqdm(total=num_interactions, desc="Loading")
+        groupby = tqdm.tqdm(groupby)
 
     pairs_to_interactions = {}
-    with open(filename, 'r') as f:
-        for row in csv.reader(f):
-            index_pair = (int(row[0]), int(row[1]))
-            p1_actions = str_to_actions(row[4])
-            p2_actions = str_to_actions(row[5])
-            interaction = list(zip(p1_actions, p2_actions))
-
-            try:
-                pairs_to_interactions[index_pair].append(interaction)
-            except KeyError:
-                pairs_to_interactions[index_pair] = [interaction]
-
-            if progress_bar:
-                progress_bar.update()
-
-    if progress_bar:
-        progress_bar.close()
+    for _, d in tqdm.tqdm(groupby):
+        key = tuple(d[["Player index", "Opponent index"]].iloc[0])
+        value = list(map(str_to_actions, zip(*d["Actions"])))
+        try:
+            pairs_to_interactions[key].append(value)
+        except KeyError:
+            pairs_to_interactions[key] = [value]
     return pairs_to_interactions
 
 

axelrod/plot.py

@@ -25,7 +25,7 @@ def default_cmap(version: str = "2.0") -> str:
 class Plot(object):
     def __init__(self, result_set: ResultSet) -> None:
         self.result_set = result_set
-        self.nplayers = self.result_set.nplayers
+        self.num_players = self.result_set.num_players
         self.players = self.result_set.players
 
     def _violinplot(
@@ -40,16 +40,16 @@ def _violinplot(
             ax = ax
 
         figure = ax.get_figure()
-        width = max(self.nplayers / 3, 12)
+        width = max(self.num_players / 3, 12)
         height = width / 2
         spacing = 4
-        positions = spacing * arange(1, self.nplayers + 1, 1)
+        positions = spacing * arange(1, self.num_players + 1, 1)
         figure.set_size_inches(width, height)
         ax.violinplot(data, positions=positions, widths=spacing / 2,
                       showmedians=True, showextrema=False)
         ax.set_xticks(positions)
         ax.set_xticklabels(names, rotation=90)
-        ax.set_xlim([0, spacing * (self.nplayers + 1)])
+        ax.set_xlim([0, spacing * (self.num_players + 1)])
         ax.tick_params(axis='both', which='both', labelsize=8)
         if title:
             ax.set_title(title)
@@ -175,14 +175,14 @@ def _payoff_heatmap(
             ax = ax
 
         figure = ax.get_figure()
-        width = max(self.nplayers / 4, 12)
+        width = max(self.num_players / 4, 12)
         height = width
         figure.set_size_inches(width, height)
         matplotlib_version = matplotlib.__version__
         cmap = default_cmap(matplotlib_version)
         mat = ax.matshow(data, cmap=cmap)
-        ax.set_xticks(range(self.result_set.nplayers))
-        ax.set_yticks(range(self.result_set.nplayers))
+        ax.set_xticks(range(self.result_set.num_players))
+        ax.set_yticks(range(self.result_set.num_players))
         ax.set_xticklabels(names, rotation=90)
         ax.set_yticklabels(names)
         ax.tick_params(axis='both', which='both', labelsize=16)
@@ -246,7 +246,7 @@ def stackplot(
         ticks = []
         for i, n in enumerate(self.result_set.ranked_names):
             x = -0.01
-            y = (i + 0.5) * 1 / self.result_set.nplayers
+            y = (i + 0.5) * 1 / self.result_set.num_players
             ax.annotate(
                 n, xy=(x, y), xycoords=trans, clip_on=False, va='center',
                 ha='right', fontsize=5)