Abstract out common code and refactor

Author: marcharper

analyze_data.py

@@ -7,11 +7,16 @@ def read_top_tables(filename, n):
     with open(filename) as data:
         for line in data:
             results.append(line.split(','))
-    results.sort(reverse=True, key=itemgetter(2))
+
+    with open(filename) as data:
+        reader = csv.reader(data)
+        for line in reader:
+            results.append((float(line[3]), int(line[0]), line[-1]))
+    results.sort(reverse=True, key=itemgetter(0))
     return results[:n]
 
 if __name__ == "__main__":
     data_filename = sys.argv[1]
     results = read_top_tables(data_filename, 10)
     for result in results:
-        print(result[2], result[1])
+        print(result[0], result[-1])

analyze_weights.py

@@ -0,0 +1,20 @@
+import csv
+from operator import itemgetter
+import sys
+
+def read_top_tables(filename, n):
+    """Read in the n top performing results from a given file"""
+    results = []
+    with open(filename) as data:
+        reader = csv.reader(data)
+        for line in reader:
+            results.append((float(line[5]), int(line[0]),
+                            list(map(float, line[6:]))))
+    results.sort(reverse=True, key=itemgetter(0))
+    return results[:n]
+
+if __name__ == "__main__":
+    data_filename = sys.argv[1]
+    results = read_top_tables(data_filename, 1)
+    for result in results:
+        print(result)

ann_evolve.py

@@ -6,125 +6,122 @@
 
 Usage:
     ann_evolve.py [-h] [-g GENERATIONS] [-u MUTATION_RATE] [-b BOTTLENECK]
-    [-d mutation_distance] [-i PROCESSORS] [-o OUTPUT_FILE]
-    [-k STARTING_POPULATION]
+    [-d MUTATION_DISTANCE] [-i PROCESSORS] [-o OUTPUT_FILE]
+    [-k STARTING_POPULATION] [-n NOISE]
 
 Options:
     -h --help                    show this
-    -g GENERATIONS               how many generations to run the program for [default: 100]
-    -u MUTATION_RATE             mutation rate i.e. probability that a given value will flip [default: 0.1]
-    -d MUTATION_DISTANCE         amount of change a mutation will cause [default: 0.5]
-    -b BOTTLENECK                number of individuals to keep from each generation [default: 10]
-    -i PROCESSORS                number of processors to use [default: 1]
-    -o OUTPUT_FILE               file to write statistics to [default: ann_out.csv]
+    -g GENERATIONS               how many generations to run the program for [default: 10000]
+    -u MUTATION_RATE             mutation rate i.e. probability that a given value will flip [default: 0.4]
+    -d MUTATION_DISTANCE         amount of change a mutation will cause [default: 10]
+    -b BOTTLENECK                number of individuals to keep from each generation [default: 6]
+    -i PROCESSORS                number of processors to use [default: 4]
+    -o OUTPUT_FILE               file to write statistics to [default: weights.csv]
     -k STARTING_POPULATION       starting population size for the simulation [default: 5]
+    -n NOISE                     match noise [default: 0.0]
 """
 
-
-from __future__ import division
-
-import copy
-import random
+import csv
+from copy import deepcopy
+from itertools import repeat
 from multiprocessing import Pool
+import os
+import random
 from statistics import mean, pstdev
 
 from docopt import docopt
+import numpy as np
 
-import axelrod as axl
 from axelrod.strategies.ann import ANN, split_weights
-from axelrod_utils import mean, pstdev
+from axelrod_utils import score_for, objective_match_score, objective_match_moran_win
 
+## Neural network specifics
 
 def get_random_weights(number):
     return [random.uniform(-1, 1) for _ in range(number)]
 
-def score_single(my_strategy_factory, other_strategy_factory, length=200):
-    if other_strategy_factory().classifier['stochastic']:
-        repetitions = 10
-    else:
-        repetitions = 1
-    all_scores = []
-    for _ in range(repetitions):
-        me = my_strategy_factory()
-        other = other_strategy_factory()
-        me.set_match_attributes(length=length)
-        other.set_match_attributes(length=length)
-
-        g = axl.Game()
-        for _ in range(length):
-            me.play(other)
-        iteration_score = sum([g.score(pair)[0] for pair in
-                               zip(me.history, other.history)]) / length
-        all_scores.append(iteration_score)
-    return sum(all_scores) / repetitions
-
-def score_for(my_strategy_factory, other_strategies, iterations=200):
-    my_scores = list(map(
-        lambda x: score_single(my_strategy_factory, x, iterations),
-        other_strategies))
-    my_average_score = sum(my_scores) / len(my_scores)
-    return my_average_score
-
-def score_weights(weights, strategies, input_values=17, hidden_layer_size=10):
+def score_weights(weights, strategies, noise, input_values=17,
+                  hidden_layer_size=10):
     in2h, h2o, bias = split_weights(weights, input_values, hidden_layer_size)
-    return (score_for(lambda: ANN(in2h, h2o, bias), strategies), weights)
-
-from itertools import repeat
-
-def score_all_weights(population, strategies):
-    results = pool.starmap(score_weights, zip(population, repeat(strategies)))
+    args = [in2h, h2o, bias]
+    return (score_for(ANN, args=args, opponents=strategies, noise=noise,
+                      objective=objective_match_score), weights)
+
+def score_all_weights(population, strategies, noise, hidden_layer_size=10):
+    results = pool.starmap(score_weights,
+                           zip(population, repeat(strategies), repeat(noise),
+                               repeat(10), repeat(hidden_layer_size)))
     return list(sorted(results, reverse=True))
 
+## Evolutionary Algorithm
+
+def crossover(weights_collection):
+    copies = []
+    for i, w1 in enumerate(weights_collection):
+        for j, w2 in enumerate(weights_collection):
+            if i == j:
+                continue
+            crosspoint = random.randrange(len(w1))
+            new_weights = deepcopy(w1[0:crosspoint]) + deepcopy(w2[crosspoint:])
+            copies.append(new_weights)
+    return copies
+
+def mutate(copies, mutation_rate):
+    randoms = np.random.random((len(copies), 190))
+    for i, c in enumerate(copies):
+        for j in range(len(c)):
+            if randoms[i][j] < mutation_rate:
+                r = 1 + random.uniform(-1, 1) * mutation_distance
+                c[j] = c[j] * r
+    return copies
+
 def evolve(starting_weights, mutation_rate, mutation_distance, generations,
-           bottleneck, strategies, output_file):
+           bottleneck, strategies, output_file, noise, hidden_layer_size=10):
 
-    # Append scores
+    # Append scores of 0 to starting parameters
     current_bests = [[0, x] for x in starting_weights]
 
-    for generation in range(generations):
-        with open(output_file, "a") as output:
-            weights_to_copy = [x[1] for x in current_bests]
-            copies = []
-            # Crossover
-            for w1 in weights_to_copy:
-                for w2 in weights_to_copy:
-                    crossover = random.randrange(len(w1))
-                    new_weights = copy.deepcopy(
-                        w1[0:crossover]) + copy.deepcopy(w2[crossover:])
-                    copies.append(new_weights)
+    with open(output_file, 'w') as output:
+        writer = csv.writer(output)
 
+        for generation in range(generations):
+            print("Generation " + str(generation))
+
+            weights_to_copy = [x[1] for x in current_bests] + \
+                              [get_random_weights(19 * hidden_layer_size) for _ in
+                               range(2)]
+            # Crossover
+            copies = crossover(weights_to_copy)
             # Mutate
-            for _, c in copies:
-                for i in range(len(c)):
-                    if random.random() < mutation_rate:
-                        r = 1 + random.uniform(-1, 1) * mutation_distance
-                        c[i] = c[i] * r
+            copies = mutate(copies, mutation_rate)
 
             population = copies + weights_to_copy
 
             # map the population to get a list of (score, weights) tuples
             # this list will be sorted by score, best weights first
-            results = score_all_weights(population, strategies)
+            results = score_all_weights(population, strategies, noise=noise,
+                                        hidden_layer_size=hidden_layer_size)
 
             current_bests = results[0: bottleneck]
 
             # get all the scores for this generation
-            scores = [score for score, weights in results]
+            scores = [score for (score, weights) in results]
 
-            for value in [generation, results[0][1], results[0][0],
-                          mean(scores), pstdev(scores), mutation_rate,
-                          mutation_distance]:
-                output.write(str(value) + "\t")
-            output.write("\n")
-            print("Generation", generation, "| Best Score:", scores[0])
-            mutation_rate *= 0.99
-            mutation_distance *= 0.99
+            # Write the data
+            row = [generation, mean(scores), pstdev(scores), mutation_rate,
+                   mutation_distance, results[0][0]]
+            row.extend(results[0][1])
+            writer.writerow(row)
+            output.flush()
+            os.fsync(output.fileno())
+
+            print("Generation", generation, "| Best Score:", results[0][0])
 
     return current_bests
 
 
 if __name__ == '__main__':
-    arguments = docopt(__doc__, version='ANN Evolver 0.1')
+    arguments = docopt(__doc__, version='ANN Evolver 0.2')
     # set up the process pool
     pool = Pool(processes=int(arguments['-i']))
     # Vars for the genetic algorithm
@@ -134,13 +131,15 @@ def evolve(starting_weights, mutation_rate, mutation_distance, generations,
     mutation_distance = float(arguments['-d'])
     starting_population = int(arguments['-k'])
     output_file = arguments['-o']
+    noise = float(arguments['-n'])
 
-    starting_weights = [[0, get_random_weights(190)] for _ in range(starting_population)]
-
-    strategies = [s for s in axl.strategies
-                  if not s().classifier['long_run_time']]
+    hidden_layer_size = 10
+    size = 19 * hidden_layer_size
 
-    evolve(starting_weights, mutation_rate, mutation_distance, generations,
-           bottleneck, strategies, output_file)
+    starting_weights = [get_random_weights(size) for _ in range(starting_population)]
 
+    # strategies = axl.short_run_time_strategies
 
+    evolve(starting_weights, mutation_rate, mutation_distance, generations,
+           bottleneck, strategies, output_file, noise,
+           hidden_layer_size=hidden_layer_size)