Two inputs to model, stacks and flat counts

2 files changed, 66 insertions, 57 deletions

diff --git a/src/pptdb.c b/src/pptdb.c
index e681735..8e8285a 100644
--- a/src/pptdb.c
+++ b/src/pptdb.c
@@ -17,12 +17,11 @@ write_input(void) {
 	/* fprintf(training_fh,"%d,",current_colour == C_BLACK); */
 
 	// Two numbers for flats remaining
-	/*
-	 * fprintf(training_fh,"%.6f,%.6f,",
-	 *				(float)(white_count & 127)/max_flats,
-	 *				(float)(black_count & 127)/max_flats);
-	 */
+	fprintf(training_fh,"%.8f,%.8f,",
+					(float)(white_count & 127)/max_flats,
+					(float)(black_count & 127)/max_flats);
 
+	// Top layer of stacks is handled differently to indicate stone type
 	float val;
 	uint16_t mask = 1;
 	for (int k = 0; k < board_size * board_size; k++) {
@@ -38,7 +37,7 @@ write_input(void) {
 		}
 		fprintf(training_fh,"%.2f,", val);
 	}
-
+	// Layers underneath
 	for (int depth = 1; depth < max_depth; depth++) {
 		for (int k = 0; k < board_size * board_size; k++) {
 			val = 0;
@@ -48,7 +47,6 @@ write_input(void) {
 		mask <<= 1;
 	}
 
-
 	/*
 	 * float t;
 	 * for (int k = 0; k < board_size * board_size; k++) {
@@ -165,19 +163,12 @@ main(int argc, char **argv) {
 		if (training_fh == NULL) exit(EXIT_FAILURE);
 
 		// Write header
-		/* fputs("\"Player\",\"White flats\",\"Black flats\",",training_fh); */
+		fputs("\"White flats\",\"Black flats\",",training_fh);
 		for (int depth = 0; depth < max_depth; depth++) {
 			for (int k = 0; k < size*size; k++) {
 				fprintf(training_fh,"\"Stack %d %d\",",depth,k);
 			}
 		}
-
-		/*
-		 * for (int k = 0; k < size*size; k++) {
-		 *	fprintf(training_fh,"\"BT %d\",",k);
-		 * }
-		 */
-
 		fputs("\"White win\",\"Black win\"\n",training_fh);
 	} else generate=0;
 
diff --git a/src/train5.py b/src/train5.py
index dd02df7..99ebd68 100644
--- a/src/train5.py
+++ b/src/train5.py
@@ -1,10 +1,8 @@
 import pandas as pd
 import numpy as np
 
-import tensorflow.keras.losses
-
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dropout
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import Concatenate
 from tensorflow.keras.layers import Input
 from tensorflow.keras.layers import Dense
 from tensorflow.keras.layers import Convolution2D
@@ -13,48 +11,68 @@ from tensorflow.keras.layers import Flatten
 # 30 10(11) 5
 # 27 17 4
 
-size = 6
-magic = int(size*3/2.0)
-shape = (-1, size, size, 8)
+def make_model(size, magic=6):
+    # Our model for the stacks, a small CNN
+    stack_shape = (size, size, 8)
+    stack_input = Input(shape=stack_shape)
+    stack_model = Convolution2D(magic, kernel_size=(3, 3), strides=(1, 1),
+                                padding='valid', activation="relu",
+                                use_bias=True)(stack_input)
+    stack_model = Flatten()(stack_model)
+    # stack_model = Dense(magic, activation="relu", use_bias=True)(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+2, activation="relu", use_bias=True)(combn_input)
+    model = Dense(magic, activation="relu", use_bias=True)(model)
+    model = Dense(2, activation="sigmoid", use_bias=True)(model)
+    model = Model(inputs=[stack_model.input, flats_input], outputs=model)
+
+    model.compile(optimizer='adam',
+                  loss='binary_crossentropy',
+                  # loss='categorical_crossentropy',
+                  # loss='mean_squared_error',
+                  metrics=['accuracy'])
+
+    model.summary()
+    return model
 
-model = Sequential([
-    Input(shape[1:]),
-    Convolution2D(magic, kernel_size=(3, 3), strides=(1, 1),
-                  padding='valid',
-                  activation="relu", use_bias=True),
-    Flatten(),
-    Dropout(0.2),
-    Dense(magic, activation="relu", use_bias=True),
-    Dense(2, activation="softmax")
-])
+def train(size, model, reps):
+    shape = (-1, size, size, 8)
 
-model.compile(loss='categorical_crossentropy',
-              optimizer='adam',
-              metrics=['accuracy'])
+    tr_fn = "training-"+str(size)+".csv"
+    training_csv = pd.read_csv(tr_fn) # .head(80000)
+    training_data = training_csv
+    training_stack_input = np.array(training_data.iloc[:, 2:-2]).reshape(shape)
+    training_flats_input = np.array(training_data.iloc[:, 0:2])
+    training_input = [training_stack_input, training_flats_input]
+    training_outcome = training_data.iloc[:, -2:]
 
-model.summary()
+    val_fn = "validation-"+str(size)+".csv"
+    val_data = pd.read_csv(val_fn).tail(20000)
+    val_stack_input = np.array(val_data.iloc[:, 2:-2]).reshape(shape)
+    val_flats_input = np.array(val_data.iloc[:, 0:2])
+    val_input = [val_stack_input, val_flats_input]
+    val_outcome = val_data.iloc[:, -2:]
 
-tr_fn = "validation-"+str(size)+".csv"
-training_csv = pd.read_csv(tr_fn).head(80000)
-training_data = training_csv
-training_input = np.array(training_data.iloc[:, :-2]).reshape(shape)
-training_outcome = training_data.iloc[:, -2:]
+    results = []
+    for i in range(0, reps):
+        print("Iteration {0}/{1}".format(i+1, reps))
+        model.fit(training_input, training_outcome, epochs=5,
+                  validation_data=(val_input, val_outcome),
+                  verbose=True)
+        v_loss, v_accuracy = model.evaluate(val_input, val_outcome, verbose=False)
+        t_loss, t_accuracy = model.evaluate(training_input, training_outcome,
+                                            verbose=False)
+        results += [((v_loss, t_loss), (v_accuracy, t_accuracy))]
 
-val_fn = "validation-"+str(size)+".csv"
-val_data = pd.read_csv(val_fn).tail(20000)
-val_input = np.array(val_data.iloc[:, :-2]).reshape(shape)
-val_outcome = val_data.iloc[:, -2:]
+    print("\n\n")
+    for i in range(0, reps):
+        print("Iteration {0}/{1}: {2}".format(i+1, reps, results[i]))
 
-results = []
-reps = 10
-for i in range(0, reps):
-    print("Iteration ", i)
-    history = model.fit(training_input, training_outcome, epochs=1,
-                        validation_data=(val_input, val_outcome),
-                        verbose=False)
-    loss, accuracy = model.evaluate(val_input, val_outcome, verbose=False)
-    results += [(loss, accuracy)]
+    return model
 
-print("\n\n")
-for i in range(0, reps):
-    print("Iteration ", i, ": ", results[i])
+# model = train(5, make_model(5), 50)
+# print(model.trainable_variables)