Pyevolve/examples/pyevolve_ex23_cgp.py at 0331506c6c1e1a08565528a3922d0943ec983ade · perone/Pyevolve · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
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()