From b07f07562720da54b39dc400606adf00bcd51e28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Christoffer=20M=C3=BCller=20Madsen?=
 <christoffer@guava.space>
Date: Sat, 10 Mar 2018 00:39:55 +0100
Subject: [PATCH] training and evaluation stats are now logged by default to
 model/logs/

---
 main.py | 63 +++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 41 insertions(+), 22 deletions(-)

diff --git a/main.py b/main.py
index 2b1d91f..0bfcea3 100644
--- a/main.py
+++ b/main.py
@@ -1,28 +1,35 @@
 import argparse
 import sys
+import os
 import time
 
-def print_train_outcome(outcome, trained_eps = 0):
+# Define helper functions
+def log_train_outcome(outcome, trained_eps = 0):
     format_vars = { 'trained_eps': trained_eps,
                     'count': len(train_outcome),
                     'sum': sum(train_outcome),
                     'mean': sum(train_outcome) / len(train_outcome),
                     'time': int(time.time())
     }
-    print("train;{time};{trained_eps};{count};{sum};{mean}".format(**format_vars))
+    with open(os.path.join(config['model_path'], 'logs', "train.log"), 'a+') as f:
+        f.write("{time};{trained_eps};{count};{sum};{mean}".format(**format_vars) + "\n")
+    
 
-def print_eval_outcomes(outcomes, trained_eps = 0):
+def log_eval_outcomes(outcomes, trained_eps = 0):
     for outcome in outcomes:
-            scores = outcome[1]
-            format_vars = { 'trained_eps': trained_eps,
-                            'method': outcome[0],
-                            'count': len(scores),
-                            'sum': sum(scores),
-                            'mean': sum(scores) / len(scores),
-                            'time': int(time.time())
-            }
-            print("eval;{time};{method};{trained_eps};{count};{sum};{mean}".format(**format_vars))
+        scores = outcome[1]
+        format_vars = { 'trained_eps': trained_eps,
+                        'method': outcome[0],
+                        'count': len(scores),
+                        'sum': sum(scores),
+                        'mean': sum(scores) / len(scores),
+                        'time': int(time.time())
+        }
+        with open(os.path.join(config['model_path'], 'logs', "eval.log"), 'a+') as f:
+            f.write("{time};{method};{trained_eps};{count};{sum};{mean}".format(**format_vars) + "\n")
 
+            
+# Parse command line arguments
 parser = argparse.ArgumentParser(description="Backgammon games")
 parser.add_argument('--episodes', action='store', dest='episode_count',
                     type=int, default=1000,
@@ -37,6 +44,8 @@ parser.add_argument('--eval', action='store_true',
                     help='whether to evaluate the neural network with a random choice bot')
 parser.add_argument('--train', action='store_true',
                     help='whether to train the neural network')
+parser.add_argument('--eval-after-train', action='store_true', dest='eval_after_train',
+                    help='whether to evaluate after each training session')
 parser.add_argument('--play', action='store_true',
                     help='whether to play with the neural network')
 parser.add_argument('--start-episode', action='store', dest='start_episode',
@@ -52,33 +61,43 @@ config = {
     'train': args.train,
     'play': args.play,
     'eval': args.eval,
+    'eval_after_train': args.eval_after_train,
     'start_episode': args.start_episode
 }
 
-#print("-"*30)
-#print(type(args.eval_methods))
-#print(args.eval_methods)
-#print("-"*30)
+# Make sure directories exist
+model_path = os.path.join(config['model_path'])
+log_path   = os.path.join(model_path, 'logs')
+if not os.path.isdir(model_path):
+    os.mkdir(model_path)
+if not os.path.isdir(log_path):
+    os.mkdir(log_path)
+    
 
+# Set up game
 import game
 g = game.Game(config = config)
 g.set_up_bots()
 
-episode_count = args.episode_count
 
+# Set up variables
+episode_count = config['episode_count']
+
+
+# Do actions specified by command-line
 if args.train:
     eps = config['start_episode']
     while True:
         train_outcome = g.train_model(episodes = episode_count, trained_eps = eps)
         eps += episode_count
-        print_train_outcome(train_outcome, trained_eps = eps)
-        if args.eval:
+        log_train_outcome(train_outcome, trained_eps = eps)
+        if config['eval_after_train']:
             eval_outcomes = g.eval(trained_eps = eps)
-            print_eval_outcomes(eval_outcomes, trained_eps = eps)
-        sys.stdout.flush()
+            log_eval_outcomes(eval_outcomes, trained_eps = eps)
 elif args.eval:
+    eps = config['start_episode']
     outcomes = g.eval()
-    print_eval_outcomes(outcomes, trained_eps = 0)
+    log_eval_outcomes(outcomes, trained_eps = eps)
 #elif args.play:
 #    g.play(episodes = episode_count)