GA求解Benchmark函数

已于 2023-05-01 11:26:04 修改
阅读量250 收藏 2
点赞数 1
分类专栏： Python-算法 文章标签： python
于 2023-05-01 11:25:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45974177/article/details/130453841
版权

遗传算法Benchmark测评

前言

本文用来记录GA求解Benchmark代码思路。

一、问题介绍

求解Benchmark用例为：
F ( x ) = ∑ 1 n x i 2   F(x)=\sum_{1}^{n}x_{i}^{2}\space F(x)=∑1n​xi2​ 
x ∈ [ − 100 , 100 ] x\in[-100,100] x∈[−100,100]
图形可视化为如下，容易看出最优点为(0,0,0,0,…)，最优值为0。
为了可视化方便，仅计算二维情况。
在这里插入图片描述

二、Python实现GA求解

2.1 定义求解函数

def func1(x1,x2):
    return x1**2+x2**2

2.2 GA类初始化部分

    def __init__(self, pop_size, epoch, cross_prob, mutate_prob,func,print_batch=10):
        self.pop_size = pop_size # 种群数量
        self.epoch = epoch # 迭代次数
        self.cross_prob = cross_prob # 交叉概率
        self.mutate_prob = mutate_prob # 变异概率
        self.width = 48 # 一个基因的长度，长度越长精度越高
        self.best = None # 索存最优结果
        self.genes = np.array(
            ["".join([random.choice(['0', '1']) for _ in range(self.width)]) for _ in range(self.pop_size)]
        ) # 随机生成初始种群

2.3 交叉操作

    def inter_cross(self):
        # 交叉操作
        ready_index = list(range(self.pop_size)) # ready_index索存所有基因的索引号，挑选任意两个进行交叉操作。
        while len(ready_index) >= 2: # 必须有2个以上的基因存在才可以交叉。
            d1 = random.choice(ready_index)  # 从0-100挑一个父基因
            ready_index.remove(d1) # 挑选以后移除列表
            d2 = random.choice(ready_index)  # 从0-100挑一个父基因
            ready_index.remove(d2) # 挑选以后移除列表

            if np.random.uniform(0, 1) <= self.cross_prob: # 随机数判断是否需要交叉
                loc = random.choice(range(1, self.width - 1)) # 随机挑选交叉的位置
                d1_a, d1_b = self.genes[d1][0:loc], self.genes[d1][loc:] # 将d1基因分为2份
                d2_a, d2_b = self.genes[d2][0:loc], self.genes[d2][loc:] # 将d2基因分为2份
                self.genes[d1] = d1_a + d2_b # 进行交叉操作
                self.genes[d2] = d2_a + d1_b # 进行交叉操作

2.4 变异操作

    def mutate(self):
        # 变异操作
        ready_index = list(range(self.pop_size)) # ready_index索存所有基因的索引号，挑选任意两个进行变异操作。
        for i in ready_index:
            if np.random.uniform(0, 1) <= self.mutate_prob: # 随机数判断是否需要变异
                loc = random.choice(range(0, self.width)) # 随机挑选需要变异的位置
                t0 = list(self.genes[i]) # t0为列表,存储第i个基因的字符串
                t0[loc] = str(1 - int(self.genes[i][loc])) # 取反操作  1-0=1,1-1=0
                self.genes[i] = "".join(t0)

2.5 适应度计算

    def get_adjust(self):
        # 计算适应度
        x1,x2 = self.get_decode()  # 首先解码，之后返回对应值。
        return func1(x1,x2)

    def get_decode(self):
    	# x1,x2分别对应列表中各24位,通过对其进行二进制转十进制操作后除以（2**24-1）*200,得到对应[0,200]的数,在加上-100后，变为[-100,100].
        x1 = (-100) + np.array([int(x[:24], 2) * 200 / (2 ** 24 - 1) for x in self.genes]) 
        x2 = (-100) + np.array([int(x[24:], 2) * 200 / (2 ** 24 - 1) for x in self.genes])
        return x1,x2

2.6 轮盘赌

由于轮盘赌的原理是概率越大越容易被选中，但是问题是求MIN问题，所以选择使用倒数的方法。

    def cycle_select(self):
        # 轮盘赌
        adjusts = 1/self.get_adjust() # 得到每个基因的适应度值.
        if self.best is None or 1/np.max(adjusts) < self.best[1]: # 筛选最优的基因并存到best中.
            self.best = self.genes[np.argmax(adjusts)], 1/np.max(adjusts)
        p = adjusts / np.sum(adjusts)  # 计算所有基因的概率
        cu_p = []  # 计算累计分布概率

        for i in range(self.pop_size):
            cu_p.append(np.sum(p[0:i]))
        cu_p = np.array(cu_p) # 变为np.array对象
        r0 = np.random.uniform(0, 1, self.pop_size) # 随机生成0-1的均匀分布与种群的累计分布概率比较
        sel = [max(list(np.where(r > cu_p)[0]) + [0]) for r in r0] 

        # 确保最优个体的存活.
        if 1/np.max(adjusts[sel]) < self.best[1]:
            self.genes[sel[np.argmax(adjusts[sel])]] = self.best[0]
        self.genes = self. Genes[sel]

2.7 主函数

    def evolve(self):
        # 主程序.
        for i in range(self.epoch):
            self.cycle_select() # 进行轮盘赌.
            self.inter_cross() # 交叉操作.
            self.mutate() # 变异操作.

三、代码整体

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Project ：最优化方法 
@File    ：GA-1.py
@IDE     ：PyCharm 
@Author  ：Pan  YX
@Date    ：2023/4/29 15:24 
@Descib  ：
'''
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import re
import math
import random

def func1(x1,x2):
    return x1**2+x2**2

def show(x_s,x_e,func,end1=None,end2=None):
    fig = plt.figure(figsize=(10, 7))
    ax = Axes3D(fig, auto_add_to_figure=False)
    fig.add_axes(ax)
    ax.set_xlabel('$x1$', fontsize=16)
    ax.set_ylabel('$x2$', fontsize=16)
    ax.set_zlabel('$f(x)$', fontsize=16)
    x1 = np.linspace(x_s, x_e, 100)
    x2 = np.linspace(x_s, x_e, 100)
    # x-y 平面的网格
    x1, x2 = np.meshgrid(x1, x2)
    z = func(x1,x2)
    ax.plot_surface(x1, x2, z, rstride=1, cstride=1, cmap=plt.get_cmap('cool'))
    if end1 != None and end2 != None:
        ax.scatter(end1,end2,func(end1,end2),s=500,c='r',marker='.')
    plt.show()

class GeneSolve:
    def __init__(self, pop_size, epoch, cross_prob, mutate_prob,func,print_batch=10):
        self.pop_size = pop_size # 种群数量
        self.epoch = epoch # 迭代次数
        self.cross_prob = cross_prob # 交叉概率
        self.mutate_prob = mutate_prob # 变异概率
        self.width = 48 # 一个基因的长度，长度越长精度越高
        self.best = None # 索存最优结果
        self.genes = np.array(
            ["".join([random.choice(['0', '1']) for _ in range(self.width)]) for _ in range(self.pop_size)]
        ) # 随机生成初始种群

    def inter_cross(self):
        # 交叉操作
        ready_index = list(range(self.pop_size)) # ready_index索存所有基因的索引号，挑选任意两个进行交叉操作。
        while len(ready_index) >= 2: # 必须有2个以上的基因存在才可以交叉。
            d1 = random.choice(ready_index)  # 从0-100挑一个父基因
            ready_index.remove(d1) # 挑选以后移除列表
            d2 = random.choice(ready_index)  # 从0-100挑一个父基因
            ready_index.remove(d2) # 挑选以后移除列表

            if np.random.uniform(0, 1) <= self.cross_prob: # 随机数判断是否需要交叉
                loc = random.choice(range(1, self.width - 1)) # 随机挑选交叉的位置
                d1_a, d1_b = self.genes[d1][0:loc], self.genes[d1][loc:] # 将d1基因分为2份
                d2_a, d2_b = self.genes[d2][0:loc], self.genes[d2][loc:] # 将d2基因分为2份
                self.genes[d1] = d1_a + d2_b # 进行交叉操作
                self.genes[d2] = d2_a + d1_b # 进行交叉操作

    def mutate(self):
        # 变异操作
        ready_index = list(range(self.pop_size))
        for i in ready_index:
            if np.random.uniform(0, 1) <= self.mutate_prob:
                loc = random.choice(range(0, self.width))
                t0 = list(self.genes[i])
                t0[loc] = str(1 - int(self.genes[i][loc]))
                self.genes[i] = "".join(t0)

    def get_adjust(self):
        # 计算适应度
        x1,x2 = self.get_decode()  # 首先解码，之后返回对应值。
        return func1(x1,x2)

    def get_decode(self):
    	# x1,x2分别对应列表中各24位,通过对其进行二进制转十进制操作后除以（2**24-1）*200,得到对应[0,200]的数,在加上-100后，变为[-100,100].
        x1 = (-100) + np.array([int(x[:24], 2) * 200 / (2 ** 24 - 1) for x in self.genes])
        x2 = (-100) + np.array([int(x[24:], 2) * 200 / (2 ** 24 - 1) for x in self.genes])
        return x1,x2

    def cycle_select(self):
        # 轮盘赌
        adjusts = 1/self.get_adjust() # 得到每个基因的适应度值.
        if self.best is None or 1/np.max(adjusts) < self.best[1]: # 筛选最优的基因并存到best中.
            self.best = self.genes[np.argmax(adjusts)], 1/np.max(adjusts)
        p = adjusts / np.sum(adjusts)  # 计算所有基因的概率
        cu_p = []  # 计算累计分布概率

        for i in range(self.pop_size):
            cu_p.append(np.sum(p[0:i]))
        cu_p = np.array(cu_p) # 变为np.array对象
        r0 = np.random.uniform(0, 1, self.pop_size) # 随机生成0-1的均匀分布与种群的累计分布概率比较
        sel = [max(list(np.where(r > cu_p)[0]) + [0]) for r in r0]

        # 确保最优个体的存活.
        if 1/np.max(adjusts[sel]) < self.best[1]:
            self.genes[sel[np.argmax(adjusts[sel])]] = self.best[0]
        self.genes = self.genes[sel]

    def evolve(self):
        # 主程序.
        for i in range(self.epoch):
            self.cycle_select() # 进行轮盘赌.
            self.inter_cross() # 交叉操作.
            self.mutate() # 变异操作.
# 求解Benchmark1 -GA
show(-100,100,func=func1)

gs = GeneSolve(100,500,0.85,0.1,func=func1)
gs.evolve()

x1 = -100+ int(gs.best[0][:24], 2) * 200 / (2 ** 24 - 1)
x2 = -100+ int(gs.best[0][24:], 2) * 200 / (2 ** 24 - 1)
print(gs.best[0])
print('x1={},x2={},最优值为{}.'.format(x1,x2,gs.best[1]))
# show(-100,100,func=func1,end1=x1,end2=x2)
# 输出结果：
#011111111111111111111111100000000000000000000000
#x1=-5.96046483281043e-06,x2=5.96046483281043e-06,最优值为7.105428204633975e-11.
weixin_45974177
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TridentOpt：多目标优化引擎或求解器
筱乐云博客
12-20 2610
抽象 描述了使用混合遗传算法 - 多代理系统的新的通用多目标优化引擎。不同于传统的多目标方法，所提出的方法将问题转化为模糊规划等价物，其中包括模糊目标和约束条件。所提出的方法然后对目标函数和约束进行模糊集操作，将信息组合成单个目标和单个约束。这个单一的目标和单一的约束，然后用于排序模糊帕累托组和梳理劣质的解决方案。 关键词：多目标优化，遗传算法，多Agent系统，模糊规划，开源，优化求
Benchmark functions 优化算法测试函数
03-13
Benchmark functions.zip 包含了17个这样的测试函数，旨在帮助研究者和工程师测试他们的优化算法的效能和适应性。 首先，我们来看几个具体的函数： 1. **AckleyDisc.m**：Ackley函数是一个经典的多模态函数，它...
benchmark函数的基本介绍和图像
10-12
benchmark函数的基本介绍 MATLAB图像 6个基本函数 Schaffer、Griewank、Rastrigin、Ackley、Rosenbrock、Sphere
【生产调度】基于遗传算法求解柔性生产调度（FJSP）问题含Matlab源码
qq_59747472的博客
03-28 1117
1 简介 制造业同人们的生活密切联系,其发展走向可直接影响国家的综合实力。制造业企业不仅需要将制造技术走在科技前端,而且需要加强生产和经营管理技术,这样才能时刻保持其核心竞争力。而企业的调度是企业管理的核心和难点。生产调度的制定,作为制造业生产运作管理的最重要的任务,其结果强烈影响着企业的利润取得、资源的利用效率及产品能否准时交货等。在实际生产环境中,柔性作业车间调度问题(FJSP)允许所有工序可以在整个机器集中任意选择一台加工机器,这样的生产调度系统可以按照资源负荷情况灵活地分配资源,提高加工的灵活性,
遗传算法解决TSP问题笔记
pdcxs007的专栏
03-31 1822
今天看到了一个JS程序，源程序为：https://github.com/parano/GeneticAlgorithm-TSP，示例见： http://parano.github.io/GeneticAlgorithm-TSP/ 觉得这个程序写的非常好，仔细阅读源码之后，认真做了笔记，在此记录。
python启发式算法在benchmark中的运行，遗传算法...
jationh的博客
03-18 901
首先贴上遗传算法代码，如下： import numpy import random import time import sys from solution import solution def crossoverPopulaton(population, scores, popSize, crossoverProbability, keep): """ The crossover of all individuals Parameters ----------
遗传算法解决路线规划问题（Vehicle Routing Problem based on GA）
狂奔的蜗牛
09-26 2万+
I.问题描述 车辆路径问题（Vehicle Routing Problem,VRP），车辆路径问题是一种组合优化问题，它由Dantzig 和 Ramser在1959年共同提出。VRP是指一定数量的客户，各自有不同数量的货物需求，配送中心向客户提供货物，由一个车队负责分送货物，组织适当的行车路线，目标是使得客户的需求得到满足，并能在一定的约束下，达到诸如路程最短、成本最小、耗费时间最少等目的。VR...
遗传算法解决作业调用问题（classic job shop scheduling problem）
热门推荐
狂奔的蜗牛
01-14 2万+
车间作业调度问题描述 JSP问题是一个包含n个工件和m台机器的调度问题，其常用的数学描述如下： Cmax ≥ tij + pij for all (i,j) ∈ N tkj ≥ tij + pij for all (i,j)  (k,j) ∈ A tij ≥ tik + pik for all (i,j) and (i,k) ∈ N tik ≥ tij +
Structural analysis of fault isolability in the DAMADICS benchmark
qq_38304138的博客
03-23 2567
结构分析论文：Structural analysis of fault isolability in the DAMADICS benchmark
benchmark.rar_Benchmark函数_benchmark
07-15
benchmark 函数,matlab编程
LSGO.CEC08.Benchmark_CEC2008_Benchmark函数_
09-30
演化算法标准测试函数CEC2008
Benchmarks.zip_Benchmark函数_benchmark_benchmark functions_benchma
07-14
常用的智能优化算法的benchmark函数，供优化算法论文性能比较实用。
cv2读取和保存图片
最新发布
m0_53291740的博客
07-12 165
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 759
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1072
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 771
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
leetcode--验证二叉搜索树
liulanba的博客
07-09 667
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2558
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
benchmark函数
07-25
benchmark函数是用于测量代码性能的函数。它通常用于比较不同算法或实现的执行速度，以便找出最优的解决方案。benchmark函数会多次运行被测试的代码，并计算平均执行时间、内存使用等指标。这样可以提供客观的性能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值