Python 遗传算法图像进化的错误结果

我正在尝试实现一个最初由创建的程序。我已经做了很多关于其他人实现了什么的研究。我决定用python编写程序，并使用基本三角形作为形状。当我运行这个程序时，经过几代之后，它并没有显示出改进（三角形往往消失）。我假设我的变异函数有问题。有人能告诉我为什么它的结果不令人满意吗

我的代码：

import random
import copy
from PIL import Image, ImageDraw

optimal = Image.open("mona_lisa.png")
optimal = optimal.convert("RGBA")

size = width, height = optimal.size

num_shapes = 128

generations = 50000

def random_genome():
    elements = []

    for i in range(num_shapes):
        x = (random.randint(0, width), random.randint(0, height))
        y = (random.randint(0, width), random.randint(0, height))
        z = (random.randint(0, width), random.randint(0, height))
        r = random.randint(0, 255)
        g = random.randint(0, 255)
        b = random.randint(0, 255)
        alpha = random.randint(10, 255)

        elements.append([x, y, z, r, g, b, alpha])

    return elements

def render_daughter(dna):
    image = Image.new("RGBA", (width, height), "white")
    draw = ImageDraw.Draw(image)

    for item in dna:
        x = item[0]
        y = item[1]
        z = item[2]
        r = item[3]
        g = item[4]
        b = item[5]
        alpha = item[6]

        color = (r, g, b, alpha)

        draw.polygon([x, y, z], fill = color)

    return image

def mutate(dna):
    dna_copy = copy.deepcopy(dna)

    shape_index = random.randint(0, len(dna) - 1)
    roulette = random.random() * 2

    if roulette < 1:

        if roulette < 0.25:
            dna_copy[shape_index][3] = int(random.triangular(255, dna_copy[shape_index][3]))

        elif roulette < 0.5:
            dna_copy[shape_index][4] = int(random.triangular(255, dna_copy[shape_index][4]))

        elif roulette < 0.75:
            dna_copy[shape_index][5] = int(random.triangular(255, dna_copy[shape_index][5]))

        elif roulette < 1.0:
            dna_copy[shape_index][6] = int(0.00390625 * random.triangular(255, dna_copy[shape_index][6] * 255))

    else:

        if roulette < 1.25:
            dna_copy[shape_index][0] = (int(random.triangular(width, dna_copy[shape_index][0][0])), int(random.triangular(height, dna_copy[shape_index][0][1])))

        elif roulette < 1.5:
            dna_copy[shape_index][2] = (int(random.triangular(width, dna_copy[shape_index][3][0])), int(random.triangular(height, dna_copy[shape_index][4][1])))

        elif roulette < 1.75:
            dna_copy[shape_index][3] = (int(random.triangular(width, dna_copy[shape_index][4][0])), int(random.triangular(height, dna_copy[shape_index][5][1])))

    return dna_copy

def fitness(original, new):
    fitness = 0

    for x in range(0, width):
        for y in range(0, height):
            r1, g1, b1, a1 = original.getpixel((x, y))
            r2, g2, b2, a2 = new.getpixel((x, y))

            deltaRed = r1 - r2
            deltaGreen = g1 - g2
            deltaBlue = b1 - b2
            deltaAlpha = a1 - a2

            pixelFitness = deltaRed + deltaGreen + deltaBlue + deltaAlpha

            fitness += pixelFitness

    return fitness

def generate():
    mother = random_genome()
    best_genome = mother
    best_fitness = fitness(optimal, render_daughter(best_genome))


    for i in range(generations):
        daughter = copy.deepcopy(best_genome)
        daughter = mutate(daughter)

        daughter_fitness = fitness(optimal, render_daughter(daughter))

        if daughter_fitness < best_fitness:
            best_genome = daughter
            best_fitness = daughter_fitness

        if i % 50 == 0:
            print i

        if i % 1000 == 0:
            render_daughter(best_genome).save("iterations/output_" + str(i) + ".png")

if __name__ == "__main__":
    generate()

随机导入
导入副本
从PIL导入图像，ImageDraw
最优=Image.open（“mona_lisa.png”）
最优=最优。转换（“RGBA”）
尺寸=宽度，高度=最佳尺寸
num_shapes=128
世代=50000
def random_genome（）：
元素=[]
对于范围内的i（num_形状）：
x=（random.randint（0，宽度），random.randint（0，高度））
y=（random.randint（0，宽度），random.randint（0，高度））
z=（random.randint（0，宽度），random.randint（0，高度））
r=随机.ranndint（0，255）
g=random.randint（0255）
b=random.randint（0255）
alpha=random.randint（10255）
元素。追加（[x，y，z，r，g，b，alpha]）
返回元素
def呈现_子体（dna）：
图像=图像。新建（“RGBA”（宽度、高度）、“白色”）
draw=ImageDraw.draw（图像）
对于dna中的项目：
x=项目[0]
y=项目[1]
z=项目[2]
r=项目[3]
g=项目[4]
b=项目[5]
α=项目[6]
颜色=（r，g，b，alpha）
绘制多边形（[x，y，z]，填充=颜色）
返回图像
def突变（dna）：
dna_copy=copy.deepcopy（dna）
shape_index=random.randint（0，len（dna）-1）
轮盘赌=随机。随机（）*2
如果轮盘赌<1：
如果轮盘赌<0.25：
dna拷贝[形状索引][3]=int（随机三角形（255，dna拷贝[形状索引][3]））
elif轮盘赌<0.5：
dna拷贝[形状索引][4]=int（随机三角形（255，dna拷贝[形状索引][4]））
elif轮盘赌<0.75：
dna拷贝[形状索引][5]=int（随机三角形（255，dna拷贝[形状索引][5]））
elif轮盘赌<1.0：
dna拷贝[形状索引][6]=int（0.00390625*随机三角形（255，dna拷贝[形状索引][6]*255））
其他：
如果轮盘赌<1.25：
dna_-copy[shape_index][0]=（int（random.triangal（宽度，dna_-copy[shape_index][0][0]）），int（random.triangal（高度，dna_-copy[shape_index][0][1]））
elif轮盘赌<1.5：
dna_-copy[shape_index][2]=（int（random.triangal（宽度，dna_-copy[shape_index][3][0]）），int（random.triangal（高度，dna_-copy[shape_index][4][1]））
elif轮盘赌<1.75：
dna_-copy[shape_index][3]=（int（random.triangal（宽度，dna_-copy[shape_index][4][0]）），int（random.triangal（高度，dna_-copy[shape_index][5][1]））
返回dna拷贝
def健身（原装、新款）：
适合度=0
对于范围内的x（0，宽度）：
对于范围（0，高度）内的y：
r1，g1，b1，a1=原始.getpixel（（x，y））
r2，g2，b2，a2=新的.getpixel（（x，y））
deltaRed=r1-r2
deltaGreen=g1-g2
数据表=b1-b2
deltaAlpha=a1-a2
pixelFitness=deltaRed+deltaGreen+deltaBlue+deltaAlpha
适合度+=像素适合度
恢复体能
def generate（）：
母亲=随机_基因组（）
最好的母亲
最佳适配度=适配度（最佳，渲染子元素（最佳基因组））
对于范围内的i（代）：
子代=拷贝。深度拷贝（最佳基因组）
子代=变异（子代）
子体适配度=适配度（最佳，渲染子体（子体））
如果女儿健康<最佳健康：
最佳基因组=女儿
最佳健康=女儿健康
如果i%50==0：
打印i
如果i%1000==0：
呈现子元素（最佳基因组）.save（“迭代/输出”+str（i）+.png”）
如果名称=“\uuuuu main\uuuuuuuu”：
生成（）

我正在使用的开始图像：

1000代后的输出图像：

5000代后输出图像：

---

您正在检查新的适应度是否小于当前适应度：

if daughter_fitness < best_fitness:

各种

delta*

变量可以是负值或正值；您的测试将支持负增量，增加“最佳”图像的白度（值越高的

r2

，

g2

等，适合度越低，图像越白，直到它们都在255、255、255。我不知道增加alpha是增加还是减少透明度）

因此，应取差值的绝对值：

deltaRed = abs(r1 - r2)
deltaGreen = abs(g1 - g2)
deltaBlue = abs(b1 - b2)
deltaAlpha = abs(a1 - a2)

你也可以考虑平方和，或者平方和的平方根（基本上，把它变成最小二乘拟合例程）：

最后，我注意到你的程序不适合我。它位于

mutate（）

函数的后半部分，在这里，您可以为x、y或z指定新值，但使用2以上的索引

random_genome（）

显示您尝试访问颜色值，这些值是整数，甚至尝试对它们进行索引

这会导致异常，所以我甚至不知道如何让这个程序运行。它要么从未运行过，要么您没有正确地复制粘贴。我把它改成了

if roulette < 1.25:
    dna_copy[shape_index][0] = (int(random.triangular(
        width, dna_copy[shape_index][0][0])), int(
            random.triangular(height, dna_copy[shape_index][0][1])))
elif roulette < 1.5:
    dna_copy[shape_index][1] = (int(random.triangular(
        width, dna_copy[shape_index][1][0])), int(
            random.triangular(height, dna_copy[shape_index][1][1])))
elif roulette < 1.75:
    dna_copy[shape_index][2] = (int(random.triangular(
        width, dna_copy[shape_index][2][0])), int(
            random.triangular(height, dna_copy[shape_index][2][1])))

如果轮盘赌<1.25：
dna拷贝[形状索引][0]=（int（random.triangular）(
宽度，dna拷贝[形状索引][0][0]），整数(
随机.三角形（高度，dna拷贝[形状索引][0][1]））
elif轮盘赌<1.5：
dna拷贝[形状索引][1]=（int（random.triangular）(
宽度，dna拷贝[形状索引][1][0]），整数(
随机.三角形（高度，dna拷贝[形状索引][1][1]））
elif轮盘赌<1.75：
dna拷贝[形状索引][2]=（int（random.triangular）(
宽度，dna拷贝[形状索引][2][0]），整数(
随机.三角形（高度，dna拷贝[形状索引][2][1]））

这似乎是你想要的

deltaRed = r1 - r2
deltaGreen = g1 - g2
deltaBlue = b1 - b2
deltaAlpha = a1 - a2

pixelFitness = math.sqrt(deltaRed**2 + deltaGreen**2 + deltaBlue**2 + deltaAlpha**2)

fitness += pixelFitness

if roulette < 1.25:
    dna_copy[shape_index][0] = (int(random.triangular(
        width, dna_copy[shape_index][0][0])), int(
            random.triangular(height, dna_copy[shape_index][0][1])))
elif roulette < 1.5:
    dna_copy[shape_index][1] = (int(random.triangular(
        width, dna_copy[shape_index][1][0])), int(
            random.triangular(height, dna_copy[shape_index][1][1])))
elif roulette < 1.75:
    dna_copy[shape_index][2] = (int(random.triangular(
        width, dna_copy[shape_index][2][0])), int(
            random.triangular(height, dna_copy[shape_index][2][1])))