Tried some naive iterative deepening. Work on TEI interface next

If TEI is implemented, then i could make use of Morten's
racetrack (https://github.com/MortenLohne/racetrack) and develop a
quantitative measure of the bot's performance. This is the current
priority.

1 files changed, 38 insertions, 36 deletions

diff --git a/src/cnn_train.py b/src/cnn_train.py
index 1264e9f..ddf208b 100644
--- a/src/cnn_train.py
+++ b/src/cnn_train.py
@@ -40,37 +40,6 @@ from tensorflow.keras.layers import Convolution2D
 from tensorflow.keras.layers import Flatten
 
 
-# We need something that's close to 2*logistic-1, but cheaper to
-# compute: (12+x+50*x/(x*x+10))/12-1, clipped between -1 and 1 as it
-# would otherwise exceed this range at +- 4.6 or so
-def clipped_pade_logistic(x):
-    val = add(k(12.0),
-              add(x, multiply(k(50.0),
-                              divide(x, add(square(x), k(10.0))))))
-    return clip_by_value(add(k(-1.0), divide(val, k(12.0))), -1.0, +1.0)
-
-
-def make_model(size, magic=[12, 11, 8]):
-    # Our model for the stacks, a small CNN
-    stack_shape = (size, size, 6)
-    stack_input = Input(shape=stack_shape)
-    stack_model = Convolution2D(magic[0], kernel_size=(3, 3), strides=(1, 1),
-                                padding='valid', activation="relu",
-                                use_bias=True)(stack_input)
-    stack_model = Flatten()(stack_model)
-    stack_model = Model(inputs=stack_input, outputs=stack_model)
-    # The overall model
-    flats_input = Input(shape=(2,))
-    combn_input = Concatenate()([stack_model.output, flats_input])
-    model = Dense(magic[1], activation="relu", use_bias=True)(combn_input)
-    model = Dense(magic[2], activation="relu", use_bias=True)(model)
-    model = Dense(1, activation=clipped_pade_logistic, use_bias=True)(model)
-    model = Model(inputs=[stack_model.input, flats_input], outputs=model)
-    model.compile(optimizer='adam', loss='mean_squared_error')
-    model.summary()
-    return model
-
-
 def load_data(size):
     shape = (-1, size, size, 6)
     # Load training data
@@ -91,6 +60,16 @@ def load_data(size):
     return [(training_input, training_outcome), (val_input, val_outcome)]
 
 
+# We need something that's close to 2*logistic-1, but cheaper to
+# compute: (12+x+50*x/(x*x+10))/12-1, clipped between -1 and 1 as it
+# would otherwise exceed this range at +- 4.6 or so
+def clipped_pade_logistic(x):
+    val = add(k(12.0),
+              add(x, multiply(k(50.0),
+                              divide(x, add(square(x), k(10.0))))))
+    return clip_by_value(add(k(-1.0), divide(val, k(12.0))), -1.0, +1.0)
+
+
 def train(size, model, data, iterations=1, epochs=10):
     (training_input, training_outcome), (val_input, val_outcome) = data
     results = []
@@ -98,19 +77,40 @@ def train(size, model, data, iterations=1, epochs=10):
         print("Iteration {0}/{1}".format(i+1, iterations))
         model.fit(training_input, training_outcome, epochs=epochs,
                   validation_data=(val_input, val_outcome),
-                  verbose=True)
+                  verbose=True, batch_size=16)
         v_loss = model.evaluate(val_input, val_outcome,
                                 verbose=False, batch_size=16)
         t_loss = model.evaluate(training_input, training_outcome,
                                 verbose=False, batch_size=32)
         results += [(v_loss, t_loss)]
+        write_weights(model, i+1, str((v_loss, t_loss)))
     print("\nScores")
     for i in range(len(results)):
         print("Iteration {0}: {1}".format(i+1, results[i]))
     return results
 
+def make_model(size, magic=[16, 128, 64, 64, 64]):
+    # Our model for the stacks, a small CNN
+    stack_shape = (size, size, 6)
+    stack_input = Input(shape=stack_shape)
+    stack_model = Convolution2D(magic[0], kernel_size=(3, 3), strides=(1, 1),
+                                padding='valid', activation="relu",
+                                use_bias=True)(stack_input)
+    stack_model = Flatten()(stack_model)
+    stack_model = Model(inputs=stack_input, outputs=stack_model)
+    # The overall model
+    flats_input = Input(shape=(2,))
+    combn_input = Concatenate()([stack_model.output, flats_input])
+    model = Dense(magic[1], activation="relu", use_bias=True)(combn_input)
+    model = Dense(magic[2], activation="relu", use_bias=True)(model)
+    model = Dense(1, activation=clipped_pade_logistic, use_bias=True)(model)
+    model = Model(inputs=[stack_model.input, flats_input], outputs=model)
+    model.compile(optimizer='adam', loss='mean_squared_error')
+    model.summary()
+    return model
+
 
-def write_weights(model):
+def write_weights(model, iteration, performance):
     def fix(val):
         string = str(np.array(val).tolist())
         string = string.replace("[", "{").replace("]", "}")
@@ -141,7 +141,10 @@ def write_weights(model):
                  dense2_weights, dense2_biases,
                  output_weights, output_bias]
     # Write to file
-    f = open("weights.txt", "w")
+    f = open("weights-"+str(iteration)+".txt", "w")
+    f.write("/*\n")
+    model.summary(print_fn=lambda l: f.write(" * "+l+"\n"))
+    f.write(" * "+performance+"\n/*\n\n")
     f.write("#include \"weights.h\"\n\n")
     for (name, val) in zip(names, variables):
         f.write("const float "+name+" =\n"+fix(val)+";\n\n")
@@ -150,5 +153,4 @@ def write_weights(model):
 
 data = load_data(5)
 model = make_model(5, [12, 11, 8])
-results = train(5, model, data, iterations=5, epochs=10)
-write_weights(model)
+results = train(5, model, data, iterations=20, epochs=10)