【算法】遗传算法

随心变化

已于 2022-11-13 10:49:21 修改

阅读量374

点赞数

分类专栏：智能优化算法文章标签： python

于 2022-10-25 18:15:36 首次发布

本文链接：https://blog.csdn.net/qq_41597232/article/details/127462490

版权

智能优化算法专栏收录该内容

6 篇文章 1 订阅

订阅专栏

遗传算法

1 基本原理

在这里插入图片描述
对每个个体都进行上述的进化，然后择优录取。

2 步骤

2.1 编码

二进制编码：用一个二进制串表示这个十进制数值。

给定数值解的区间范围： $[1, 10]$ 。
给定精度： $e^{-5}$ ，两个数值解的间隔。
进行编码：为每个数值解分配一个独一无二的二进制串。

例如
区间范围为 $[1, 10]$ ，长度为 2 的串提供的精度为多少？对应精度为 $\frac{10-1}{2^2 - 1} = 3$
于是数值区间长度为 L ，精度为 $E$ 的条件下，二进制串的长度 n ，三者关系为 $\frac{L}{2^n - 1} ≤E$
要想达到 $e^{-5}$ 的精度，对于区间长度为 10 ，串的长度 n 应该满足 $\frac{10}{2^n - 1} ≤0.00001$ → $n \geq 20$
$n = 20$ 时，串提供的精度约为 0.00000954
例如
以 $[1, 10]$ 为例，其十进制转换结果为 $0*2^0 + 1 * 2^1 = 2$
对应表示的数值为： $7 = 1 + 2 * 3$
以 $[1, 10]$ 为例，其十进制转换结果为 $1*2^0 + 1 * 2^1 = 3$
对应表示的数值为： $10 = 1 + 3 * 3$
一般的，区间范围为 $[a, b]$ ，区间长度为 L ，即 $L = b - a$ 串长为 n ，当前串对应十进制为 T ，则该串对应实值解为： $\frac{b - a}{2^n - 1}$
X

2.2 复制

个体进行复制，以概率𝑝𝑐进行基因的交叉，注意复制交叉方式多种多样。
复制

将个体适应度大小映射为概率进行复制：适应度高的个体有更大概率复制，且复制的份数越多轮盘赌法。
对适应度高的前 $\frac{N}{4}$ 的个体进行复制，然后用这些个体把后 $\frac{N}{4}$ 个体替换掉精英产生精英。
一定是将当前个体的复制体将下一个个体替换掉吗？随机可以吗？ YES!
一定只能把“坏解”替换掉吗？把随机某个适应度高的解替换掉呢？ YES!

2.3 交叉

交叉

按顺序，两两个体之间按概率交叉。如 1 和 2,2 和 3 等。或者 1 和 2,2 和 4 等，或者 1 和 4 这样。
必须两两交叉？ 3 个可以吗？ YES! 。 5 个？ YES！
对适应度高的前 $\frac{N}{2}$ 个体、甚至 $\frac{N}{4}$ 的个体之间相互交叉？ YES！
一定是按顺序交叉吗？对每个个体随机从前 $\frac{N}{2}$ 中选一个个体交叉？ YES！
一定是只有一段交叉？多段呢？ YES！

2.4 变异

变异

每个个体都进行变异。
只对适应度低的后 $\frac{N}{4}$ 的，或者后 $\frac{N}{2}$ 个个体变异？ YES！
必须都变异吗？按适应度大小映射为概率变异？ YES！
一定是只有一个位点变异？多个位点呢？ YES！

在这里插入图片描述

轮盘赌基本思想：适应度越高的解，按道理越应该高概率的进行复制，且复制的份数应该越多。
对于个体 $x_i$ ，计算对应适应度 $𝑓(𝑥_𝑖)$ ==> $𝑝_𝑖 = \frac{𝑓(𝑥_𝑖)}{\sum{𝑓(𝑥_𝑖)}}$

3 代码

import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation as animation  # 动画
import math

from numpy import random

# 解所在的可能区间
start = 0   # 起始
end = 8    # 结尾
# 迭代次数
iteration = 200
# 种群大小
size = 50
# 交叉概率
pc = 0.85
# 变异概率
pm = 0.05

# 表达式
def fitness(x):
    y = x * np.sin(4 * x) + 3 * x * np.cos(x) + 15
    return y

# 二进制编码
def getStrLen(precision):
    # 根据精度求串长
    l = math.ceil(math.log2((end - start) / precision + 1))
    return l

# 二进制解码: 二进制转十进制
def binaryDecode(matrix):
    len = getStrLen(1e-5)
    realValue = np.zeros(size)
    for i in range(size):  # 按照行来遍历
        for j in range(len):  # 对第i行进行遍历
            realValue[i] += matrix[i][j] * math.pow(2, j)

    for i in range(size):
        realValue[i] = start + realValue[i] * (end - start) / (math.pow(2, len) - 1)
    return realValue

# 复制
def copyX(parentX, fitness):  # martix 二进制基因片段；fitness种群的适应度
    l = getStrLen(1e-5)
    newX = np.random.randint(0, 2, (size, l))  #初始化一个下一代矩阵空间
    # print("初始化下一代矩阵")
    # print(newX)
    p = fitness / np.sum(fitness)  #概率
    cs = np.cumsum(p)  #累积概率
    # print("累积概率")
    # print(cs)
    cps= np.sort(np.random.rand(size))  # 轮盘赌，每个个体复制的概率
    # print("每个个体复制的概率")
    # print(cps)
    for i in range(size):
        if cps[i] < cs[i]:
            newX[i,:] = parentX[i,:]
    # print("复制后的种群")
    # print(newX)

    return newX


# 交叉方式 第i行的[crossStart, crossEnd]片段 与 第 i + 1行的[crossStart, crossEnd]片段交换
def crossX(matrix):
    i = 0
    l = getStrLen(1e-5)
    while i < size:
        if np.random.rand(1) < pc:
            positions = np.random.choice(l, 2, False)
            crossStart = positions.min()
            crossEnd = positions.max()
            np.random.choice(l, 2, False) # 在[0, len)之间选择两个不重复的数字
            j = (i + 1) % size
            pre = matrix[i: j, crossStart: crossEnd + 1]
            if j > i:
                matrix[i: j, crossStart: crossEnd + 1] = matrix[j: j + 1, crossStart: crossEnd + 1]
                matrix[j: j + 1, crossStart: crossEnd + 1] = pre
            i = i + 2
        else:
            i = i + 1

        if i >= size:
            break
    # print("交叉后的种群")
    # print(matrix)
    return matrix

# 变异
def mutationX(matrix):
    l = getStrLen(1e-5)
    for i in range(size):
        if np.random.rand(1) < pm:
            position = np.random.choice(l, 1, False)
            matrix[i][position] = np.mod((matrix[i][position] + 1), 2)

    # print("变异后的种群")
    # print(matrix)
    return matrix


if __name__ == '__main__':
    l = getStrLen(1e-5)
    # 生成初代种群，size--种群大小；len--串长
    matrix = np.random.randint(0, 2, (size, l))
    print("初代矩阵")
    print(matrix)
    # 绘制函数图像
    t = np.arange(start, end, 0.001)

    for i in range(iteration):
        dec = binaryDecode(matrix)  # 上一代解的十进制
        fit = fitness(dec)  # 上一代适应值
        # print("上代适应值")
        # print(fit)
        # print("*******  复制操作  ********")
        newX = copyX(matrix, fit)
        # print("*******  交叉操作  ********")
        newX = crossX(newX)
        # print("*******  变异操作  ********")
        newX = mutationX(newX)
        # 对下一代择优保留
        newDec = binaryDecode(newX)  #新一代十进制
        newFit = fitness(newDec) # 新一代适应度
        for j in range(size):
            if newFit[j] > fit[j]:
                matrix[j,:] = newX[j,:]    # 将好的子代替换进父代
        # 动态每一代最优值图像
        dec = binaryDecode(matrix)  # 择优后最终新一代解的十进制
        fit = fitness(dec)  # 择优后最终新一代适应值
        plt.plot(t, fitness(t), color='black')
        plt.scatter(dec, fit, s=5, c='red')
        plt.draw()
        plt.pause(0.2)
        plt.clf()


    dec = binaryDecode(matrix)  # 最终一代解的十进制
    fit = fitness(dec)  # 最一代适应值

    maxIndex = fit.argmax()

    plt.plot(t,fitness(t),color = 'black')
    plt.scatter(dec, fit, s=5, c='red')
    plt.scatter(dec[maxIndex], fit.max(), s=5, c = 'blue')
    plt.show()

# 取矩阵的第一行 matrix[0,:]
# 取矩阵的第一列 matrix[:,0]
# 取部分矩阵，行[i, j),列[m,n)：matrix[i: j, m: n]
# 产生一个随机小数：np.random.rand(1)

# -------------------动态图-----------------------
# fig：窗口画布，用 fig, ax = plt.subplots() 生成
# func：要反复调用的函数（至少要传入一个参数），用该函数生成、更改图像
# frames:向要调用的函数传递的参数（默认依次传入0,1,2,3…）
# init_func：用于给定图像初始信息的函数

4 运行效果

在这里插入图片描述

随心变化

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【算法】遗传算法

遗传算法借鉴了达尔文的进化论和孟德尔的遗传学说。其本质是一种并行、高效、全局搜索的方法，它能在搜索过程中自动获取和积累有关搜索空间的知识，并自适应地控制搜索过程以求得最优解。遗传算法操作使用“适者生存”的原则，在潜在的解决方案种群中逐次产生一个近似最优的方案。在遗传算法的每一代中，根据个体在问题域中的适应度值和从自然遗传学中借鉴来的再造方法进行个体选择，产生一个新的近似解。这个过程导致种群中个体的进化，得到的新个体比原个体更能适应环境，就像自然界中的改造一样。
复制链接

扫一扫