python实现遗传算法,并绘制训练过程以及参数对比

前言:

        本实验使用遗传算法寻找3维函数的最大/最小值,并对基因位数,种群初始大小,每次死亡个数,适应度计算方式这些参数进行修改,对比结果。

初始代码如下:

import numpy as np
import matplotlib.pyplot as plt
import random
import time  # 暂停用的,方便我录像,你们不需要


# 所用的函数
def Function(x_data, y_data):
    """
    :param x_data: x数值
    :param y_data: y数值
    :return: 输出表达式计算出的z
    """
    # 本来想找个能可视化捏函数,给表达式的方法,在matlab绘图中发现这个表达式长得不错,就直接用了。
    return 3 * (1 - x_data) ** 2 * np.exp(-x_data ** 2 - (y_data + 1) ** 2) - 10 * (
            x_data / 5 - x_data ** 3 - y_data ** 5) * np.exp(
        -x_data ** 2 - y_data ** 2) - np.exp(-(x_data + 1) ** 2 - y_data ** 2)


def Get_Grid():  # 生成坐标网格
    """
    :return: 返回Function的x,y,z
    """
    # 生成坐标网格
    x = np.linspace(-4, 4, 100)  # 坐标轴是-3~3,100个均匀分布,为了个体不跑到图片外,修改至-4~4
    y = np.linspace(-4, 4, 100)
    x, y = np.meshgrid(x, y)  # 按刚刚的坐标轴生成二维矩阵
    z = np.array(Function(x, y))  # 调用生成函数,获得y值
    return x, y, z


def Get_Random_gene(number, n):  # 随机生成基因型
    """
    :param number: 生成个数
    :param n: x的总位数
    :return: 生成的族群
    """
    return np.random.randint(0, 2, size=(number, n + n))


def Plot_Draw_F(fig, x, y, z):  # 绘图,重新绘制F的图像,返回引用
    """
    :param fig:     窗口的引用
    :param x:
    :param y:
    :param z:
    :return:    axes_3d,画布引用
    """
    fig.clf()
    axes_3d = fig.add_subplot(111, projection='3d')
    cmap = plt.cm.viridis  # 设定变色的颜色,可选项:viridis, plasma, inferno, magma, cividis 等
    norm = plt.Normalize(vmin=-5, vmax=5)  # 颜色变化范围,不设置就是按z轴最大最小,
    img_f = axes_3d.plot_surface(x, y, z, rstride=1, cstride=1, alpha=0.75, cmap=cmap, norm=norm)  # 绘制3D图
    # 长得还是有点抽象,一会发一下三视图,就能知道函数大概形状了
    # 添加颜色条
    cbar = fig.colorbar(img_f, ax=axes_3d)
    cbar.set_label('Color')
    # 设置坐标轴范围和标签
    axes_3d.set_xlim(-4, 4)
    axes_3d.set_ylim(-4, 4)
    axes_3d.set_zlim(-10, 10)
    axes_3d.set_xlabel('X')
    axes_3d.set_ylabel('Y')
    axes_3d.set_zlabel('Z')
    return axes_3d


def Plot_Scatter(ax, plot_gene_data, plot_z, colour):  # 根据解码后数据绘制种群的散点图
    """
    :param ax: 画布引用
    :param plot_z: 计算出的z值
    :param plot_gene_data: 全部基因型转码后的数据
    """
    for i in range(len(plot_z)):
        ax.scatter(plot_gene_data[i][0], plot_gene_data[i][1], plot_z[i], c=colour, marker='o')
    # 刷新图形
    plt.draw()
    plt.pause(1e-3)


# 解码,将全部二进制基因型数据转换为数值
def Decoding(data, n, point):  # 输入的分别是要解码的列表,x,y,的位数,小数位数
    """
    :param data: 要解码的列表,[[x符号,x整数部分,x整数部分,x整数部分,x小数部分,x小数部分,······y符号,y整数部分,x整数部分,x整数部分,y小数部分,y小数部分,],]
    :param n: x的总位数
    :param point: 小数位数
    :return: 二进制基因型数据转换的数值
    """
    # 在这个例子中,x,y的取值范围为-3~3,整数刚好整2位,加一位符号位,加上小数部分就-4~4了(为了不跑到图像外,修改一下图像范围),
    # 小数部分不用太多,整个8位,就差不多够了,所以前11位x,后11位y,正负只看第一个符号,1正0负
    # [x符号,x整数部分,x整数部分,x整数部分,x小数部分,x小数部分,······y符号,y整数部分,x整数部分,x整数部分,y小数部分,y小数部分,]
    decode_data = []
    for i in data:  # 遍历每个个体,转码
        x = Decoding_to_decimal(i[0:n], n, point)
        y = Decoding_to_decimal(i[n:], n, point)
        decode_data.append([x, y])
    return decode_data


def Decoding_to_decimal(data, n, point):
    # 仅一个x或y的转换
    integer_len = n - point
    decimal_data = 0
    for i in range(1, integer_len):  # 整数部分 2^n n=0,1,2···
        decimal_data += data[i] * 2 ** (integer_len - i - 1)
    for i in range(point):  # 小数部分 1/2^n n = 1,2,3···
        decimal_data += data[i + integer_len] / 2 ** (i + 1)
    return (data[0] * 2 - 1) * decimal_data


def Get_gene_z(data):  # 根据解码后数据,计算z值
    """
    :param data: 全部基因型转码后的数据
    :return: z值,z最大值,z最小值
    """
    data_z = []
    max_z = -float("inf")
    min_z = float("inf")
    for i in range(len(data)):
        data_z.append(Function(data[i][0], data[i][1]))
        if data_z[i] > max_z:
            max_z = data_z[i]
        if data_z[i] < min_z:
            min_z = data_z[i]
    return data_z, max_z, min_z


def Get_Fitness(data, max_data, min_data, maximum):  # 计算适应度,这里用z的归一化加次方
    """
    :param data: 需要计算的z值列表
    :param max_data: z最大值
    :param min_data: z最小值
    :param maximum: 数值较大适应度高?
    :return: 适应度列表
    """
    # 之所以加个1e-3是为了让最小的也有活下去可能(来自i道i的仁慈)
    gap = max_data - min_data  # 最大最小值的差距
    # 下面这里加点次方能更好的提升最大数值与最小数值的差距,保证较优秀的个体不会寄
    if (maximum):
        fitness = [((i - min_data) / gap)**1 + 1e-3 for i in data]  # 归一化
    else:
        fitness = [((max_data - i) / gap)**1 + 1e-3 for i in data]  # 归一化
    return fitness


def Inheritance(parents, n):  # 生育时,交叉+变异,可以扔进去多个个体
    len_parents = len(parents)  # 父辈个数
    child = []  # 生出的孩子
    for i in range(n + n):  # 遍历每个基因点
        child.append(parents[random.randint(0, len_parents - 1)][i])  # 随机继承某一个父辈的基因
        # 假如我想每一轮,每个人都有10%概率突变,那么,当有11位数时,我需要 22个基因点突变概率x,
        # (1-x)^22约等于0.9,解得x约为0.0048,整个0.005得了
        if random.random() < 0.005:
            child[i] = 0 if child == 1 else 1
    return child


def Reproduction(number, data, n, strength):  # 让新族群生育到原先族群大小
    """
    :param number: 族群大小
    :param data:生育前的族群基因
    :param n: x的总位数
    :param point: 小数位数
    :return: 剩余完成的族群
    """
    initial_len = len(data)  # 初始个数
    len_data = initial_len  # 当前个数
    if initial_len < 2:
        print("种族没人")
    while len_data < number:  # 生够了就停下
        parents = random.sample(data[0:initial_len], strength)  # 对象包分配,不过是随机分配,不能和子代生育
        data.append(Inheritance(parents, n))  # 生出的个体添加进族群
        len_data += 1
    return data


def Genetic_train(fig, gene_data, number, n, point, loop, x, y, z, maximum=True):  # 遗传算法训练,带过程绘制
    """
    :param fig: 窗口引用
    :param gene_data: 基因型
    :param number: 族群大小
    :param n: x的总位数
    :param point: 小数位数
    :param maximum: 是否求函数最大值,默认是
    :return: 最终的族群
    """
    new_gene = gene_data  # 开始的输入就是新族群
    for i in range(loop):  # 最大训练loop轮
        # 物竞天择,适者生存
        gene_data = new_gene
        decode_data = Decoding(gene_data, n, point)  # 解码
        data_z, max_z, min_z = Get_gene_z(decode_data)  # 计算z
        fitness = Get_Fitness(data_z, max_z, min_z, maximum)  # 求适应度
        ax = Plot_Draw_F(fig, x, y, z)  # 绘画出函数
        Plot_Scatter(ax, decode_data, data_z, "blue")  # 绘制全部个体
        if max_z - min_z < 1e-2:  # 认为训练完毕
            break
        # 开杀,每回死一半
        len_gene = len(gene_data)
        index_table = list(range(len_gene))  # 未选中的索引标志
        new_gene = []  # 新族群
        for j in range(len_gene // 2):
            selected_elements = random.choices(index_table, weights=fitness)  # 根据适应度,选中生存的个体
            k = index_table.index(selected_elements[0])  # 根据选中的值,找到索引
            new_gene.append(gene_data[k])  # 生存的个体进入新族群
            decode_data.pop(k)
            data_z.pop(k)
            index_table.pop(k)  # 活下来的不再选了
            fitness.pop(k)
        Plot_Scatter(ax, decode_data, data_z, "red")  # 绘制死亡的个体
        new_gene = Reproduction(number, new_gene, n, 2)  # 让新族群生育到原先族群大小,两个人生
    return new_gene


if __name__ == "__main__":
    # 建立窗口
    fig = plt.figure()
    # 生成坐标网格
    x, y, z = Get_Grid()
    plt.pause(1)  # 方便录像用,开窗口后等1秒再出图,你们建议删去
    # 参数设置
    number = 100  # 种群初始大小
    point = 8  # 小数位数
    n = point+3  # x或y长度
    loop = 100  # 最大训练轮数
    gene_data = Get_Random_gene(number, n)  # 获得初始基因
    gene_end = Genetic_train(fig, gene_data, number, n, point, loop, x, y, z)  # 族群开始进化
    # 显示图形,完成后不消失
    plt.show()

        注释写的比较清楚了,就不多解释了,

gene_end = Genetic_train(fig, gene_data, number, n, point, loop, x, y, z)

        最后还可以再加一个参数maximum,True求最大值False求最小值,默认求最大值

        贴一下所用函数的三视图,三个极大值,两个极小值

python实现遗传算法,并绘制训练过程以及参数对比_第1张图片python实现遗传算法,并绘制训练过程以及参数对比_第2张图片

python实现遗传算法,并绘制训练过程以及参数对比_第3张图片python实现遗传算法,并绘制训练过程以及参数对比_第4张图片

还想不明白,用这个主函数看一眼

if __name__ == "__main__":
    # 建立窗口
    fig = plt.figure()
    # 生成坐标网格
    x, y, z = Get_Grid()
    Plot_Draw_F(fig,x,y,z)
    # plt.pause(1)  # 方便录像用,开窗口后等1秒再出图,你们建议删去
    # # 参数设置
    # number = 100  # 种群初始大小
    # point = 8  # 小数位数
    # n = point+3  # x或y长度
    # loop = 100  # 最大训练轮数
    # gene_data = Get_Random_gene(number, n)  # 获得初始基因
    # gene_end = Genetic_train(fig, gene_data, number, n, point, loop, x, y, z)  # 族群开始进化
    # 显示图形,完成后不消失
    plt.show()

初始代码结果:

        视频挺长,蓝色的是初始族群,红色的是寄了的

遗传算法,初始代码结果

参数修改:

每一项修改都完成了上面的修改项,比如增加小数点位数的结果也修改了适应度计算。

修改适应度计算

        通过训练过程,我们发现,有些跑到最大值附近的点,却没存活下来,这是因为我们使用的是

random.choices(index_table, weights=fitness)

        通过weights的值,来决定存活下来的概率,值越大存活概率越高,因此,哪怕值比较高,依然有可能去世(先帝创业未半而中道崩殂),基于这点,我修改了适应度计算函数,让最高值和最低值之间的差距加大,使得优秀的个体更容易存活下来

def Get_Fitness(data, max_data, min_data, maximum):  # 计算适应度,这里用z的归一化加次方
def Get_Fitness(data, max_data, min_data, maximum):  # 计算适应度,这里用z的归一化加次方
    """
    :param data: 需要计算的z值列表
    :param max_data: z最大值
    :param min_data: z最小值
    :param maximum: 数值较大适应度高?
    :return: 适应度列表
    """
    # 之所以加个1e-3是为了让最小的也有活下去可能(来自i道i的仁慈)
    gap = max_data - min_data  # 最大最小值的差距
    # 下面这里加点次方能更好的提升最大数值与最小数值的差距,保证较优秀的个体不会寄
    if (maximum):
        fitness = [((i - min_data) / gap)**5 + 1e-3 for i in data]  # 归一化
    else:
        fitness = [((max_data - i) / gap)**5 + 1e-3 for i in data]  # 归一化
    return fitness

        通过实验,增加次方运算能帮助收敛,3次方有一定效果,5次方效果比较明显,更高次方效果显著。这里使用5次方为例,结果如下:

适应度计算公式修改后结果:

遗传算法,修改适应度代码结果

增加小数点位数

        通过观察最后的结果,我们发现最后并没有到达最值点,这是因为我们使用二进制编码的方式来决定个体的x,y,使用了8位小数,这代表个体的取值其实是离散的,且最小粒度为2^-8 = 0.00390625

因此,我们可以通过增加小数位数,来使得最终收敛结果更加接近真正的最值点。

修改小数位数可以直接修改主函数中的point变量,这里我们以修改为21为例,2^-21=0.000000476837158203125

主函数修改:

if __name__ == "__main__":
    # 建立窗口
    fig = plt.figure()
    # 生成坐标网格
    x, y, z = Get_Grid()
    plt.pause(1)  # 方便录像用,开窗口后等1秒再出图,你们建议删去
    # 参数设置
    number = 100  # 种群初始大小
    point = 21  # 小数位数
    n = point+3  # x或y长度
    loop = 100  # 最大训练轮数
    gene_data = Get_Random_gene(number, n)  # 获得初始基因
    gene_end = Genetic_train(fig, gene_data, number, n, point, loop, x, y, z)  # 族群开始进化
    # 显示图形,完成后不消失
    plt.show()

增加小数点位数,确实能减少粒度,更趋近于最值点,但随着位数增多,收益会不断递减

增加小数点位数结果:

遗传算法,修改小数位数代码结果

修改存活个体数

        我们可能下意识认为,减少存活个体数会加快收敛过程,但会更容易找到错误最值点,相对而言,增加存活个体数,虽然会使得收敛变慢,但找到的最值点更准确,也更能避免错误的收敛。

        但实际使用时,我们会发现,增加存活个体数,因为每次死亡的个体少,所以出生的个体也少,导致变异的个体比较少,最后往往会因为没有变异个体早停,最后往往不能寻找到更好的最值点,总是差一些,减少存活个体数会导致留下的基因型少,但是生的多,更容易变异,反倒经常比增加存活个体数结果好。

修改Genetic_train函数,代码202行左右,这个for语句range(len_gene//2)更改为

保留1成个体

        new_gene = []  # 新族群
        for j in range(len_gene *1// 10):
            selected_elements = random.choices(index_table, weights=fitness)  # 根据适应度,选中生存的个体

保留1成个体结果:

遗传算法,保留一成个体代码结果

保留9成个体 

        new_gene = []  # 新族群
        for j in range(len_gene *9// 10):
            selected_elements = random.choices(index_table, weights=fitness)  # 根据适应度,选中生存的个体

保留9成个体结果:

遗传算法,保留九成个体代码结果

酌情使用

增加初始个体数目:

无明显变化(计算时间除外)结果肯定是更好的,毕竟搜索的点更多了,但感觉不如多次取最好值。视频过长就不粘贴了

你可能感兴趣的:(python,开发语言)