Add subparser and image generator

gte/__main__.py

@@ -1,124 +1,144 @@
+import os
+import os.path
 import argparse
 import logging
 import time
 import numpy as np
 from random import randint
-import os.path
+from multiprocessing import Pool
 
 logging.basicConfig(level=logging.INFO,
                     format="%(created)d %(asctime)s:%(module)s(%(lineno)d):%(levelname)s:%(message)s")
-logger = logging.getLogger(__name__)
+logger = logging.getLogger()
 logger.debug('Logger started')
 
 from . import turmit, rpnlib
 from .turmit import Turmit
-from .world import World, LivingTurmit
+from .world import World, LivingTurmit, eval_prog
 from .mutator import mutate
 
 parser = argparse.ArgumentParser(description='Genetic Turmit Evolver')
 
-parser.add_argument('--list-op', action='store_const', default=False,
-                    const=True)
-parser.add_argument('--list-var', action='store_const', default=False,
-                    const=True)
-parser.add_argument('--rand-sym', '-r', action='store_const', default=False,
-                    const=True)
+subparsers = parser.add_subparsers(help='sub-commands help')
+
+parser_evolve = subparsers.add_parser('evolve', help='evolving help')
 
-parser.add_argument('--steps', '-s', type=int, metavar='N', default=1024,
+parser_evolve.add_argument('--steps', '-s', type=int, metavar='N', default=1024,
                     help="Number of steps")
 
-parser.add_argument('--try', type=int, metavar='N', default=5)
+parser_evolve.add_argument('--repeat-eval', type=int, metavar='N', default=5)
+
+parser_evolve.add_argument('--world-height', '-y', type=int, metavar='HEIGHT',
+                           default=256)
+parser_evolve.add_argument('--world-width', '-x', type=int, metavar='WIDTH',
+                           default=256)
+
+parser_evolve.add_argument('--turmit-count', '-T', type=int, metavar='N',
+                           default=10)
+
+parser_evolve.add_argument('--pool-size', '-p', type=int, metavar='N',
+                           default=10)
 
-parser.add_argument('--world-height', '-y', type=int, metavar='HEIGHT',
-                    default=256)
-parser.add_argument('--world-width', '-x', type=int, metavar='WIDTH',
-                    default=256)
+parser_evolve.add_argument('--prog-size', type=int, metavar='SIZE',
+                           default=10)
 
-parser.add_argument('--turmit-count', '-T', type=int, metavar='N',
-                    default=10)
+parser_evolve.add_argument('--prog', '-P', type=str, metavar='EXPR',
+                           default=None)
 
-parser.add_argument('--pool-size', '-p', type=int, metavar='N',
-                    default=20)
+parser_evolve.add_argument('--threads', type=int, metavar='N',
+                           default=os.cpu_count())
 
-parser.add_argument('--prog-size', type=int, metavar='SIZE',
-                    default=10)
+parser_evolve.add_argument('--max-generation', '-G', type=int, metavar='N',
+                           default=0)
 
-parser.add_argument('--output-dir', '-O', type=str, metavar='PATH',
-                    default=None)
+parser_gen = subparsers.add_parser('generate', help='evolving help')
 
-parser.add_argument('--prog', '-P', type=str, metavar='EXPR',
-                    default=None)
+parser_gen.add_argument('--prog', '-P', type=str, default=None)
+parser_gen.add_argument('--output', '-o', type=str, default='gte.png')
+parser_gen.add_argument('--world-height', '-y', type=int, metavar='HEIGHT',
+                        default=256)
+parser_gen.add_argument('--world-width', '-x', type=int, metavar='WIDTH',
+                        default=256)
+parser_gen.add_argument('--turmit-count', '-T', type=int, metavar='N',
+                        default=10)
+parser_gen.add_argument('--steps', '-s', type=int, metavar='N',
+                        default=1024)
 
-parser.add_argument('--threads', type=int, metavar='N',
-                    default=4)
 
 args = parser.parse_args()
 
-if args.list_op:
-    for i,(op, desc) in enumerate(rpnlib._op_list.items()):
-        print('#%02X %7s%s' % (i, op.upper(), desc[0].__doc__))
-    exit(0)
-elif args.list_var:
-    print([op.upper() for op in rpnlib._op_list.keys()])
-    exit(0)
-elif args.rand_sym:
-    for _ in range(10):
-        print(rpnlib.RpnSymbol.random())
-    exit(0)
-
-w = World(args.world_height, args.world_width)
-
-if args.prog is None:
-    progs = [rpnlib.RpnExpr.random(args.prog_size)
-             for _ in range(args.pool_size)]
+if 'pool_size' in args:
+    # Evolver
+    if args.prog is None:
+        progs = [rpnlib.RpnExpr.random(args.prog_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)]
+
+    generation = 0
+
+    pool = Pool(args.threads)
+
+    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))
+
+        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)
+        scores = [0 for _ in range(len(progs))]
+        for pid, score in res:
+            scores[pid] += score
+        scores = [(scores[i] / args.repeat_eval, progs[i])
+                  for i in range(len(progs))]
+
+        genstop = time.time()
+        logger.info('Generation evaluating ended in %.2fs' % (genstop - genstart))
+
+        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))
+            if len(progs) >= args.pool_size:
+                break
+        generation += 1
 else:
-    progs = [rpnlib.RpnExpr.from_string(args.prog)
-             for _ in range(args.pool_size)]
-
-generation = 0
-
-while True:
-    scores = []
-    logger.info('Generation %d' % generation)
-    genstart = time.time()
-    for i, prog in enumerate(progs):
-        
-        logger.debug('Running %s' % prog)
-        w.raz()
-        turmits = [LivingTurmit(world=w, prog=prog)
-                   for _ in range(args.turmit_count)]
-
-        start = time.time()
-        for step in range(args.steps):
-            for turmit in turmits:
-                turmit()
-        stop = time.time()
-
-        score = w.fractdim()
-        scores.append((score, prog))
-        msg = 'Prog %d/%d scores %.3f in %.2fs (%dus per step)'
-        msg %= (i, len(progs), score,
-                stop - start,
-                ((stop - start)*1000000)//args.steps)
-        logger.info(msg)
-        
-        if args.output_dir is not None:
-            filename = 'gte_G%04X_%02d.png' % (generation, i)
-            w.save(os.path.join(args.output_dir,filename))
-            logger.debug('Saved in %s' % filename)
-
-    genstop = time.time()
-    logger.info('Generation evaluating ended in %.2fs' % (genstop - genstart))
-
-    scores = sorted(scores, key=lambda x: x[0], reverse=True)
-    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))
-        if len(progs) >= args.pool_size:
-            break
-    generation += 1
+    # Generate
+    w = World(args.world_height, args.world_width)
+    prog = rpnlib.RpnExpr.from_string(args.prog)
+    turmits = [LivingTurmit(world=w, prog=prog)
+               for _ in range(args.turmit_count)]
+    msg = 'Generating image for program %s with %d steps and %d turmits'
+    logger.info(msg % (str(prog), args.steps, args.turmit_count))
+    start = time.time()
+    for step in range(args.steps):
+        for turmit in turmits:
+            turmit()
+    stop = time.time()
+
+    msg = 'Fractdim %.3f after %d steps in %.2fs (%dus per step)'
+    msg %= (w.fractdim(), args.steps,
+            stop - start,
+            ((stop - start)*1000000)//args.steps)
+    logger.info(msg)
+
+    w.save(args.output)
+    logger.info('Image saved in %s' % args.output)
 
 exit(0)

gte/world.py

@@ -3,19 +3,21 @@
 import colorsys
 import scipy.misc
 import logging
+import time
 import numpy as np
 from random import randint
 
 from .turmit import Turmit
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger()
 
-def eval_prog(prog, args):
+def eval_prog(args):
     ''' @brief Return an array of fractdim
         @param args : dirty argparser returned arguments
     '''
+    progid, prog, trynum, args = args
     w = World(args.world_height, args.world_width)
-    logger.debug('Running %s' % prog)
+    logger.debug('Running P%d run#%d %s' % (progid, trynum, prog))
     w.raz()
     turmits = [LivingTurmit(world=w, prog=prog)
                for _ in range(args.turmit_count)]
@@ -27,13 +29,12 @@ def eval_prog(prog, args):
     stop = time.time()
 
     score = w.fractdim()
-    scores.append(score)
-    msg = 'Prog %d/%d scores %.3f in %.2fs (%dus per step)'
-    msg %= (i, len(progs), score,
+    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)
-    return scores
+    return progid, score
 
 class World(object):
     ''' @brief A Turmit world. An array of dim == 2 with tuple(R,G,B) '''