Add a direction variation score

gte/__main__.py

@@ -154,9 +154,21 @@ if 'pool_size' in args:
             scores = [(max(scores[i]), progs[i]) for i in range(len(progs))]
         else:
             scores = [0 for _ in range(len(progs))]
-            for pid, score in res:
+            sinfos = [dict() for _ in range(len(progs))]
+            for pid, score, sinfo in res:
                 scores[pid] += score
-            scores = [(scores[i] / args.repeat_eval, progs[i])
+                # sum all score infos
+                for k, s in sinfo.items():
+                    if k not in sinfos[pid]:
+                        sinfos[pid][k] = 0
+                    sinfos[pid][k] += s
+            # avg all infos
+            for i in range(len(sinfos)):
+                sinfo = sinfos[i]
+                for k in sinfo:
+                    sinfo[k] /= args.repeat_eval
+                scores[i] /= args.repeat_eval
+            scores = [(scores[i], progs[i], sinfos[i])
                       for i in range(len(progs))]
 
         genstop = time.time()
@@ -167,20 +179,24 @@ if 'pool_size' in args:
             scores = sorted(scores, key=lambda x: x[0], reverse=True)
         else:
             scores = sorted(scores, key=lambda x: abs(x[0] - args.target),)
-        for i, (score, prog) in enumerate(scores):
-            logger.info('P%d %.3f : "%s"' % (i, score, str(prog)))
+        for i, (score, prog, sinfo) in enumerate(scores):
+            logger.info('P%d %.3f:(D:%.3f,F:%.3f) : "%s"' % (i, score,
+                                                             sinfo['D'],
+                                                             sinfo['F'],
+                                                             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)))
+                for i, (score, prog, sinfo) in enumerate(scores):
+                    msg = 'Gen #%d P%d %.3f(D:%.3f,F:%.3f): "%s"\n'
+                    logprogs.write(msg % (generation, i, score, sinfo['D'],
+                                          sinfo['F'], str(prog)))
                     logprogs.flush()
                 logprogs.write('\n')
 
         # Split pool & mutate the one we kept
         keep_div = args.pool_div
         progs = []
-        for prog in [ prog for _, prog in scores[:len(scores)//keep_div]]:
+        for prog in [ prog for _, prog, _ in scores[:len(scores)//keep_div]]:
             progs.append(prog)
             for cur_mut in range(keep_div - 1):
                 if args.exp_mutate:

gte/world.py

@@ -32,14 +32,19 @@ def eval_prog(args):
             turmit()
     stop = time.time()
 
-    score = w.fractdim()
+    score_dir = sum([t.dirvar() for t in turmits]) / len(turmits)
+    score_fract = w.fractdim()
+    score = score_dir * score_fract
+    sinfo = {'F':score_fract, 'D':score_dir}
+    #score = sum([score_fract] + [score_dir] * 4) / 5
     if not args.quiet:
-        msg = 'G%d P%d run#%d %d steps scores %.3f in %.2fs (%dus per step)\t%s'
-        msg %= (generation, progid, trynum, steps, score, stop - start,
+        msg = 'G%d P%d run#%d %d steps scores %.3f:(D:%.3f,F:%.3f) in %.2fs (%dus per step)\t%s'
+        msg %= (generation, progid, trynum, steps, score, score_dir,
+                score_fract, stop - start,
                 ((stop - start)*1000000)//steps//len(turmits),
                 str(prog))
         logger.info(msg)
-    return progid, score
+    return progid, score, sinfo
 
 class World(object):
     ''' @brief A Turmit world. An array of dim == 2 with tuple(R,G,B) '''
@@ -192,6 +197,15 @@ class LivingTurmit(Turmit):
                 raise ValueError('Invalid Y position %d' % y)
             self._y = y
 
+        # Direction variation addon
+        self._absx = self._absy = 0
+        self._prev_abs = (0, 0)
+        self._dirvar = 0
+        self._prev_dirvar = None
+        self._dirvar_res = 50
+        self._steps = 1
+        
+
     def __call__(self):
         ''' @brief Exec a turmit and move it '''
         if self._world._gray:
@@ -201,6 +215,29 @@ class LivingTurmit(Turmit):
         tdir = super().__call__(x=self._x, y=self._y, r=r, g=g, b=b)
         self.move(tdir)
 
+        # direction variation handling
+        if self._steps % self._dirvar_res == 0:
+            dy = self._absy - self._prev_abs[0]
+            dx = self._absx - self._prev_abs[1]
+            self._prev_abs = (self._absy, self._absx)
+            if self._prev_dirvar is not None:
+                pdvar = self._prev_dirvar
+                self._dirvar += abs(pdvar[0] - dy) + abs(pdvar[1] - dx)
+            self._prev_dirvar = (dy, dx)
+            
+        self._steps += 1
+
+    def dirvar(self):
+        ''' @brief Process @ref _dirvar to return a direction variation
+            score
+            @return a score in [0..2]
+        '''
+        return self._dirvar / (self._steps * 2)
+        #d = self._dirvar
+        #return sum([sum([abs(d[i][j] - d[i+1][j]) for j in (0,1)])
+        #                 for i in range(len(d)-1)]) / (self._steps * 2)
+
+
     def move(self, tdir, setcol=True):
         ''' @brief Update coordinates given a direction
             @param tdir int : One of 8 directions (integer is understanded
@@ -215,17 +252,21 @@ class LivingTurmit(Turmit):
         tdir %= 8 if self._diag else 4
 
         if tdir == 0 or tdir == 4 or tdir == 5:
+            self._absx += 1
             self._x += 1
             self._x %= self._world.width
         elif tdir == 2 or tdir == 7 or tdir == 6:
+            self._absx -= 1
             if self._x == 0:
                 self._x = self._world.width -1
             else:
                 self._x -= 1
         if tdir == 1 or tdir == 4 or tdir == 6:
+            self._absy += 1
             self._y += 1
             self._y %= self._world.height
         elif tdir == 3 or tdir == 7 or tdir == 5:
+            self._absy -= 1
             if self._y == 0:
                 self._y = self._world.height - 1
             else: