适应度函数

已于 2023-09-10 16:49:06 修改
阅读量992 收藏 19
点赞数 2
分类专栏： python 算法 群智能算法学习 文章标签： python 数学建模 人工智能
于 2023-09-10 10:55:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39128405/article/details/132770007
版权

23个基准测试函数

优化算法常用的适应度函数

在这里插入图片描述

23个基准测试函数的图像

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

python版code

将23个基准测试函数封装成python库，并进行实例化、调用绘图函数。下面代码只需根据提示打印，输入想要绘制的函数名称或all, 即可绘制相应基准测试函数，并将生成的静态图保存至当前文件夹中的fig文件夹、动态图保存至gif文件夹。

# -*- coding: UTF-8 -*-
"""
    @IDE    : PyCharm
    @project: 23个基准函数绘制
    @file   ：plot_benchmark_functions.py
    @date   ：2023-09-09 1:37
    @Author : 十@八九
    @email  : 
"""
import os
import numpy as np
from matplotlib import pyplot as plt
import matplotlib.animation as animation


class PlotFunction:
    def __int__(self):
        self.select_func = None
        return

    def F1(self, X):
        Results = np.sum(X ** 2)
        return Results

    def F2(self, X):
        Results = np.sum(np.abs(X)) + np.prod(np.abs(X))
        return Results

    def F3(self, X):
        dim = X.shape[0]
        Results = 0
        for i in range(dim):
            Results = Results + np.sum(X[0:i + 1]) ** 2

        return Results

    def F4(self, X):
        Results = np.max(np.abs(X))

        return Results

    def F5(self, X):
        dim = X.shape[0]
        Results = np.sum(100 * (X[1:dim] - (X[0:dim - 1] ** 2)) ** 2 + (X[0:dim - 1] - 1) ** 2)

        return Results

    def F6(self, X):
        Results = np.sum(np.abs(X + 0.5) ** 2)

        return Results

    def F7(self, X):
        dim = X.shape[0]
        Temp = np.arange(1, dim + 1, 1)
        Results = np.sum(Temp * (X ** 4)) + np.random.random()

        return Results

    def F8(self, X):
        Results = np.sum(-X * np.sin(np.sqrt(np.abs(X))))

        return Results

    def F9(self, X):
        dim = X.shape[0]
        Results = np.sum(X ** 2 - 10 * np.cos(2 * np.pi * X)) + 10 * dim

        return Results

    def F10(self, X):
        dim = X.shape[0]
        Results = -20 * np.exp(-0.2 * np.sqrt(np.sum(X ** 2) / dim)) - np.exp(
            np.sum(np.cos(2 * np.pi * X)) / dim) + 20 + np.exp(1)

        return Results

    def F11(self, X):
        dim = X.shape[0]
        Temp = np.arange(1, dim, 1)
        Results = np.sum(X ** 2) / 4000 - np.prod(np.cos(X / np.sqrt(Temp))) + 1

        return Results

    def Ufun(self, x, a, k, m):
        Results = k * ((x - a) ** m) * (x > a) + k * ((-x - a) ** m) * (x < -a)
        return Results

    def F12(self, X):
        dim = X.shape[0]
        Results = (np.pi / dim) * (10 * ((np.sin(np.pi * (1 + (X[0] + 1) / 4))) ** 2) + \
                                   np.sum(((X[0:dim - 1] + 1) / 4) ** 2) * (
                                           1 + 10 * ((np.sin(np.pi * (1 + X[1:dim] + 1) / 4)) ** 2)) + \
                                   ((X[dim - 1] + 1) / 4) ** 2) + np.sum(self.Ufun(X, 10, 100, 4))

        return Results

    def F13(self, X):
        dim = X.shape[0]
        Results = 0.1 * ((np.sin(3 * np.pi * X[0])) ** 2 + np.sum(
            (X[0:dim - 1] - 1) ** 2 * (1 + (np.sin(3 * np.pi * X[1:dim])) ** 2)) + \
                         ((X[dim - 1] - 1) ** 2) * (1 + (np.sin(2 * np.pi * X[dim - 1])) ** 2)) + np.sum(
            self.Ufun(X, 5, 100, 4))

        return Results

    def F14(self, X):
        aS = np.array(
            [[-32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32], \
             [-32, -32, -32, -32, -32, -16, -16, -16, -16, -16, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 32, 32, 32, 32, 32]])
        bS = np.zeros(25)
        for i in range(25):
            bS[i] = np.sum((X - aS[:, i]) ** 6)
        Temp = np.arange(1, 26, 1)
        Results = (1 / 500 + np.sum(1 / (Temp + bS))) ** (-1)

        return Results

    def F15(self, X):
        aK = np.array([0.1957, 0.1947, 0.1735, 0.16, 0.0844, 0.0627, 0.0456, 0.0342, 0.0323, 0.0235, 0.0246])
        bK = np.array([0.25, 0.5, 1, 2, 4, 6, 8, 10, 12, 14, 16])
        bK = 1 / bK
        Results = np.sum((aK - ((X[0] * (bK ** 2 + X[1] * bK)) / (bK ** 2 + X[2] * bK + X[3]))) ** 2)

        return Results

    def F16(self, X):
        Results = 4 * (X[0] ** 2) - 2.1 * (X[0] ** 4) + (X[0] ** 6) / 3 + X[0] * X[1] - 4 * (X[1] ** 2) + 4 * (
                X[1] ** 4)
        return Results

    def F17(self, X):
        Results = (X[1] - (X[0] ** 2) * 5.1 / (4 * (np.pi ** 2)) + (5 / np.pi) * X[0] - 6) ** 2 + 10 * (
                1 - 1 / (8 * np.pi)) * np.cos(X[0]) + 10
        return Results

    def F18(self, X):
        Results = (1 + (X[0] + X[1] + 1) ** 2 * (
                19 - 14 * X[0] + 3 * (X[0] ** 2) - 14 * X[1] + 6 * X[0] * X[1] + 3 * X[1] ** 2)) * \
                  (30 + (2 * X[0] - 3 * X[1]) ** 2 * (
                          18 - 32 * X[0] + 12 * (X[0] ** 2) + 48 * X[1] - 36 * X[0] * X[1] + 27 * (X[1] ** 2)))
        return Results

    def F19(self, X):
        aH = np.array([[3, 10, 30], [0.1, 10, 35], [3, 10, 30], [0.1, 10, 35]])
        cH = np.array([1, 1.2, 3, 3.2])
        pH = np.array(
            [[0.3689, 0.117, 0.2673], [0.4699, 0.4387, 0.747], [0.1091, 0.8732, 0.5547], [0.03815, 0.5743, 0.8828]])
        Results = 0
        for i in range(4):
            Results = Results - cH[i] * np.exp(-(np.sum(aH[i, :] * ((X - pH[i, :])) ** 2)))
        return Results

    def F20(self, X):
        aH = np.array([[10, 3, 17, 3.5, 1.7, 8], [0.05, 10, 17, 0.1, 8, 14], [3, 3.5, 1.7, 10, 17, 8],
                       [17, 8, 0.05, 10, 0.1, 14]])
        cH = np.array([1, 1.2, 3, 3.2])
        pH = np.array(
            [[0.1312, 0.1696, 0.5569, 0.0124, 0.8283, 0.5886], [0.2329, 0.4135, 0.8307, 0.3736, 0.1004, 0.9991], \
             [0.2348, 0.1415, 0.3522, 0.2883, 0.3047, 0.6650], [0.4047, 0.8828, 0.8732, 0.5743, 0.1091, 0.0381]])
        Results = 0
        for i in range(4):
            Results = Results - cH[i] * np.exp(-(np.sum(aH[i, :] * ((X - pH[i, :])) ** 2)))
        return Results

    def F21(self, X):
        aSH = np.array([[4, 4, 4, 4], [1, 1, 1, 1], [8, 8, 8, 8], [6, 6, 6, 6], [3, 7, 3, 7], \
                        [2, 9, 2, 9], [5, 5, 3, 3], [8, 1, 8, 1], [6, 2, 6, 2], [7, 3.6, 7, 3.6]])
        cSH = np.array([0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5])
        Results = 0
        for i in range(5):
            Results = Results - (np.dot((X - aSH[i, :]), (X - aSH[i, :]).T) + cSH[i]) ** (-1)
        return Results

    def F22(self, X):
        aSH = np.array([[4, 4, 4, 4], [1, 1, 1, 1], [8, 8, 8, 8], [6, 6, 6, 6], [3, 7, 3, 7], \
                        [2, 9, 2, 9], [5, 5, 3, 3], [8, 1, 8, 1], [6, 2, 6, 2], [7, 3.6, 7, 3.6]])
        cSH = np.array([0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5])
        Results = 0
        for i in range(7):
            Results = Results - (np.dot((X - aSH[i, :]), (X - aSH[i, :]).T) + cSH[i]) ** (-1)
        return Results

    def F23(self, X):
        aSH = np.array([[4, 4, 4, 4], [1, 1, 1, 1], [8, 8, 8, 8], [6, 6, 6, 6], [3, 7, 3, 7], \
                        [2, 9, 2, 9], [5, 5, 3, 3], [8, 1, 8, 1], [6, 2, 6, 2], [7, 3.6, 7, 3.6]])
        cSH = np.array([0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5])
        Results = 0
        for i in range(10):
            Results = Results - (np.dot((X - aSH[i, :]), (X - aSH[i, :]).T) + cSH[i]) ** (-1)
        return Results

    def rotate(self, angle):
        self.ax.view_init(elev=30, azim=angle)

    def plot_save(self, func, x1_range=(0, 10, 0.5), x2_range=(0, 10, 0.5), function_name='F1'):
        fig = plt.figure(1)  # 定义figure
        # ax = Axes3D(fig)  # 将figure变为3d
        ax = plt.axes(projection='3d')
        self.ax = ax
        fig.add_axes(ax)
        x1 = np.arange(x1_range[0], x1_range[1], x1_range[2])
        x2 = np.arange(x2_range[0], x2_range[1], x2_range[2])
        X1, X2 = np.meshgrid(x1, x2)  # 生成网格
        nSize = x1.shape[0]
        Z = np.zeros([nSize, nSize])
        for i in range(nSize):
            for j in range(nSize):
                if function_name in ['F15', 'F16', 'F21', 'F22', 'F23']:
                    X = [X1[i, j], X2[i, j], 0, 0, ]
                elif function_name in ['F19']:
                    X = [X1[i, j], X2[i, j], 0]
                elif function_name in ['F20']:
                    X = [X1[i, j], X2[i, j], 0, 0, 0, 0]
                else:
                    X = [X1[i, j], X2[i, j]]  # 构造F23输入
                X = np.array(X)  # 将格式由list转换为array
                Z[i, j] = func(X)  # 计算F23的值
        # 绘制3D曲面
        # rstride:行之间的跨度  cstride:列之间的跨度
        # rstride:行之间的跨度  cstride:列之间的跨度
        # cmap参数可以控制三维曲面的颜色组合
        ax.plot_surface(X1, X2, Z, rstride=1, cstride=1, cmap=plt.get_cmap('rainbow'))
        ax.contour(X1, X2, Z, zdir='z', offset=-0.1)  # 绘制等高线
        ax.set_xlabel('X1')  # x轴说明
        ax.set_ylabel('X2')  # y轴说明
        ax.set_zlabel('Z')  # z轴说明
        ax.set_title(function_name + '_space')
        plt.savefig('./fig/' + function_name + '.png')
        anim = animation.FuncAnimation(fig, self.rotate, frames=range(0, 360, 10))
        anim.save('./gif/' + function_name + '.gif', writer='pillow', fps=30)
        if select_func == 'all':
            plt.pause(5)
            plt.close()
        else:
            plt.show()
        return

    def selectFunc(self, func_str='F1', x1_range=(0, 10, 0.5), x2_range=(0, 10, 0.5), function_name='F1'):
        if func_str == 'F1':
            self.plot_save(self.F1, x1_range=(-100, 100, 2), x2_range=(-100, 100, 2), function_name='F1')
        elif func_str == 'F2':
            self.plot_save(self.F2, x1_range=(-10, 10, 0.2), x2_range=(-10, 10, 0.2), function_name='F2')
        elif func_str == 'F3':
            self.plot_save(self.F3, x1_range=(-100, 100, 2), x2_range=(-100, 100, 2), function_name='F3')
        elif func_str == 'F4':
            self.plot_save(self.F4, x1_range=(-100, 100, 2), x2_range=(-100, 100, 2), function_name='F4')
        elif func_str == 'F5':
            self.plot_save(self.F5, x1_range=(-30, 30, 2), x2_range=(-30, 30, 2), function_name='F5')
        elif func_str == 'F6':
            self.plot_save(self.F6, x1_range=(-100, 100, 2), x2_range=(-100, 100, 2), function_name='F6')
        elif func_str == 'F7':
            self.plot_save(self.F7, x1_range=(-1.28, 1.28, 0.02), x2_range=(-1.28, 1.28, 0.02), function_name='F7')
        elif func_str == 'F8':
            self.plot_save(self.F8, x1_range=(-500, 500, 10), x2_range=(-500, 500, 10), function_name='F8')
        elif func_str == 'F9':
            self.plot_save(self.F9, x1_range=(-5.12, 5.12, 0.2), x2_range=(-5.12, 5.12, 0.2), function_name='F9')
        elif func_str == 'F10':
            self.plot_save(self.F10, x1_range=(-30, 30, 0.5), x2_range=(-30, 30, 0.5), function_name='F10')
        elif func_str == 'F11':
            self.plot_save(self.F11, x1_range=(-600, 600, 5), x2_range=(-600, 600, 5), function_name='F11')
        elif func_str == 'F12':
            self.plot_save(self.F12, x1_range=(-50, 50, 1), x2_range=(-50, 50, 1), function_name='F12')
        elif func_str == 'F13':
            self.plot_save(self.F13, x1_range=(-50, 50, 1), x2_range=(-50, 50, 1), function_name='F13')
        elif func_str == 'F14':
            self.plot_save(self.F14, x1_range=(-65, 65, 2), x2_range=(-65, 65, 2), function_name='F14')
        elif func_str == 'F15':
            self.plot_save(self.F15, x1_range=(-5, 5, 0.2), x2_range=(-5, 5, 0.2), function_name='F15')
        elif func_str == 'F16':
            self.plot_save(self.F16, x1_range=(-5, 5, 0.2), x2_range=(-5, 5, 0.2), function_name='F16')
        elif func_str == 'F17':
            self.plot_save(self.F17, x1_range=(-5, 5, 0.2), x2_range=(-5, 5, 0.2), function_name='F17')
        elif func_str == 'F18':
            self.plot_save(self.F18, x1_range=(-2, 2, 0.1), x2_range=(-2, 2, 0.1), function_name='F18')
        elif func_str == 'F19':
            self.plot_save(self.F19, x1_range=(1, 3, 0.1), x2_range=(1, 3, 0.1), function_name='F19')
        elif func_str == 'F20':
            self.plot_save(self.F20, x1_range=(0, 1, 0.05), x2_range=(0, 1, 0.05), function_name='F20')
        elif func_str == 'F21':
            self.plot_save(self.F21, x1_range=(0, 10, 0.5), x2_range=(0, 10, 0.5), function_name='F21')
        elif func_str == 'F22':
            self.plot_save(self.F22, x1_range=(0, 10, 0.5), x2_range=(0, 10, 0.5), function_name='F22')
        elif func_str == 'F23':
            self.plot_save(self.F22, x1_range=(0, 10, 0.5), x2_range=(0, 10, 0.5), function_name='F23')
        return


if __name__ == '__main__':
    dir_fig = "./fig"
    if not os.path.exists(dir_fig):
        os.makedirs(dir_fig)
    dir_gif = "./gif"
    if not os.path.exists(dir_gif):
        os.makedirs(dir_gif)
    print("23 benchmark functions:")
    func_name = ['F' + str(i) for i in range(1, 24, 1)]
    func_str = ',  '.join(func_name) + ',  all'
    print(func_str)
    select_func = input("Please select one of the above functions and enter it:")
    plotFunction_o = PlotFunction()
    if select_func == 'all':
        for func in func_name:
            plotFunction_o.selectFunc(func)
    else:
        plotFunction_o.selectFunc(select_func)

将以上代码打包为exe

新建文件夹，如 23 benchmark functions， 路径中不要含有中文
在cmd窗口中打开该文件夹，
输入：pip install pipenv
输入：pipenv shell

在这里插入图片描述
输入：pip install pyinstaller
pip install numpy
pip install matplotlib
打包成.exe: pyinstaller -F --distpath Release/ -c --clean plot_benchmark_functions.py

十@八九
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
遗传算法的适应度函数构造
12-07
从基本遗传算法所遇到的一些问题，讲解遗传算法中适应度函数的作用，以及解决这些问题所需的适应度函数。 包括常见的适应度函数，适应度函数的尺度变换，以及一些适应度函数的改进算法。
【全力以送】CEEMDAN的参数优化：4种适应度函数（matlab代码）
最新发布
weixin_44028734的博客
03-18 1010
前期已经分享，本期推出完全自适应噪声集合经验模态分解（CEEMDAN，)的参数优化方法。CEEMDAN于2011年发表，至今已有1700多次引用，虽不如VMD火热，但效果不比VMD差。CEEMDAN在一定程度上解决了EMD、EEMD的模态混叠问题，然而，CEEMDAN的性能受到其参数的影响，尤其是。手动调参是繁琐的、不经济的。研究者们通过设置合理的，利用群智能优化算法对其参数进行自适应的选择。本期介绍4种。
粒子群算法的几个适应度评价函数
兔清风的博客
08-27 3万+
下面给出几个适应度评价函数，并给出图形表示   第一个函数：Griewank函数，图形如下所示： 适应度函数如下：（为了求最大值，我去了所有函数值的相反数）   function y = Griewank(x) % Griewan函数 % 输入x,给出相应的y值,在x = ( 0 , 0 ,…, 0 )处有全局极小点0. % 编制人： % 编制日期： [r
GA/GP中的适应度函数
kaichao的专栏
06-09 7438
进化算法GA/GP中，适应度函数对进化方向有重要影响，也是影响运行效率的关键因素。
matlab中适应度函数怎么编写,matlab常用的几个适应度评价函数
weixin_39968946的博客
03-20 3837
/article/details/1619496粒子群算法(6)-----几个适应度评价函数下面给出几个适应度评价函数，并给出图形表示头几天机子种了病毒，重新安装了系统，不小心把程序全部格式化了，痛哭！！！没办法，好多程序不见了，现在把这几个典型的函数重新编写了，把他们给出来，就算粒子群算法的一个结束吧！痛恨病毒！！！！第一个函数：Griewank函数，图形如下所示：适应度函数如下：(为了求最大值...
基于matlab的适应度曲线的代码,[求助]适应度函数的编写
weixin_31140863的博客
03-19 750
现在算衔接成本的程序是csj=[1,0,1,0,0,0,1,0,0,1,0,0,0,0;0,1,1,0,0,0,0,1,0,0,0,1,0,0;1,0,0,1,0,0,0,1,0,1,0,0,0,0;0,1,0,0,0,1,1,0,0,0,0,0,1,0;0,1,0,1,0,0,1,0,0,0,0,0,0,1;1,0,1,0,0,0,1,0,0,0,1,0,0,0;0,1,0,1,0,0,...
PSO.zip_适应度函数
09-24
**适应度函数在粒子群优化（PSO）中的作用** 粒子群优化（PSO）是一种模拟自然界中鸟群飞行行为的全局优化算法，由Eberhart和Kennedy于1995年提出。在PSO算法中，每个解被称为一个“粒子”，粒子在问题的解空间中...
遗传算法目标函数、适应度函数与遗传算法工具箱简介.pdf
09-12
在遗传算法中，目标函数和适应度函数扮演着至关重要的角色。 目标函数（Objective Function）是遗传算法的核心，它定义了我们想要优化的问题。目标函数可以是寻找函数的最大值或最小值，例如在工程设计中的最小化...
PE_排列熵_适应度函数_pe熵_
09-30
在IT领域，尤其是在数据分析、机器学习以及算法优化中，"PE_排列熵_适应度函数_pe熵_"这一主题涉及到一些核心概念和技术。排列熵（Permutation Entropy, PE）是一种衡量序列复杂性和有序程度的统计量，常用于信号...
fitness.rar_fitness函数_适应度函数
07-13
在机器学习和优化算法中，"fitness function"（适应度函数）扮演着至关重要的角色。适应度函数是评价一个解决方案或个体在特定问题中的“优劣”程度的标准，它为进化算法、遗传算法、粒子群优化等搜索算法提供了一个...
FDO适应度优化算法_FDO适应度优化算法_适应度函数_最优化算法_
10-03
适应度函数(Fitness Function)的选取直接影响到遗传算法的收敛速度以及能否找到最优解
matlab粒子群适应度函数代码-2016_NatComms_urgency:选自Murphy，Boonstra和Nieuwenhuis（20
05-28
matlab粒子群适应度函数代码选自以下代码：Murphy，Boonstra和Nieuwenhuis（2016）。 全局增益调制在人类的感知选择过程中产生与时间有关的紧迫性， Nature Communications ，7：13526。 内容 CAF_fitting：Matlab函数将分段逻辑条件精度函数拟合为单次试验精度和响应时间数据（例如，在纸的面板c中）。 顶级功能是fit_CAF.m 。 DDM_reg：Matlab的功能是将“常规”漂移扩散模型（带有静态边界）拟合到选择/响应时间数据（例如，在纸的面板中）。 顶级函数是FIT_regular_DDM_PSO.m 。 通过粒子群优化（）进行的优化。 NB拟合方法与具有时间依赖性的紧迫性的模型拟合方法相匹配（见下文）； 因此，它在某些方面与典型的DDM拟合例程有所不同（例如，它以相对稀疏的间隔估算并通过内插来计算第一通过时间密度）。 如果仅需要常规DDM，则强烈建议使用其他方法（例如HDDM;）。 DDM_urg：Matlab的功能是使漂移扩散模型具有随时间变化的紧迫性（等效于塌陷边界）（例如，在纸面板ae中）。 顶级功能是FI
遗传算法适应度函数
08-20
matlab平台 适应度函数的设计 作为寻优的依据
灰狼优化算法GWO，优化VMD，适应度函数为最小样本熵或最小包络熵（可自行选择，代码已集成好，很方便修改）包含MATLAB源代码
woaipythonmeme的博客
06-25 2757
灰狼优化算法优化VMD两个参数，考虑到大家有可能会以最小样本熵或最小包络熵为适应度函数的，在这个程序中将会直接把样本熵和包络熵集成，在代码中选择“1”代表包络熵，选择“2”代表样本熵，方便大家自由切换。
粒子群算法(6)-----几个适应度评价函数
热门推荐
niuyongjie的专栏
05-21 9万+
下面给出几个适应度评价函数，并给出图形表示      头几天机子种了病毒，重新安装了系统，不小心把程序全部格式化了，痛哭！！！没办法，好多程序不见了，现在把这几个典型的函数重新编写了，把他们给出来，就算粒子群算法的一个结束吧！痛恨病毒！！！！第一个函数：Griewank函数，图形如下所示：适应度函数如下：（为了求最大值，我去了所有函数值的相反数）
智能优化算法：适应度相关优化算法 - 附代码
Jack旭的博客
08-28 3874
智能优化算法：适应度相关优化算法 - 附代码 文章目录智能优化算法：适应度相关优化算法 - 附代码1.算法原理2.算法流程3.算法结果4.参考文献5.Matlab代码 摘要：Fitness DependentOptimizer（FDO）称为适应度相关优化器（FDO）于2019年被提出。受启发于蜂群繁殖过程及其集体决策过程；FDO被认为是一种基于粒子群优化（PSO）的算法，它通过增加速度（pace）来更新搜索代理的位置。然而，FDO计算速度的方式不同；它使用问题适应度函数值生成权重，这些权重在探索和开发阶段指
matlab自适应平滑,以信噪比为适应度函数的自适应粒子群优化算法Matlab Code 修改...
weixin_39906906的博客
03-16 247
本人最近写了一篇以信噪比为适应度函数的自适应粒子群优化算法Matlab Code，但是运行总是出错误，恳求哪位Matlab大神帮忙看看 修改修改，谢谢。信噪比SNR适应度函数：function SNR=fitness(x)N=20000;fs=20;h=1/fs;T=(0:N-1)*h;AL=0.1;fL=0.01;u=AL*sin(2*pi*fL.*T);D=0.5; %噪声强度ff=fs*...
matlab调用适应度函数
09-19
在使用Matlab调用适应度函数时，首先需要定义适应度函数的具体计算方法。适应度函数是评估染色体优劣的标准，它的值越大表示染色体的适应度越高。 我们可以将适应度函数定义为一个独立的函数文件，以便在其他程序中调用。在该函数中，我们可以根据具体的问题和优化目标设计适应度函数的计算逻辑。 在主程序中，我们需要引入适应度函数的代码，并将待优化的染色体作为参数输入。根据问题的具体情况，可能还需要传入其他参数，如目标函数的参数等。 调用适应度函数的方式可以有多种，最常见的方式是使用函数句柄或匿名函数。函数句柄可以将适应度函数赋值给一个变量，然后通过这个变量来调用适应度函数。匿名函数则可以直接定义适应度函数，并在调用时使用该匿名函数。 在调用适应度函数时，我们可以传入待优化的染色体，并接收返回的适应度值。这个适应度值可以用来评估染色体的优劣，并根据染色体的适应度进行选择、交叉和变异等遗传算法的操作。 总之，使用Matlab调用适应度函数需要先定义适应度函数的计算逻辑，然后在主程序中引入适应度函数的代码，并根据具体情况传入需要优化的染色体和其他参数。最后，通过调用适应度函数来获得染色体的适应度值，用于遗传算法的进一步操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值