Enhanced __main__ and add mutator

gte/__main__.py

@@ -1,15 +1,19 @@
 import argparse
 import logging
+import time
 import numpy as np
 from random import randint
+import os.path
 
-logging.basicConfig(level=logging.DEBUG,
-                    format="%(created)d %(asctime)s:%(module)s(%(lineno)d):%(levelname)s:%(message)s %(relativeCreated)dms")
+logging.basicConfig(level=logging.INFO,
+                    format="%(created)d %(asctime)s:%(module)s(%(lineno)d):%(levelname)s:%(message)s")
 logger = logging.getLogger(__name__)
 logger.debug('Logger started')
 
 from . import turmit, rpnlib
 from .turmit import Turmit
+from .world import World, LivingTurmit
+from .mutator import mutate
 
 parser = argparse.ArgumentParser(description='Genetic Turmit Evolver')
 
@@ -23,10 +27,30 @@ parser.add_argument('--rand-sym', '-r', action='store_const', default=False,
 parser.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.add_argument('--world-height', '-y', type=int, metavar='HEIGHT',
-                    default=512)
+                    default=256)
 parser.add_argument('--world-width', '-x', type=int, metavar='WIDTH',
-                    default=512)
+                    default=256)
+
+parser.add_argument('--turmit-count', '-T', type=int, metavar='N',
+                    default=10)
+
+parser.add_argument('--pool-size', '-p', type=int, metavar='N',
+                    default=20)
+
+parser.add_argument('--prog-size', type=int, metavar='SIZE',
+                    default=10)
+
+parser.add_argument('--output-dir', '-O', type=str, metavar='PATH',
+                    default=None)
+
+parser.add_argument('--prog', '-P', type=str, metavar='EXPR',
+                    default=None)
+
+parser.add_argument('--threads', type=int, metavar='N',
+                    default=4)
 
 args = parser.parse_args()
 
@@ -42,20 +66,59 @@ elif args.rand_sym:
         print(rpnlib.RpnSymbol.random())
     exit(0)
 
-from .world import World, LivingTurmit
 w = World(args.world_height, args.world_width)
 
-prog = rpnlib.RpnExpr.random(10)
-prog.append(rpnlib.RpnSymbol.rand_op())
-print(str(prog))
+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)
+             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))
 
-turmits = [LivingTurmit(world=w, prog=prog) for _ in range(10)]
-for step in range(args.steps):
-    for turmit in turmits:
-        turmit()
+    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)))
 
-print(w.fractdim())
-w.save('/tmp/gte.png')
-print('Saved in /tmp/gte.png')
+    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
 
 exit(0)

gte/mutator.py

@@ -0,0 +1,70 @@
+import copy
+from random import randint
+
+from .rpnlib import RpnExpr, RpnSymbol
+
+ADD = (10, 100)
+DEL = (5,100)
+UPDVAL = (25, 100)
+UPDTYPE = (25,100)
+
+def mutate(expr, force = True, mutcount = 1):
+    ''' @brief Introduce a mutation in expr
+        @param expr RpnExpr : an RPN expression
+        @param force bool : if force a mutation occur each time
+        @param mutcount int : count of time
+        @return a muatated copy of expr
+    '''
+    if force:
+        return mutatef(expr, mutcount)
+
+    res = copy.copy(expr)
+    for _ in range(mutcount):
+        rep = randint(*ADD)
+        if rep <= ADD[0]:
+            mutadd(res)
+
+        rep = randint(*DEL)
+        if rep <= DEL[0]:
+            mutdel(res)
+
+        rep = randint(*UPDTYPE)
+        if rep <= UPDTYPE[0]:
+            mutupdtype(res)
+        
+        rep = randint(*UPDVAL)
+        if rep <= UPDVAL[0]:
+            mutupdval(res)
+
+    return res
+
+def mutatef(expr, mutcount = 1):
+    mutations = [mutadd, mutdel]
+    mutations += [mutupdtype for _ in range(3)]
+    mutations += [mutupdval for _ in range(6)]
+    res = copy.copy(expr)
+    for _ in range(mutcount):
+        mutations[randint(0, len(mutations)-1)](res)
+    return res
+
+def mutadd(expr):
+    pos = randint(0, len(expr))
+    expr.insert(pos, RpnSymbol.random())
+    return expr
+
+def mutdel(expr):
+    pos = randint(0, len(expr)-1)
+    del(expr[pos])
+    return expr
+
+def mutupdtype(expr):
+    pos = randint(0, len(expr) - 1)
+    optype = [RpnSymbol.OPERATION, RpnSymbol.VALUE, RpnSymbol.VARIABLE]
+    del(optype[optype.index(expr[pos].optype)])
+    expr[pos] = RpnSymbol.random(optype[randint(0,1)])
+    return expr
+
+def mutupdval(expr):
+    pos = randint(0, len(expr) - 1)
+    expr[pos] = RpnSymbol(randint(0, 0xFFFF), expr[pos].optype)
+    return expr

gte/rpnlib.py

@@ -58,7 +58,7 @@ class RpnExpr(list):
     def __setitem__(self, idx, val):
         if not isinstance(val, RpnSymbol):
             raise TypeError('RpnSymbol expected but got %s' % type(val))
-        super().__setitem(idx, val)
+        super().__setitem__(idx, val)
 
     def __str__(self):
         return ' '.join([str(sym) for sym in self])
@@ -104,6 +104,7 @@ class RpnSymbol(object):
                     self.value = value
             else:
                 self.value = list(_op_list.keys())[value % len(_op_list)]
+            self.value = self.value.lower()
         elif optype == self.VARIABLE:
             if isinstance(value, str):
                 if not value in _var_list:
@@ -113,6 +114,7 @@ class RpnSymbol(object):
                     self.value = value
             else:
                 self.value = list(_var_list.keys())[value % len(_var_list)]
+            self.value = self.value.lower()
         if err:
             msg = 'Invalid %s : "%s"' % (err_type, value.upper())
 

gte/world.py

@@ -1,11 +1,40 @@
 """ @brief This module contains stuff that represent Turmit's world """
 
+import colorsys
 import scipy.misc
+import logging
 import numpy as np
 from random import randint
 
 from .turmit import Turmit
 
+logger = logging.getLogger(__name__)
+
+def eval_prog(prog, args):
+    ''' @brief Return an array of fractdim
+        @param args : dirty argparser returned arguments
+    '''
+    w = World(args.world_height, args.world_width)
+    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)
+    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)
+    return scores
+
 class World(object):
     ''' @brief A Turmit world. An array of dim == 2 with tuple(R,G,B) '''
     
@@ -109,19 +138,22 @@ class LivingTurmit(Turmit):
             msg = 'Color expected to be a tuple(R,G,B) but %s found'
             raise TypeError(msg % color)
         ## @brief Stores Turmit color
-        self._col = (randint(0,255), randint(0, 255), randint(0,255))
+        rand_hue = randint(0,255) / 255
+        self._col = tuple(round(i * 255)
+                          for i in colorsys.hsv_to_rgb(rand_hue,1,1))
+        #self._col = (randint(0,255), randint(0, 255), randint(0,255))
         if color is not None:
             self._col = color
         ## @brief @ref World instance
         self._world = world
 
-        self._x = randint(0, world.width)
+        self._x = randint(0, world.width - 1)
         if x is not None:
             if x < 0 or x >= world.width:
                 raise ValueError('Invalid X position %d' % x)
             self._x = x
 
-        self._y = randint(0, world.height)
+        self._y = randint(0, world.height - 1)
         if y is not None:
             if y < 0 or y >= world.height:
                 raise ValueError('Invalid Y position %d' % y)