【数模/启发式算法】遗传算法

最新推荐文章于 2024-04-19 10:36:47 发布
最新推荐文章于 2024-04-19 10:36:47 发布
阅读量1k 收藏 8
点赞数 3
分类专栏： 数学建模 文章标签： 启发式算法 算法 遗传算法 优化问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55799677/article/details/126323943
版权

文章目录

简介

 遗传算法（Genetic Algorithm，GA）最早是由美国的 John holland于20世纪70年代提出，该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。

符号说明

符号含义
n n n种群个体个数
a a a求解区间左端点
b b b求解区间右端点
l e n g t h length length编码长度
X X X编码串的二进制转十进制值
v a l val val编码串的映射值
p c pc pc‘基因’交叉的概率
p m pm pm‘基因’变异的概率

核心思想

 遗传算法借鉴了达尔文的进化论和孟德尔的遗传学说。其本质是一种并行、高效、全局搜索的方法。其能够在搜索过程中自动获取和积累搜索空间的知识，并自适应的控制搜索过程以获得最优解。

 遗传算法使用“适者生存”的原则，在潜在的解决方案种群中逐次产生一个近似最优的方案。在遗传算法的每一代中，根据个体在问题域中的适应度和从自然学说中借鉴来的再造方法进行个体选择，产生一个新的近似解。在这个过程中导致种群的进化，得到的新个体比原个体更能适应环境，就像自然界中的改造一样。

流程图

在这里插入图片描述

文章使用到的测试函数

一元函数： y = − a b s ( x s i n ( x ) c o s ( 2 x ) − 2 x s i n ( 3 x ) + 3 x s i n ( 4 x ) ) ,     x ∈ [ 0 , 50 ] y = -abs(xsin(x)cos(2x)-2xsin(3x)+3xsin(4x)), \ \ \ x \in [0, 50] y=−abs(xsin(x)cos(2x)−2xsin(3x)+3xsin(4x)),   x∈[0,50]参考最小值为： m i n ( y ) = − 219.501 min(y) = -219.501 min(y)=−219.501
在这里插入图片描述

二元函数： y = x 1 2 + x 2 2 − x 1 x 2 − 10 x 1 − 4 x 2 + 60 y = x_{1}^{2}+x_{2}^{2}-x_{1}x_{2}-10x_{1}-4x_{2}+60 y=x12​+x22​−x1​x2​−10x1​−4x2​+60参考最小值为： m i n ( y ) = 8.0 min(y) = 8.0 min(y)=8.0
在这里插入图片描述

遗传算法基本原理

编码解码

常见的编码方式为使用二进制进行编码，并利用解码函数将二进制码映射到可行域中。对于不同的问题编码方式会作出相应调整。

当串长 l e n g t h = n length=n length=n，可行域为 [ a , b ] [a, b] [a,b]时。我们将可行域划分为 2 n − 1 2^{n}-1 2n−1份，其中一个二进制串s（s的10进制值 ∈ [ 0 , 2 l e n g t h − 1 ] \in [0, 2^{length}-1] ∈[0,2length−1]）所映射值的计算公式为： v a l = a + X ∗ b − a 2 l e n g t h − 1 val = a + X*\frac{b - a}{2^{length} - 1} val=a+X∗2length−1b−a​其中， X X X表示s的十进制值。能够直观理解，将原区间划分为 2 l e n g t h − 1 2^{length} - 1 2length−1份，每一份的值为 b − a 2 l e n g t h − 1 \frac{b - a}{2^{length} - 1} 2length−1b−a​。

因此，串长决定了每个二进制串映射值的精度，串长越长则划分越细精度越高。（注意：每个串表示的精度越高，也间接影响到遗传算法计算结果的精度。通常串长取20-30较为合适。）

代码中的二进制映射函数：

# 二进制 ”转“（映射）十进制
# 公式：val = 区间begin + 串十进制值 * 区间长度 / (2^length - 1)
# 注意：为适应多元函数，返回值为一个包含var个实数值的向量
def m_decode(self, indiv):
    xpos = [0] * self.var
    # var个自变量
    for i in range(self.var):
        xpos[i] = self.lb[i] + int(indiv[i], 2) * (self.ub[i] - self.lb[i]) / (2 ** self.length - 1)

    return xpos
“基因”复制

在这里插入图片描述
为了得到最优解，算法模拟基因编码的复制。并控制较为优秀的基因要多复制（表现为复制概率更大），而较差一点的基因要少复制（表现为复制概率较小）。这里的优秀与否取决于对应编码的适应度。

那么，如何根据适应度来赋予复制概率，并按照概率来进行复制呢？

假设，我们在解决一个函数最大值的问题。此时适应度即为编码对应的函数值，假设fit(a) = 1，fit(b) = 2，fit(c ) = 3，fit(d) = 4。对每个编码适应度进行归一化，即可得到对应的概率P为：P(a) = 1/10, P(b) = 2/10, P(c ) = 3/10, P(d) = 4/10。

有了编码对应的概率，我们要如何依概率进行复制呢？
我们将概率进行一次累加得到[1/10, 3/10, 6/10, 10/10]，此时我们取一随机数，若随机数落入区间为 r ≤ 1 / 10 r \le 1/10 r≤1/10则编码1需要复制、随机数落入区间为 1 / 10 < r ≤ 3 / 10 1/10< r \le 3/10 1/10<r≤3/10则编码2需要复制…

我们只需要得到一组随机数，并将其排序依次对累加概率进行比较，即可按概率进行复制。此方法相当于将区间问题转化为右端点问题，简化了原问题。

基因复制代码（预处理部分为了保证函数值越小，概率越大）：

# 基因（编码）复制
def m_copy(self):
    new_popu = [[''] * self.var for _ in range(self.n)]
    # 计算复制每个个体复制基因的概率， 概率越大复制概率越大
    ## 按照取值赋概率， 取值越小概率越大。 因此对所有取值先预处理
    ### 预处理：首先要非负，因为概率取值原理是归一化

    minval = min(self.fit)
    addval = 0
    if minval <= 0:
        # 原值要加上addval， 保证取倒数后分母不能为0。 取倒数原因：值越小需要概率越大
        addval = -minval + 1

    tem = list(map(lambda x : 1 / (x + addval), self.fit))
    s_tem = sum(tem)
    # 归一化计算概率
    p = list(map(lambda x : x / s_tem, tem))

    # 概率求累加, 为了方便让概率大的多复制
    cum_p = [0] * self.n
    cum_p[0] = p[0]
    for i in range(1, self.n):
        cum_p[i] = cum_p[i - 1] + p[i]

    # 制造一组有序的随机数， 随机数落入累加区间即需要复制
    choice = [random.random() for _ in range(self.n)]
    choice.sort()

    i = 0
    j = 0
    while j < self.n and i < self.n:
        # 只要当前随机数小于右端点就说明落入该区间，需要复制
        if choice[j] <= cum_p[i]:
            new_popu[j] = deepcopy(self.popu[i])
            j = j + 1
        else: # 随机数大于右端点，需要和之后的区间进行比较
            i = i + 1

    return new_popu
“基因”交叉

在这里插入图片描述
使用三段式交叉方式，即掐头，去尾，交换中间（可以参考上图）。
代码中对相邻两编码进行“基因”交叉操作，所交换部分由随机数控制。

基因交叉代码：

# 基因（编码）交叉
def m_cross(self, new_popu):
    # 相邻两个个体同种基因（同一自变量编码）进行交叉
    i = 1
    while i < self.n:
        if random.random() < self.pc:
            # 取出要进行交叉的两个个体
            indiv1 = deepcopy(new_popu[i - 1])
            indiv2 = deepcopy(new_popu[i])

            # 逐变量进行编码交叉
            # hmax 划分值：self.length - 1， 因为下边从1开始
            hmax = self.length - 1
            for j in range(self.var):
                h1 = random.randint(0, hmax)
                h2 = random.randint(0, hmax)

                if h1 > h2:
                    h1, h2 = h2, h1

                # 交叉划分构成的区间
                new_popu[i - 1][j] = indiv1[j][0 : h1] + indiv2[j][h1 : h2 + 1] + indiv1[j][h2 + 1:]
                new_popu[i][j] = indiv2[j][0 : h1] + indiv1[j][h1 : h2 + 1] + indiv2[j][h2 + 1:]

        i = i + 2

    return new_popu
“基因”变异

在这里插入图片描述
由于采用二进制编码，因此“基因”变异十分简单，可以描述为：随机选择位点进行取反操作即可，因为二进制串只有0和1。

“基因”变异代码：

# 基因（编码）变异
def m_mutation(self, new_popu):
    # n个个体
    for i in range(self.n): # var个自变量
        for j in range(self.var):
            if random.random() < self.pm:
                # 随机挑选2个数变异
                for k in range(2):
                    # 要变异的下标
                    idx = random.randint(0, self.length - 1)
                    if new_popu[i][j][idx] == '0':
                        new_popu[i][j] = new_popu[i][j][0:idx] + '1' + new_popu[i][j][idx + 1:]
                    else:
                        new_popu[i][j] = new_popu[i][j][0:idx] + '0' + new_popu[i][j][idx + 1:]

    return new_popu

遗传算法代码

Python版本：


import random
from copy import deepcopy
import math

def func(x):
    # 一元函数测试
    return -abs(x[0] * math.sin(x[0]) * math.cos(2 * x[0]) - 2 * x[0] * math.sin(3 * x[0]) + 3 * x[0] * math.sin(4 * x[0]))

    # # 二元函数测试
    # return x[0]**2 + x[1]**2 - x[0]*x[1] - 10 * x[0] - 4 * x[1] + 60

class GA:

    def __init__(self, func, n, var = 1, length = 20, iter = 50, lb = None, ub = None):
        """ 默认寻找最小值，以及对应自变量取值。 若需要寻找最大值，对目标函数乘-1，并对最终结果乘-1即可
        Args:
            :param func: type: 函数， des: 所要求解优化问题的目标函数
            :param n: type: int， des: 粒子群粒子的个数
            :param var: type: int， des: 函数中自变量的个数，即：几元函数
            :param length: type: int， des: 用于编码的串长了。
            :param iter: type: int， des: 迭代次数
            :param lb: type: list(double)， des: 每一种自变量的下界，注意应和自变量一一对应
            :param ub: type: list(double)， des: 每一种自变量的上界，注意应和自变量一一对应
        """
        if lb is None:
            lb = []
        if ub is None:
            ub = []

        # 目标函数
        self.func = func
        # 初始化种群个数
        self.n = n
        # 初始化编码串长
        self.length = length
        # 初始化变量种类数
        self.var = var
        # 初始化迭代次数
        self.iter = iter
        # 初始化自变量范围 len(lb) = len(ub) = var
        self.lb = lb
        self.ub = ub

        # 交叉概率和变异概率 0.6 - 0.1
        self.pc = 0.6
        self.pm = 0.1

        # 初始化适应度
        self.fit = [0] * n

        # 产生初始群体 每一行为一个种群个体的var个字符串, 因为每一个个体需要var个变量来描述
        ## var等于1时即为一元函数
        self.popu = [[''] * var for _ in range(n)]
        # 使用随机数初始个体
        for i in range(n): # n个个体
            for j in range(var): # 每个个体的自变量个数
                self.popu[i][j] = str(bin(random.randint(0, int(2 ** length))))[2:]
                if len(self.popu[i][j]) < length:
                    self.popu[i][j] = '0' * (length - len(self.popu[i][j])) + self.popu[i][j]

        # 最优解对应的对应自变量取值
        self.x = self.m_decode(self.popu[0])
        self.fit[0] = self.func(self.x)

        # 用初代值计算一组解
        for i in range(1, n):
            now_x = self.m_decode(self.popu[i])
            self.fit[i] = self.func(now_x)
            if self.fit[i] < self.func(self.x): # 以求解最小值的方式更新当前最优解
                self.x = deepcopy(now_x)



    # 二进制 ”转“（映射）十进制
    # 公式：val = 区间begin + 串十进制值 * 区间长度 / (2^length - 1)
    # 注意：为适应多元函数，返回值为一个包含var个实数值的向量
    def m_decode(self, indiv):
        xpos = [0] * self.var
        # var个自变量
        for i in range(self.var):
            xpos[i] = self.lb[i] + int(indiv[i], 2) * (self.ub[i] - self.lb[i]) / (2 ** self.length - 1)

        return xpos


    # 基因（编码）复制
    def m_copy(self):
        new_popu = [[''] * self.var for _ in range(self.n)]
        # 计算复制每个个体复制基因的概率， 概率越大复制概率越大
        ## 按照取值赋概率， 取值越小概率越大。 因此对所有取值先预处理
        ### 预处理：首先要非负，因为概率取值原理是归一化

        minval = min(self.fit)
        addval = 0
        if minval <= 0:
            # 原值要加上addval， 保证取倒数后分母不能为0。 取倒数原因：值越小需要概率越大
            addval = -minval + 1

        tem = list(map(lambda x : 1 / (x + addval), self.fit))
        s_tem = sum(tem)
        # 归一化计算概率
        p = list(map(lambda x : x / s_tem, tem))

        # 概率求累加, 为了方便让概率大的多复制
        cum_p = [0] * self.n
        cum_p[0] = p[0]
        for i in range(1, self.n):
            cum_p[i] = cum_p[i - 1] + p[i]

        # 制造一组有序的随机数， 随机数落入累加区间即需要复制
        choice = [random.random() for _ in range(self.n)]
        choice.sort()

        i = 0
        j = 0
        while j < self.n and i < self.n:
            # 只要当前随机数小于右端点就说明落入该区间，需要复制
            if choice[j] <= cum_p[i]:
                new_popu[j] = deepcopy(self.popu[i])
                j = j + 1
            else: # 随机数大于右端点，需要和之后的区间进行比较
                i = i + 1

        return new_popu


    # 基因（编码）交叉
    def m_cross(self, new_popu):
        # 相邻两个个体同种基因（同一自变量编码）进行交叉
        i = 1
        while i < self.n:
            if random.random() < self.pc:
                # 取出要进行交叉的两个个体
                indiv1 = deepcopy(new_popu[i - 1])
                indiv2 = deepcopy(new_popu[i])

                # 逐变量进行编码交叉
                # hmax 划分值：self.length - 1， 因为下边从1开始
                hmax = self.length - 1
                for j in range(self.var):
                    h1 = random.randint(0, hmax)
                    h2 = random.randint(0, hmax)

                    if h1 > h2:
                        h1, h2 = h2, h1

                    # 交叉划分构成的区间
                    new_popu[i - 1][j] = indiv1[j][0 : h1] + indiv2[j][h1 : h2 + 1] + indiv1[j][h2 + 1:]
                    new_popu[i][j] = indiv2[j][0 : h1] + indiv1[j][h1 : h2 + 1] + indiv2[j][h2 + 1:]

            i = i + 2

        return new_popu


    # 基因（编码）变异
    def m_mutation(self, new_popu):
        # n个个体
        for i in range(self.n): # var个自变量
            for j in range(self.var):
                if random.random() < self.pm:
                    # 随机挑选2个数变异
                    for k in range(2):
                        # 要变异的下标
                        idx = random.randint(0, self.length - 1)
                        if new_popu[i][j][idx] == '0':
                            new_popu[i][j] = new_popu[i][j][0:idx] + '1' + new_popu[i][j][idx + 1:]
                        else:
                            new_popu[i][j] = new_popu[i][j][0:idx] + '0' + new_popu[i][j][idx + 1:]

        return new_popu


    def run(self):
        for k in range(1, self.iter + 1):

            # 控制交叉概率线性递减 [0.6 - 0.2]
            self.pc = 0.6 - 0.4 * k / self.iter
            # 控制变异概率线性递减 [0.3 - 0.1]
            self.pm = 0.3 - 0.2 * k / self.iter

            # "基因"复制
            new_popu = self.m_copy()
            # "基因"交叉
            new_popu = self.m_cross(new_popu)
            # "基因"变异
            new_popu = self.m_mutation(new_popu)

            for i in range(self.n):

                new_fit = self.func(self.m_decode(new_popu[i]))
                if new_fit < self.fit[i]:
                    # 概率保留优秀基因，因为较差的基因也有可能更新出最优解
                    if random.random() < 0.5:
                        self.fit[i] = new_fit
                        self.popu[i] = deepcopy(new_popu[i])

                    self.x = self.m_decode(new_popu[i])

        print(f'最优解为：{self.func(self.x)}')
        print(f'最优解对应自变量取值为：{self.x}')



"""一元函数测试"""
ga = GA(func, 50, 1, 20, 100, [0], [50])


"""二元函数测试"""
# ga = GA(func, 50, 2, 20, 100, [-15, -15], [15, 15])

ga.run()

以一元函数测试为例，对应输出为（结果较为不错）：

最优解为：-219.4965723300476
最优解对应自变量取值为：[47.55863910545264]
Sophon、
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
启发式算法之遗传算法
weixin_46509574的博客
12-05 289
Python实现： 参考：​​​​​​(32条消息) 遗传算法详解及代码实现_呆小呆_的博客-CSDN博客_遗传算法代码 import numpy as np import matplotlib.pyplot as plt from matplotlib import cm from mpl_toolkits.mplot3d import Axes3D DNA_SIZE = 24 POP_SIZE = 200 CROSSOVER_RATE = 0.8 # crossover：交叉 MUTATION
启发式算法-遗传算法详解(内附几百行超详细有注释源代码)
阳寜的博客
05-26 4188
超详细的遗传算法原理、步骤解析，另附几百行完整源代码。
启发式算法-遗传算法
qq_42250782的博客
03-19 165
启发式算法-遗传算法
启发式算法——遗传算法
最新发布
qqrrjj2011的博客
04-19 955
启发式算法——遗传算法
TSP问题—启发式遗传算法
weixin_30914981的博客
07-13 174
TSP问题—启发式遗传算法 转载于:https://www.cnblogs.com/liuys635/p/11181266.html
数学建模培训 MATLAB与数学建模 启发式算法简介及其在数学模型中的应用 共147页.pdf
04-09
启发式算法在数学建模中的应用，如模拟退火和遗传算法，为解决复杂的优化问题提供了有效工具。它们不仅应用于TSP，还适用于资源分配、生产调度、网络设计等多个领域。然而，使用这些算法时需注意参数设置的影响，如...
数模美赛常用算法集合
03-13
深度优先搜索(DFS)和广度优先搜索(BFS)是最基础的搜索策略，而A*搜索算法则引入了启发式函数，提高了效率。 7. **概率算法**： 这类算法在决策过程中引入了随机性。例如，蒙特卡洛方法就是通过随机抽样来计算问题...
A星八数码/广度优先/深度优先/粒子群寻优算法/遗传算法/蚁群算法/BP神经网络/卷积神经网络
10-07
6. **遗传算法(GA)**：遗传算法模拟自然选择和遗传过程，通过选择、交叉和变异操作，从一组初始解（个体）中逐步演化出高质量的解。这种方法广泛应用于复杂优化问题。 7. **蚁群算法(ACO)**：受蚂蚁寻找食物过程中...
遗传算法从入门到掌握.pdf
03-01
尽管遗传算法是一种启发式算法，不一定保证能求出全局最优解，但在多数情况下，它都能得到较好的近似解。随着人工智能技术的发展，遗传算法作为一种强大而灵活的工具，在解决各种实际问题中有着不可替代的重要作用。
GA遗传算法matlab程序
12-11
遗传算法是一种启发式搜索算法，灵感来源于自然界中的生物进化过程，它通过模拟自然选择和遗传机制来解决优化问题。 在描述中提到的“基于ATO的列车速度曲线优化”，ATO（Automatic Train Operation）是指自动列车...
基于遗传算法启发式算法退火算法的车间调度研究（代码+案例+说明）
04-09
进阶生产规划及排程系统　便是利用先进的信息科技及规划技术，例如基因算法﹝Genetic Algorithm﹞、限制理论﹝Theory of Constraints﹞、作业分析 ﹝Operations Research﹞、 生产仿真﹝Simulation﹞及限制条件满足技术﹝Constraint Satisfaction Technique﹞等，在考虑企业资源﹝主要为物料与产能﹞限制条件与生产现场的控制与派工法则下，规划可行的物 料需求计划与生产排程计划，以满足顾客需求及面对竞争激烈的市场。进阶生产规划及排程亦提供了what-if 的分析，可以让规划者快速结合生产信息﹝如订单、途程、存货、BOM与产能限 制等﹞，作出平衡企业利益与顾客权益的最佳规划和决策。
启发式算法 | 遗传算法
Hygge的博客
11-05 573
遗传算法是借鉴生物的自然选择和遗传进化机制而开发出的一种全局优化自适应概率搜索算法。 生物遗传概念&术语 算法中的作用 适者生存 算法停止时，最优目标值的可行解有最大的可能被留住 个体 可行解 种群 个体的集合 染色体
启发式算法详解——遗传算法
BodyCoding
06-15 1982
启发式算法详解——遗传算法算法原理算法详解算法详解算法总结 算法原理       遗传算法(Genetic Algorithm)遵循『适者生存』、『优胜劣汰』的原则，是一类借鉴生物界自然选择和自然遗传机制的随机化搜索算法。通过选择、交叉以及变异等机制，在每次迭代中都保留一组候选个体，重复此过程，种群经过若干代进化后，理想情况下其适应度达到近似最优的状态。       用大白话说，遗传算法就是模拟一个人工种群的进化过程，进化会有淘汰、交配、生殖、基
现代启发式算法（一）——遗传算法
Metropolis_cn的博客
09-13 5737
带你入门遗传算法，解读遗传算法的实现过程，通过求解TSP和mTSP问题加深对遗传算法的理解，你会发现遗传其实很有趣~
2015.2.7--记录我的机器学习之路--现代启发式算法之遗传算法
jaybeat的专栏
02-08 1228
遗传算法 对于经典的模型算法，已有太多前人为我们写下各种攻略，我就先整理下我在学习过程中查阅的并觉得讲解得不错的文章吧，之后再慢慢补充我自己反思之后的体会~ ---------------------------------------------------------------------------------------------------------------------
启发式算法之遗传算法--求解组合优化问题
qq_38757869的博客
08-24 6537
本文为原创文章，如有任何疑问请留言 遗传算法是一种全局、概率搜索算法，主要用于求解大规模旅行商问题、路径规划问题、任务调度等NP-hard问题。 遗传算法属于进化算法，首先将需要求解的自变量通过编码形成染色体，在遗传过程中通过交叉、变异等操作产生新个体，选择种群中较优的个体遗传到下一代，不断进化，直到达到遗传终止条件为止。 本文以一个小规模的两两组合优化问题为例对遗传算法的流程进行简要介绍。...
遗传算法
aizhouqian5537的博客
06-04 486
1 基本概念 　　遗传算法(GA)的概念是由Holland于1973年受生物进化论的启发而首次提出的。它是一种通过模拟生物界自然选择和遗传机制的随机搜索算法。 　　遗传算法基本思想是模拟自然界优胜劣汰的进化现象，把搜索空间映射为遗传空间，把可能的解编码成一个向量——染色体，向量的每个元素称为基因。 通过不断计算各染色体的适应值，选择最好的染色体，获得最优解。　 　　个体就是模拟生物...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sophon、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值