Reorg of ANN evolver code

Author: marcharper

ann_evolve.py

@@ -12,6 +12,69 @@
 from statistics import mean, pstdev
 
 import axelrod
+from axelrod.strategies.ann import split_weights
+
+
+
+
+# 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)
+
+
+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']:
+        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)
+
+        g = axelrod.Game()
+        for _ in range(iterations):
+            me.play(other)
+        # print(me.history)
+        iteration_score = sum([g.score(pair)[0] for pair in
+                               zip(me.history, other.history)]) / iterations
+        all_scores.append(iteration_score)
+
+def score_all_weights(population):
+    return sorted(pool.map(score_weights, population), reverse=True)
+
+
+def score_weights(weights):
+    in2h, h2o, bias = split_weights(weights, input_values, hidden_layer_size)
+    return (score_for(lambda: ANN(in2h, h2o, bias), strategies), weights)
+
+
+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 evolve(starting_weights, mutation_rate, mutation_distance, generations,
@@ -38,7 +101,7 @@ def evolve(starting_weights, mutation_rate, mutation_distance, generations,
                 for i in range(len(c)):
                     if random.random() < mutation_rate:
                         c[i] = c[i] * (
-                        1 + (random.uniform(-1, 1) * mutation_distance))
+                            1 + (random.uniform(-1, 1) * mutation_distance))
 
             population = copies + weights_to_copy
 
@@ -60,68 +123,4 @@ def evolve(starting_weights, mutation_rate, mutation_distance, generations,
             mutation_rate *= 0.99
             mutation_distance *= 0.99
 
-    return (current_bests)
-
-
-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']:
-        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)
-
-        g = axelrod.Game()
-        for _ in range(iterations):
-            me.play(other)
-        # print(me.history)
-        iteration_score = sum([g.score(pair)[0] for pair in
-                               zip(me.history, other.history)]) / iterations
-        all_scores.append(iteration_score)
-
-
-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)
-
-
-def score_all_weights(population):
-    return sorted(pool.map(score_weights, population), reverse=True)
-
-
-def _score_weights(weights):
-    in2h, h2o, bias = split_weights(weights, input_values, hidden_layer_size)
-    return (score_for(lambda: ANN(in2h, h2o, bias), strategies), weights)
-
-
-score_weights = _score_weights
-
-
-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)
+    return current_bests