Make ann_evolve.py work again

Author: marcharper

LICENSE.txt

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Martin Jones, Georgios Koutsovoulos, Marc Harper
+Copyright (c) 2015 Martin Jones, Georgios Koutsovoulos, Marc Harper,
+                   Vincent Knight
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

ann_evolve.py

@@ -3,93 +3,93 @@
 
 Original code by Martin Jones @mojones:
 https://gist.github.com/mojones/b809ba565c93feb8d44becc7b93e37c6
+
+Usage:
+    ann_evolve.py [-h] [-g GENERATIONS] [-u MUTATION_RATE] [-b BOTTLENECK]
+    [-d mutation_distance] [-i PROCESSORS] [-o OUTPUT_FILE]
+    [-k STARTING_POPULATION]
+
+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.1]
+    -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]
+    -k STARTING_POPULATION       starting population size for the simulation [default: 5]
 """
 
+
 from __future__ import division
 
 import copy
 import random
+from multiprocessing import Pool
 from statistics import mean, pstdev
 
-import axelrod
-from axelrod.strategies.ann import split_weights
-
+from docopt import docopt
 
-
-
-# def split_weights(weights, input_values, hidden_layer_size):
-#     number_of_input_to_hidden_weights = input_values * hidden_layer_size
-#     number_of_hidden_bias_weights = hidden_layer_size
-#     number_of_hidden_to_output_weights = hidden_layer_size
-#
-#     input2hidden = []
-#     for i in range(0, number_of_input_to_hidden_weights, input_values):
-#         input2hidden.append(weights[i:i + input_values])
-#
-#     hidden2output = weights[
-#                     number_of_input_to_hidden_weights:number_of_input_to_hidden_weights + number_of_hidden_to_output_weights]
-#     bias = weights[
-#            number_of_input_to_hidden_weights + number_of_hidden_to_output_weights:]
-#
-#     return (input2hidden, hidden2output, bias)
+import axelrod as axl
+from axelrod.strategies.ann import ANN, split_weights
+from axelrod_utils import mean, pstdev
 
 
 def get_random_weights(number):
     return [random.uniform(-1, 1) for _ in range(number)]
 
 
-def score_single(my_strategy_factory, other_strategy_factory, iterations=200,
-                 debug=False):
-    if other_strategy_factory.classifier['stochastic']:
+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_tournament_attributes(length=iterations)
-        other.set_tournament_attributes(length=iterations)
+        me.set_match_attributes(length=length)
+        other.set_match_attributes(length=length)
 
-        g = axelrod.Game()
-        for _ in range(iterations):
+        g = axl.Game()
+        for _ in range(length):
             me.play(other)
-        # print(me.history)
         iteration_score = sum([g.score(pair)[0] for pair in
-                               zip(me.history, other.history)]) / iterations
+                               zip(me.history, other.history)]) / length
         all_scores.append(iteration_score)
+    return sum(all_scores)
 
-def score_all_weights(population):
-    return sorted(pool.map(score_weights, population), reverse=True)
-
+def score_for(my_strategy_factory, other_strategies, iterations=200):
+    my_scores = 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):
+def score_weights(weights, strategies, 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_for(my_strategy_factory, other_strategies=strategies, iterations=200,
-              debug=False):
-    my_scores = map(
-        lambda x: score_single(my_strategy_factory, x, iterations, debug=debug),
-        other_strategies)
-    my_average_score = sum(my_scores) / len(my_scores)
-    return (my_average_score)
-
+def score_all_weights(population, strategies):
+    # args = (population, strategies)
+    results = pool.starmap(score_weights, zip(population, repeat(strategies)))
+    return sorted(results, reverse=True)
+    # return sorted(pool.map(score_weights, *args), reverse=True)
 
 def evolve(starting_weights, mutation_rate, mutation_distance, generations,
-           bottleneck, starting_pop, output_file):
+           bottleneck, strategies, output_file):
 
     current_bests = starting_weights
 
     for generation in range(generations):
 
         with open(output_file, "a") as output:
 
-            weights_to_copy = [x[1] for x in current_bests]
-
+            # weights_to_copy = [x[1] for x in current_bests]
+            weights_to_copy = current_bests[0:3]
             copies = []
-
             for w1 in weights_to_copy:
                 for w2 in weights_to_copy:
                     crossover = random.randrange(len(w1))
@@ -107,12 +107,12 @@ def evolve(starting_weights, mutation_rate, mutation_distance, generations,
 
             # 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)
+            results = score_all_weights(population, strategies)
 
-            current_bests = results[0:bottleneck]
+            current_bests = results[0: bottleneck]
 
             # get all the scores for this generation
-            scores = [score for score, table 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,
@@ -124,3 +124,26 @@ def evolve(starting_weights, mutation_rate, mutation_distance, generations,
             mutation_distance *= 0.99
 
     return current_bests
+
+
+if __name__ == '__main__':
+    arguments = docopt(__doc__, version='ANN Evolver 0.1')
+    # set up the process pool
+    pool = Pool(processes=int(arguments['-i']))
+    # Vars for the genetic algorithm
+    mutation_rate = float(arguments['-u'])
+    generations = int(arguments['-g'])
+    bottleneck = int(arguments['-b'])
+    mutation_distance = float(arguments['-d'])
+    starting_population = int(arguments['-k'])
+    output_file = arguments['-o']
+
+    starting_weights = [get_random_weights(190) for _ in range(starting_population)]
+
+    strategies = [s for s in axl.all_strategies
+                  if not s().classifier['long_run_time']]
+
+    evolve(starting_weights, mutation_rate, mutation_distance, generations,
+           bottleneck, strategies, output_file)
+
+

axelrod_utils.py

@@ -1,7 +1,7 @@
 from __future__ import division
-import axelrod
+from operator import itemgetter
 
-axl = axelrod
+import axelrod as axl
 
 def mean(data):
     """Return the sample arithmetic mean of data."""
@@ -33,7 +33,7 @@ def score_single(me, other, iterations=200):
     Return the average score per turn for a player in a single match against
     an opponent.
      """
-    g = axelrod.Game()
+    g = axl.Game()
     for _ in range(iterations):
         me.play(other)
     return sum([g.score(pair)[0] for pair in zip(me.history, other.history)]) / iterations
@@ -79,11 +79,9 @@ def do_table(table):
     Take a lookup table dict, construct a lambda factory for it, and return
     a tuple of the score and the table itself
     """
-    fac = lambda: axelrod.LookerUp(lookup_table=table)
+    fac = lambda: axl.LookerUp(lookup_table=table)
     return (score_for(fac), table)
 
-from operator import itemgetter, attrgetter, methodcaller
-
 def score_tables(tables, pool):
     """Use a multiprocessing Pool to take a bunch of tables and score them"""
     results = list(pool.map(do_table, tables))

lookup_evolve.py

@@ -16,14 +16,11 @@
     -i PROCESSORS                number of processors to use [default: 1]
     -o OUTPUT_FILE               file to write statistics to [default: evolve.csv]
     -z INITIAL_POPULATION_FILE   file to read an initial population from [default: None]
-
-
-
 """
+
 from __future__ import division
 import itertools
 import random
-import copy
 from multiprocessing import Pool
 
 from docopt import docopt
@@ -70,80 +67,95 @@ def evolve(starting_tables, mutation_rate, generations, bottleneck, pool, plys,
 
     """
 
-    # current_bests is a list of 2-tuples, each of which consists of a score and a lookup table
-    # initially the collection of best tables are the ones supplied to start with
+    # Current_bests is a list of 2-tuples, each of which consists of a score
+    # and a lookup table initially the collection of best tables are the ones
+    # supplied to start with
     current_bests = starting_tables
 
     keys = list(sorted(table_keys(plys, start_plys)))
 
     for generation in range(generations):
 
-        # because this is a long-running process we'll just keep appending to the output file
-        # so we can monitor it while it's running
+        # Because this is a long-running process we'll just keep appending to
+        # the output file so we can monitor it while it's running
         with open(output_file, "a") as output:
             print("doing generation " + str(generation))
 
-            # the tables at the start of this generation are the best ones from the
-            # previous generation (i.e. the second element of each tuple) plus a bunch
-            # of random ones
-            tables_to_copy = [x[1] for x in current_bests] + get_random_tables(plys, start_plys, starting_pop)
+            # The tables at the start of this generation are the best ones from
+            # the previous generation (i.e. the second element of each tuple)
+            # plus a bunch of random ones
+            tables_to_copy = [x[1] for x in current_bests] + \
+                             get_random_tables(plys, start_plys, starting_pop)
 
-            # set up new list to hold the tables that we are going to want to score
+            # Set up new list to hold the tables that we are going to want to
+            # score
             copies = crossover(tables_to_copy, mutation_rate, keys=keys)
 
             # Mutations
             for c in copies:
-                # flip each value with a probability proportional to the mutation rate
+                # Flip each value with a probability proportional to the
+                # mutation rate
                 for history, move in c.items():
                     if random.random() < mutation_rate:
                         c[history] = 'C' if move == 'D' else 'D'
 
-            # the population of tables we want to consider includes the recombined, mutated copies, plus the originals
+            # The population of tables we want to consider includes the
+            # recombined, mutated copies, plus the originals
             population = copies + tables_to_copy
 
-            # map the population to get a list of (score, table) tuples
-            # this list will be sorted by score, best tables first
+            # Map the population to get a list of (score, table) tuples
+            # This list will be sorted by score, best tables first
             results = axelrod_utils.score_tables(population, pool)
 
             # keep the user informed
             print("generation " + str(generation))
 
-            # the best tables from this generation become the starting tables for the next generation
+            # The best tables from this generation become the starting tables
+            # for the next generation
             current_bests = results[0: bottleneck]
 
             # get all the scores for this generation
             scores = [score for score, table in results]
 
-            # write the generation number, identifier of current best table, score of current best table, mean score, and SD of scores to the output file
-            for value in [generation, axelrod_utils.id_for_table(results[0][1]), results[0][0], axelrod_utils.mean(scores), axelrod_utils.pstdev(scores)]:
+            # write the generation number, identifier of current best table,
+            # score of current best table, mean score, and SD of scores to the
+            # output file
+            for value in [generation,
+                          axelrod_utils.id_for_table(results[0][1]),
+                          results[0][0], axelrod_utils.mean(scores),
+                          axelrod_utils.pstdev(scores)]:
                 output.write(str(value) + ",")
             output.write("\n")
 
-    return (current_bests)
+    return current_bests
 
 def table_keys(plys, opponent_start_plys):
     """Return key for given size of table"""
 
-    # generate all the possible recent histories for the player and opponent
+    # Generate all the possible recent histories for the player and opponent
     player_histories = [''.join(x) for x in itertools.product('CD', repeat=plys)]
     opponent_histories = [''.join(x) for x in itertools.product('CD', repeat=plys)]
 
-    # also generate all the possible opponent starting plays
+    # Also generate all the possible opponent starting plays
     opponent_starts = [''.join(x) for x in itertools.product('CD', repeat=opponent_start_plys)]
 
-    # the list of keys for the lookup table is just the product of these three lists
-    lookup_table_keys = list(itertools.product(opponent_starts,player_histories, opponent_histories))
+    # The list of keys for the lookup table is just the product of these three
+    # lists
+    lookup_table_keys = list(itertools.product(opponent_starts,
+                                               player_histories,
+                                               opponent_histories))
 
     return lookup_table_keys
 
 
 def get_random_tables(plys, opponent_start_plys, number):
     """Return randomly-generated lookup tables"""
 
-    # the list of keys for the lookup table is just the product of these three lists
+    # The list of keys for the lookup table is just the product of these three
+    # lists
     lookup_table_keys = table_keys(plys, opponent_start_plys)
 
-    # to get a pattern, we just randomly pick between C and D for each key
+    # To get a pattern, we just randomly pick between C and D for each key
     patterns = [''.join([random.choice("CD") for _ in lookup_table_keys]) for i in range(number)]
 
     # zip together the keys and the patterns to give a table
@@ -185,4 +197,5 @@ def get_random_tables(plys, opponent_start_plys, number):
     real_starting_tables = axelrod_utils.score_tables(starting_tables, pool)
 
     # kick off the evolve function
-    evolve(real_starting_tables, mutation_rate, generations, bottleneck, pool, plys, start_plys, starting_pop, arguments['-o'])
+    evolve(real_starting_tables, mutation_rate, generations, bottleneck, pool,
+           plys, start_plys, starting_pop, arguments['-o'])

run_ann.sh

@@ -0,0 +1 @@
+python ann_evolve.py -i 4 -u 0.5 -g 20 -b 10 -d 0.1 -k 5

run.sh renamed to run_lookerup.sh

@@ -8,13 +8,8 @@ python lookup_evolve.py -p 1 -s 2  -g 100000 -k 20 -u 0.1 -b 20 -i 2 -o evolve1-
 
 python lookup_evolve.py -p 2 -s 1  -g 100000 -k 20 -u 0.1 -b 20 -i 2 -o evolve2-1.csv
 
-
-
 python lookup_evolve.py -p 1 -s 1  -g 100000 -k 10 -u 0.1 -b 10 -i 4 -o evolve1-1.csv
 
 python lookup_evolve.py -p 1 -s 1  -g 100000 -k 10 -u 0.1 -b 10 -i 4 -o evolve1-1.csv
 
-
-
-
 python lookup_evolve.py -p 3 -s 3  -g 100000 -k 20 -u 0.001 -b 20 -i 4 -o evolve3-3.csv