Cartesian Genetic Programming extension

.gitignore

@@ -0,0 +1,2 @@
+.coverage
+*.pyc

README

@@ -1,3 +1,5 @@
-This is the new official Pyevolve repository.
+This is the fork of pyevolve framework. 
 
-The documentation (html rendered) is still hosted at sourceforge.net at http://pyevolve.sourceforge.net/0_6rc1/
+The main puprose is to add a Cartesian Genetic Programming (CGP) genome to the evolution schema. 
+
+Also some fixes and reformation added.

examples/pyevolve_ex23_cgp.py

@@ -0,0 +1,162 @@
+from pyevolve import G2DCartesian, GSimpleGA, Consts, Util, Mutators
+import random
+import os
+from datetime import datetime
+
+PIL_SUPPORT = None
+PYDOT_SUPPORT = None
+
+try:
+    import numpy as np
+except:
+    raise ImportError("This example needs numpy module.")
+
+try:
+    from PIL import Image, ImageDraw, ImageFilter
+    PIL_SUPPORT = True
+except:
+    PIL_SUPPORT = False
+
+try:
+    import pydot
+    PYDOT_SUPPORT = True
+except:
+    PYDOT_SUPPORT = False
+
+DIRECTORY = "unities"
+INPUT = "./data/input.jpg"
+TARGET = "./data/target.jpg"
+IMG_WIDTH=608
+IMG_HEIGHT=300
+
+def gp_blur(src, params):    
+    return src.filter(ImageFilter.BLUR)
+
+def gp_contour(src, params):    
+    return src.filter(ImageFilter.CONTOUR)
+
+def gp_detail(src, params):    
+    return src.filter(ImageFilter.DETAIL)
+
+def gp_edge_enhance(src, params):    
+    return src.filter(ImageFilter.EDGE_ENHANCE)
+
+def gp_edge_enhance_more(src, params):    
+    return src.filter(ImageFilter.EDGE_ENHANCE_MORE)
+
+def gp_emboss(src, params):    
+    return src.filter(ImageFilter.EMBOSS)
+
+def gp_find_edges(src, params):    
+    return src.filter(ImageFilter.FIND_EDGES)
+
+def gp_smooth(src, params):    
+    return src.filter(ImageFilter.SMOOTH)
+
+def gp_smooth_more(src, params):    
+    return src.filter(ImageFilter.SMOOTH_MORE)
+
+def gp_sharpen(src, params):    
+    return src.filter(ImageFilter.SHARPEN)
+
+def gp_gaussian_blur(src, params):    
+    return src.filter(ImageFilter.GaussianBlur(params['pos_int']))
+
+def gp_unsharp_mask(src, params):    
+    return src.filter(ImageFilter.UnsharpMask(params['pos_int'], 
+                                                int(params['percent_int']), 
+                                                int(params['pos_float'])))
+
+def gp_kernel(src, params):
+    size = params['kernel_size'][0] * params['kernel_size'][1]
+    kernel = params['kernel'][:size]
+    return src.filter(ImageFilter.Kernel(params['kernel_size'], 
+                                                kernel, 
+                                                params['pos_float']))
+
+def gp_rank_filter(src, params):    
+    rank = int(params['img_size_val'] * params['kernel_size_rad'] 
+                * params['kernel_size_rad'])
+    return src.filter(ImageFilter.RankFilter(params['kernel_size_rad'], 
+                                                rank))
+
+def gp_mode_filter(src, params):    
+    return src.filter(ImageFilter.ModeFilter(params['pos_int']))
+
+def eval_fitness_mean_diff(chromosome):
+    rmse_accum = Util.VectorErrorAccumulator()
+    code = chromosome.getCompiledCode()
+    evaluated = np.array(eval(code[0]))
+    rmse_accum.append(evaluated, target)
+    return rmse_accum.getRMSE()
+
+def store_result(genome, filename):
+    if PIL_SUPPORT:
+        code = genome.getCompiledCode()
+        ev = eval(code[0])
+        if not os.path.exists(DIRECTORY):
+            os.makedirs(DIRECTORY)
+
+        ev.save(os.path.join(DIRECTORY, filename))
+
+def store_graph(genome, filename):
+    if PYDOT_SUPPORT:
+        graph = pydot.Dot(graph_type='graph')
+        genome.writeDotGraph(graph)
+        graph.write_png(os.path.join(DIRECTORY, filename))
+
+def step_callback(engine): 
+    step = engine.getCurrentGeneration()
+    if step % 100 == 0:              
+        best = engine.bestIndividual()
+        store_result(best, "%s_%s.png" % (step, best.score))
+        store_graph(best, "%s_%s_graph.png" % (step, best.score))                               
+
+def main():    
+    pos_int = """ rand_randint(1,17) """
+    pos_float = """ rand_uniform(0.1, 16.0) """
+    percent_int = """ rand_gauss(100, 40) """
+    img_size_val = """ rand_uniform(0, 1) """
+    kernel_size = """ rand_choice([(3, 3), (5, 5)]) """
+    kernel = """ [rand_uniform(0.1, 2.5) for x in range(0,25) ] """
+    kernel_size_rad = """ rand_choice([3, 5]) """
+
+    random.seed(13)
+
+    global im, target, tfft
+    orig = Image.open(TARGET)    
+    target = np.array(orig)     
+    im = Image.open(INPUT)    
+    im.load()    
+    genome = G2DCartesian.G2DCartesian(128, 3, 1, 1)
+    genome.evaluator += eval_fitness_mean_diff
+    ga = GSimpleGA.GSimpleGA(genome, seed=13)
+    genome.mutator.set(Mutators.G2DCartesianMutatorNodeParams)
+    genome.mutator.add(Mutators.G2DCartesianMutatorNodeInputs)
+    genome.mutator.add(Mutators.G2DCartesianMutatorNodeFunction)
+    genome.mutator.add(Mutators.G2DCartesianMutatorNodesOrder)
+    ga.setPopulationSize(8)
+    ga.setGenerations(200)
+    #ga.setMultiThreading(True)
+    ga.setMinimax(Consts.minimaxType["minimize"])
+    ga.setParams(gp_function_prefix = "gp", gp_terminals = ['im'], 
+                    gp_args_mapping = { "pos_int" : pos_int,
+                                        "pos_float" : pos_float,
+                                        "percent_int" : percent_int,
+                                        "img_size_val" : img_size_val,
+                                        "kernel_size" : kernel_size,
+                                        "kernel" : kernel,
+                                        "kernel_size_rad" : kernel_size_rad})
+    ga.setMutationRate(0.05)
+    ga.setElitism(True)
+    ga.setSortType(Consts.sortType["raw"])
+    ga.stepCallback.set(step_callback)    
+
+    ga(freq_stats=100)
+    end = datetime.now()
+    best = ga.bestIndividual()  
+    store_result(best, "best_%s.png" % (best.score))
+    store_graph(best, "best_graph_%s.png" % (best.score))                    
+
+if __name__ == "__main__":       
+    main()

examples/test.py

@@ -0,0 +1,55 @@
+from pyevolve import Util
+from PIL import Image
+import numpy as np
+import random
+import pywt
+import math
+
+IMG_WIDTH=608
+IMG_HEIGHT=300
+
+w=Image.new("L", (4,4), "white")
+pix=w.load()
+
+#for i in range(0,4):
+#    for j in range(0,4):
+#        pix[i,j] = (random.randint(0,255), random.randint(0,255), random.randint(0,255))
+
+b=Image.new("L", (4,4), "black")
+b=np.array(b)
+orig = Image.open("./data/est.png")
+target = np.array(orig)
+input = np.array(Image.open("./data/target.jpg"))
+tfft = np.fft.fft2(target)
+rmse_accum = Util.VectorErrorAccumulator()
+
+
+
+efft = np.fft.fft2(input)    
+#print abs(efft/len(efft))
+#print abs(tfft/len(tfft))
+rmse_accum.append(abs(tfft/len(tfft)), abs(efft/len(efft)))
+print rmse_accum.getMean()/255
+
+rmse_accum.reset()
+rmse_accum.append(target, input)
+print rmse_accum.getRMSE()
+score = 0
+for i in range(0,3):
+    ev = input[:,:,i]   
+    hist = np.histogram2d(ev.ravel(), target[:,:,i].ravel(), [x for x in xrange(0, 256)])[0]
+    nonzeroInd = np.nonzero(hist)        
+    nonzero = hist[nonzeroInd]        
+    histProb = nonzero/float(608*300)     
+    score += -np.sum(np.log2(histProb)*histProb)
+max_entropy = 3*math.log(IMG_WIDTH*IMG_HEIGHT, 2)    
+print score/max_entropy
+
+#cA, (cH, cV, cD) = pywt.dwt2(target, 'haar')
+#print cA
+#print cD
+#cA, (cH, cV, cD) = pywt.dwt2(b, 'haar')
+#print cA
+#print cD
+#print pywt.dwt2(b, 'haar')        
+

pyevolve/Consts.py

@@ -373,6 +373,7 @@
 import Crossovers
 import logging
 from GTree import GTreeGP
+from G2DCartesian import G2DCartesian
 
 # Required python version 2.5+
 CDefPythonRequire = (2, 5)
@@ -491,6 +492,11 @@
 CDefG2DListInit = Initializators.G2DListInitializatorInteger
 CDefG2DListCrossUniformProb = 0.5
 
+# - G2DCartesian defaults
+CDefG2DCartesianInit = Initializators.G2DCartesianInitializatorNode
+CDefG2DCartesianCrossover = Crossovers.G2DCartesianCrossoverNode
+CDefG2DCartesianMutator = Mutators.G2DCartesianMutatorNodeFunction
+
 # Gaussian Gradient
 CDefGaussianGradientMU = 1.0
 CDefGaussianGradientSIGMA = (1.0 / 3.0)  # approx. +/- 3-sigma is +/- 10%
@@ -525,7 +531,7 @@
 CDefBroadcastAddress = "255.255.255.255"
 nodeType = {"TERMINAL": 0, "NONTERMINAL": 1}
 
-CDefGPGenomes = [GTreeGP]
+CDefGPGenomes = [GTreeGP, G2DCartesian]
 
 # Migration Consts
 CDefGenMigrationRate = 20

pyevolve/Crossovers.py

@@ -798,3 +798,10 @@ def GTreeGPCrossoverSinglePoint(genome, **args):
       assert brother.getHeight() <= max_depth
 
    return (sister, brother)
+
+#############################################################################
+#################  G2DCartesian Crossovers  #################################
+#############################################################################
+
+def G2DCartesianCrossoverNode(genome, **args):
+   return (args["mom"].clone(), args["dad"].clone())