Add options, enhance output + bugfixes

gte/__main__.py

@@ -1,8 +1,10 @@
+import sys
 import os
 import os.path
 import argparse
 import logging
 import time
+import datetime
 import numpy as np
 from random import randint
 from multiprocessing import Pool
@@ -51,6 +53,15 @@ parser_evolve.add_argument('--threads', type=int, metavar='N',
 parser_evolve.add_argument('--max-generation', '-G', type=int, metavar='N',
                            default=0)
 
+parser_evolve.add_argument('--log-progs', '-L', type=str, metavar='FILENAME',
+                           default=None)
+
+parser_evolve.add_argument('--quiet', '-q', action='store_const',
+                           default=False, const=True)
+
+parser_evolve.add_argument('--pool-div', '-D', type=int, metavar='N',
+                           default=2, help='Each generation keep 1/N of the pool')
+
 parser_gen = subparsers.add_parser('generate', help='evolving help')
 
 parser_gen.add_argument('--prog', '-P', type=str, default=None)
@@ -71,31 +82,37 @@ if 'pool_size' in args:
     # Evolver
     if args.prog is None:
         progs = [rpnlib.RpnExpr.random(args.prog_size)
-                 for _ in range(args.pool_size)]
+                for _ in range(args.pool_size)]
     else:
-        progs = [rpnlib.RpnExpr.from_string(args.prog)]
-        progs = [mutate(progs[0], force=True) for _ in range(args.pool_size-1)]
+        prog = rpnlib.RpnExpr.from_string(args.prog)
+        progs = [mutate(prog, force=True) for _ in range(args.pool_size-1)]
 
     generation = 0
 
     pool = Pool(args.threads)
 
+    if args.log_progs is not None:
+        logprogs = open(args.log_progs, 'a')
+        logprogs.write('%s Run args %s\n' % (datetime.datetime.now(),
+                                             args))
+        logprogs.close()
+    else:
+        logger.warning('No log specified (--log-progs or -L)')
+
     while True:
         if args.max_generation > 0 and generation >= args.max_generation:
             exit(0)
         scores = []
-        for i, prog in enumerate(progs):
-            logger.info('Gen#%d P%d: %s' % (generation, i, str(prog)))
-        genstart = time.time()
         msg = 'Gen#%d Running %d eval with %d turmits and %d steps for each %d progs'
         logger.info(msg % (generation, args.repeat_eval, args.turmit_count,
                            args.steps, args.pool_size))
+        genstart = time.time()
 
         works = []
         for pid, prog in enumerate(progs):
             for i in range(args.repeat_eval):
                 works.append((pid, prog, i, args))
-        res = pool.map(eval_prog, works)
+        res = pool.imap(eval_prog, works)
         scores = [0 for _ in range(len(progs))]
         for pid, score in res:
             scores[pid] += score
@@ -107,17 +124,27 @@ if 'pool_size' in args:
 
         scores = sorted(scores, key=lambda x: x[0], reverse=True)
         for i, (score, prog) in enumerate(scores):
-            logger.debug('P%d %.3f : %s' % (i, score, str(prog)))
-
-        for score, prog in scores[:len(scores)//2]:
-            logger.info('Keeping %.3f : %s' % (score, str(prog)))
-
-        progs = [ prog for _, prog in scores[:len(scores)//2]]
-        for prog in list(progs):
-            progs.append(mutate(prog, force=True))
+            logger.info('P%d %.3f : "%s"' % (i, score, str(prog)))
+        if args.log_progs is not None:
+            with open(args.log_progs, 'a') as logprogs:
+                for i, (score, prog) in enumerate(scores):
+                    msg = 'Gen #%d P%d %.3f : "%s"\n'
+                    logprogs.write(msg % (generation, i, score, str(prog)))
+                    logprogs.flush()
+                logprogs.write('\n')
+
+        keep_div = 2
+        progs = []
+        for prog in [ prog for _, prog in scores[:len(scores)//keep_div]]:
+            progs.append(prog)
+            for _ in range(keep_div - 1):
+                progs.append(mutate(prog, force=True))
+                if len(progs) >= args.pool_size:
+                    break
             if len(progs) >= args.pool_size:
                 break
         generation += 1
+    exit(0)
 else:
     # Generate
     w = World(args.world_height, args.world_width)
@@ -128,6 +155,11 @@ else:
     logger.info(msg % (str(prog), args.steps, args.turmit_count))
     start = time.time()
     for step in range(args.steps):
+        if step % 512 == 1:
+            msg = 'Step %d/%d %dus/step'
+            msg %= (step, args.steps,
+                    ((time.time() - start)*1000000)//step//len(turmits))
+            logger.info(msg)
         for turmit in turmits:
             turmit()
     stop = time.time()

gte/world.py

@@ -29,11 +29,13 @@ def eval_prog(args):
     stop = time.time()
 
     score = w.fractdim()
-    msg = 'P%d run#%d scores %.3f in %.2fs (%dus per step)'
-    msg %= (progid, trynum, score,
-            stop - start,
-            ((stop - start)*1000000)//args.steps)
-    logger.info(msg)
+    if not args.quiet:
+        msg = 'P%d run#%d scores %.3f in %.2fs (%dus per step)\t%s'
+        msg %= (progid, trynum, score,
+                stop - start,
+                ((stop - start)*1000000)//args.steps//len(turmits),
+                str(prog))
+        logger.info(msg)
     return progid, score
 
 class World(object):

tests/test_rpnexpr.py

@@ -19,8 +19,8 @@ class RpnExprTestCase(unittest.TestCase):
         self.assertEqual(len(expr), 4)
         tests = ((RpnSymbol.VALUE, 5),
                  (RpnSymbol.VALUE, 255),
-                 (RpnSymbol.VARIABLE, 'X'),
-                 (RpnSymbol.OPERATION, 'MOD'))
+                 (RpnSymbol.VARIABLE, 'x'),
+                 (RpnSymbol.OPERATION, 'mod'))
         for i, (optype, val) in enumerate(tests):
             self.assertEqual(expr[i].optype, optype)
             self.assertEqual(expr[i].value, val)