粒子群算法（PSO）及函数可视化 | XDU人工智能概论大作业 | 源代码及pdf报告

完整代码及大作业PDF报告已开源上传在github:
基于粒子群算法对六个范例函数的最优化分析
欢迎STAR仓库⭐： 会持续更新
XDU_AI_homework

粒子更新规则基于粒子的当前位置、速度和历史最佳位置（个体最优）以及整个群体的最佳位置（全局最优）。更新规则通常由以下公式描述：

1. 更新速度：
   $$v_{id}(t+1)=w\cdot v_{id}(t)+c_1\cdot r_1\cdot (p_{id}-x_{id}(t))+c_2\cdot r_2\cdot (p_{gd}-x_{id}(t))$$

2. 更新位置：
   $$x_{id}(t+1)=x_{id}(t)+v_{id}(t+1)$$

其中，

• $v_{id}(t)是粒子i在维度d上的速度；$
• $x_{id}(t)是粒子i在维度d上的位置；$
• $p_{id}是粒子i历史上在维度d上的最佳位置（个体最优）；$
• $p_{gd}是整个群体历史上在维度d上的最佳位置（全局最优）；$
• $w是惯性权重，控制粒子保持上一时刻速度的程度；$
• $c_1和c_2是学习因子，分别控制个体经验和群体协作的影响；$
• $r_1和r_2是[0,1]范围内的随机数。$

大作业要求：
要求：选择一种计算智能方法（遗传算法、粒子群算法），利用C、Python或Matlab编程实现求解至少5个函数优化问题，进行仿真结果分析，并撰写报告，后附代码。目的是考察和培养学生对课程中讲授的计算智能方法的深入理解。
2 测试函数 从下列6个标准测试函数
(F01_{F06)中自选至少5个函数来测试算法求解无约束优化问题的性能。其中：F01}F03是单峰函数；F04~F06是多峰函数，其局部最优值的个数随着问题维数的增长而增长。实验中，测试函数的维数n统一设为2。（也可自拟测试问题，至少5个测试函数）

具体要求如下：

（一）报告的内容要求：

题目

作者信息及分工情况介绍（学号1， 姓名1，负责什么工作内容； 学号2， 姓名2，负责什么工作内容……
）（如果不分组，就直接写自己的信息即可）

（工作内容可以是查阅文献，编程，撰写报告等，工作量大的工作如编程或撰写报告，可以由多人共同完成。）

摘要（简要说明本报告实现了什么算法或方法，能够完成什么任务或解决什么问题，实验的效果怎样）

正文（先给出与实现内容相关的理论背景及知识，引出要完成的任务及采用的方法，之后对方法的具体实现进行详细说明，最好结合算法流程图等直观图示进行说明，最后给出图表等实验结果并进行相应的分析）

结论（对该程序系统的实验效果进行总结，指出优势，不足及可改进的方面）

参考文献（文献条目格式规范统一）

附录（附程序代码，关键语句进行必要注释。如果代码程序使用了一些网络上的资源，请务必在附录最后注明一下，哪些部分属于借鉴内容，哪些部分属于自己原创的工作）。

（二）报告的格式要求：

正文字体宋体，小四，行距：固定值20磅。其他格式细节自行设置，力求简洁美观。

（三）完成及提交方式

根据分组情况，各队内的同学合作完成。每队提交一份报告，不同队之间务必独立完成，避免雷同。

需要提交的内容：

1）源程序

2）报告（word版和PDF版各一份）

提交截止时间：2023年12月30日23:00。

1.作者

学号：2100XXXXX

姓名：游XX

单人组队

语言：Python

created：2023/12/18

源代码介绍：

• PSO.py为粒子群算法的具体实现方法
• test.py调用PSO.py对六个范例函数进行了测试
• Test_Function.ipynb为使用matlibplot库绘制了六个函数的三维图

2.摘要

本实验基于粒子群算法（PSO）实现了对六个无约束优化问题的求解，选定了包括单峰函数和多峰函数在内的六个标准测试函数。实验中使用Python编程语言，通过PSO算法优化寻找这些函数的最优解。实验结果显示，PSO算法在不同性质的函数上表现出色，找到了相对较好的最优解。通过详细的结果分析，我们发现PSO对于对称性、多峰性等特性的函数都表现良好，对不同问题的优化都具有一定的一致性。

实验还展示了对PSO算法参数的初步选择，但强调了在实际应用中可能需要更进一步的参数调优。实验结果为进一步研究和优化PSO算法提供了基础，并突显了PSO算法在解决无约束优化问题上的可行性和潜力。这种实验设计和结果分析有助于深化对计算智能方法的理解，并为未来算法调优和实际问题应用提供了有益的参考。

3.正文

3.1问题描述

要求：选择一种计算智能方法（遗传算法、粒子群算法），利用C、Python或Matlab编程实现求解至少5个函数优化问题，进行仿真结果分析，并撰写报告，后附代码。目的是考察和培养学生对课程中讲授的计算智能方法的深入理解。

测试函数

从下列6个标准测试函数 (F01-F06)中自选至少5个函数来测试算法求解无约束优化问题的性能。其中：F01-F03是单峰函数；F04-F06是多峰函数，其局部最优值的个数随着问题维数的增长而增长。实验中，测试函数的维数n统一设为2。（也可自拟测试问题，至少5个测试函数）

3.2函数分析

六个范例函数如下所示：
$$\begin{array}{rl}& 1.f(x)=\sum _{i=1}^n{x}_i^2\\ & 2.f(x)=\sum _{i=1}^n\left|x_i\right|+\prod _{i=1}^n\left|x_i\right|\\ & 3.f(x)=\sum _{i=1}^n{\left(\sum _{j=1}^i{x}_j\right)}^2\\ & 4.f(x)=\sum _{i=1}^n\left(-x_i\sin \left(\sqrt{\left|x_i\right|}\right)\right)\\ & 5.f(x)=\sum _{i=1}^n\left[x_i^2-10\cos \left(2\pi x_i\right)+10\right]\\ & 6.f(x)=20\left[1-\exp \left(-0.2\sqrt{\frac{1}{n}\sum _{i=1}^n{x}_i^2}\right)\right]+\exp (1)-\exp \left(\frac{1}{n}\sum _{i=1}^n\cos 2\pi x_i\right)\end{array}$$
根据题干所示，n默认设置为2。

3.2.1 Quadratic Function

$$f(x)=\sum _{i=1}^n{x}_i^2$$

这是一个简单的二次函数，即每个元素的平方和。这种函数通常用于优化问题和数学建模。

def quadratic_function(X_min=-15, X_max=15, Y_min=-15, Y_max=15):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = X**2 + Y**2
    return X, Y, Z, 400, "Quadratic Function"
#%%
z_min=None
X, Y, Z, z_max, title = quadratic_function()
draw_pic(X, Y, Z, z_max, title, z_min)

使用python绘制出该函数的二次形式图像如下所示：

可以看出该图像比较简单。

3.2.2 Schwefel’s Problem 2.21 Function

$$f(x)=\sum _{i=1}^n\left|x_i\right|+\prod _{i=1}^n\left|x_i\right|$$

这是Schwefel函数家族的一部分，其中包含了绝对值和元素的乘积。这类函数在全局优化问题中经常用于测试优化算法。

def schwefel_2_21_function(X_min=-10, X_max=10, Y_min=-10, Y_max=10):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = np.abs(X) + np.abs(Y) + np.abs(X)*np.abs(Y)
    return X, Y, Z, 200, "Schwefel's Problem 2.21 Function"
#%%
z_min=None
X, Y, Z, z_max, title = schwefel_2_21_function()
draw_pic(X, Y, Z, z_max, title, z_min)

使用python绘制出该函数的二次形式图像如下所示：

也印证题干所描述的单峰函数的特征。

3.2.3 Brown’s Almost-Linear Function

$$f(x)=\sum _{i=1}^n{\left(\sum _{j=1}^i{x}_j\right)}^2$$

这是一个具有几乎线性性质的函数，其中每个元素是其前面所有元素的累积和。这也是一个用于测试优化算法的标准函数。

令$n=2$：

当 (n=2) 时，将 $f(x)$ 展开为更具体的形式。首先，考虑 $x=(x_1,x_2)$：

$$f(x)={\left(\sum _{j=1}^1{x}_j\right)}^2+{\left(\sum _{j=1}^2{x}_j\right)}^2$$
现在，逐步计算这个表达式：

$f(x)=x_1^2+(x_1+x_2{)}^2$

展开平方项：

$f(x)=x_1^2+(x_1^2+2x_1{x}_2+x_2^2)$

将项合并：

$f(x)=2x_1^2+2x_1{x}_2+x_2^2$

因此，$当n=2时，f(x)的展开形式为：$

$$f(x)=2x_1^2+2x_1{x}_2+x_2^2$$
这是一个关于 $x_1$ 和 $x_2$ 的二次型（二次多项式）函数。这样的形式在数学和优化领域中是相当常见的。

def brown_almost_linear_function(X_min=-20, X_max=20, Y_min=-20, Y_max=20):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = X**2+2*X*Y+Y**2
    return X, Y, Z,2000, "Brown's Almost-Linear Function"
#%%
z_min=None
X, Y, Z, z_max, title = brown_almost_linear_function()
draw_pic(X, Y, Z, z_max, title, z_min)

使用python绘制出该函数的二次形式图像如下所示：

3.2.4 Rastrigin Function

Rastrigin函数是一个用于全局优化问题的经典非凸函数。它包含了正弦函数和平方根，形成了复杂的结构。
$$f(x)=\sum _{i=1}^n\left(-x_i\sin \left(\sqrt{\left|x_i\right|}\right)\right)$$

def rastrigin_function(X_min=-50, X_max=50, Y_min=-50, Y_max=50):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = -X * np.sin(np.sqrt(np.abs(X))) -Y * np.sin(np.sqrt(np.abs(Y)))
    return X, Y, Z, 100, "rastrigin Function"
#%%
z_min=None
X, Y, Z, z_max, title = rastrigin_function()
draw_pic(X, Y, Z, z_max, title, z_min)

使用python绘制出该函数的二次形式图像如下所示：

3.2.5 Ackley Function

$$f(x)=\sum _{i=1}^n\left[x_i^2-10\cos \left(2\pi x_i\right)+10\right]$$

Ackley函数是另一个用于优化问题的经典函数。它包含了平方项、余弦函数和常数，具有平坦而广泛的谷底，对于优化算法的测试具有挑战性。

def ackley_function(X_min=-20, X_max=20, Y_min=-20, Y_max=20):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = X**2 - 10 * np.cos(2 * np.pi * X) + 10 + Y**2 - 10 * np.cos(2 * np.pi * Y) + 10
    return X, Y, Z,1000, "Ackley Function"
#%%
z_min=None
X, Y, Z, z_max, title = ackley_function()
draw_pic(X, Y, Z, z_max, title, z_min)

使用python绘制的图像如下所示：

可以看出该函数含有大量的峰与尖刺，即局部最优解，这对优化算法提出了挑战。

3.2.6 Sum of Different Powers Function

$$f(x)=20\left[1-\exp \left(-0.2\sqrt{\frac{1}{n}\sum _{i=1}^n{x}_i^2}\right)\right]+\exp (1)-\exp \left(\frac{1}{n}\sum _{i=1}^n\cos 2\pi x_i\right)$$

这是一个包含指数、平方根和余弦的函数，通常用于优化算法的测试。它的设计使得函数在高维空间中具有多个局部极小值，是优化问题的有趣挑战。

def sum_of_different_powers_function(X_min=-20, X_max=20, Y_min=-20, Y_max=20):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    n = 2
    term1 = 20 * (1 - np.exp(-0.2 * np.sqrt((X**2+Y**2)/ n)))
    term2 = np.exp(1) - np.exp((np.cos(2 * np.pi * X) + np.cos(2 * np.pi * Y))/ n)

    Z = term1 + term2
    return X, Y, Z,25, "Sum of Different Powers Function"
#%%
z_min=None
X, Y, Z, z_max, title = sum_of_different_powers_function()
draw_pic(X, Y, Z, z_max, title, z_min)

3.3 粒子群算法介绍

粒子群算法（Particle Swarm Optimization，PSO）是一种基于群体智能的优化算法，源于对鸟群和鱼群等社会性群体行为的模拟。该算法通过模拟群体中个体之间的合作与竞争关系来寻找问题的最优解。在PSO中，候选解被表示为群体中的“粒子”，这些粒子通过在解空间中移动来寻找最优解。

下面是粒子群算法的基本思想和相关数学公式：

3.3.1 粒子的表示和初始化

每个粒子都表示解空间中的一个潜在解。在优化问题中，一个解通常是一个向量。粒子的位置表示该解的位置，速度表示粒子在解空间中的搜索方向和速度。

$假设有D维的问题，每个粒子i的位置表示为X_i=(x_{i1},x_{i2},...,x_{iD})，速度表示为V_i=(v_{i1},v_{i2},...,v_{iD})。$

3.3.2 适应度函数

PSO的目标是最小化或最大化一个适应度函数，通常用 f(X)表示。这个函数是待优化问题的目标函数。

3.3.3 粒子更新规则

粒子更新规则基于粒子的当前位置、速度和历史最佳位置（个体最优）以及整个群体的最佳位置（全局最优）。更新规则通常由以下公式描述：

1. 更新速度：
   $$v_{id}(t+1)=w\cdot v_{id}(t)+c_1\cdot r_1\cdot (p_{id}-x_{id}(t))+c_2\cdot r_2\cdot (p_{gd}-x_{id}(t))$$

2. 更新位置：
   $$x_{id}(t+1)=x_{id}(t)+v_{id}(t+1)$$

其中，

• $v_{id}(t)是粒子i在维度d上的速度；$
• $x_{id}(t)是粒子i在维度d上的位置；$
• $p_{id}是粒子i历史上在维度d上的最佳位置（个体最优）；$
• $p_{gd}是整个群体历史上在维度d上的最佳位置（全局最优）；$
• $w是惯性权重，控制粒子保持上一时刻速度的程度；$
• $c_1和c_2是学习因子，分别控制个体经验和群体协作的影响；$
• $r_1和r_2是[0,1]范围内的随机数。$

3.3.4 算法流程

1. 初始化群体中每个粒子的位置和速度。
2. 对于每个粒子，计算其适应度值。
3. 更新粒子的速度和位置。
4. 更新个体最优位置和全局最优位置。
5. 重复步骤2至4，直到满足停止条件（如迭代次数达到预定值或适应度值足够小）。

粒子群算法的优点在于其简单性和易于实现，但它的性能也受到参数的选择和问题的特性影响。调整惯性权重和学习因子等参数对算法的性能具有重要影响。

class PSO:
    def __init__(self, dim, size, iter_num, x_max, max_vel, best_fitness_value=float('Inf'), C1=2, C2=2, W=1):
        self.C1 = C1
        self.C2 = C2
        self.W = W
        self.dim = dim  # 粒子的维度
        self.size = size  # 粒子个数
        self.iter_num = iter_num  # 迭代次数
        self.x_max = x_max
        self.max_vel = max_vel  # 粒子最大速度
        self.best_fitness_value = best_fitness_value
        self.best_position = [0.0 for i in range(dim)]  # 种群最优位置
        self.fitness_val_list = []  # 每次迭代最优适应值
        self.avg_fitness_values = []  # 存储每一代适应度的平均值
        self.worst_fitness_values = []  # 存储每一代适应度的最差值

        # 对种群进行初始化
        self.Particle_list = [Particle(self.x_max, self.max_vel, self.dim) for i in range(self.size)]

    def set_bestFitnessValue(self, value):
        self.best_fitness_value = value

    def get_bestFitnessValue(self):
        return self.best_fitness_value

    def set_bestPosition(self, i, value):
        self.best_position[i] = value

    def get_bestPosition(self):
        return self.best_position

    # 更新速度
    def update_vel(self, part):
        for i in range(self.dim):
            vel_value = self.W * part.get_vel()[i] + self.C1 * random.random() * (part.get_best_pos()[i] - part.get_pos()[i]) \
                        + self.C2 * random.random() * (self.get_bestPosition()[i] - part.get_pos()[i])
            if vel_value > self.max_vel:
                vel_value = self.max_vel
            elif vel_value < -self.max_vel:
                vel_value = -self.max_vel
            part.set_vel(i, vel_value)

    # 更新位置
    def update_pos(self, part):
        for i in range(self.dim):
            pos_value = part.get_pos()[i] + part.get_vel()[i]
            part.set_pos(i, pos_value)
        value = fit_fun(part.get_pos())
        if value < part.get_fitness_value():
            part.set_fitness_value(value)
            for i in range(self.dim):
                part.set_best_pos(i, part.get_pos()[i])
        if value < self.get_bestFitnessValue():
            self.set_bestFitnessValue(value)
            for i in range(self.dim):
                self.set_bestPosition(i, part.get_pos()[i])
    def update(self):
        for i in range(self.iter_num):
            current_fitness_values = []  # 存储当前迭代的所有适应度值
            for part in self.Particle_list:
                self.update_vel(part)
                self.update_pos(part)
                current_fitness_values.append(fit_fun(part.get_pos()))  # 记录当前粒子的适应度值

            # 计算当前迭代的适应度统计值
            avg_fitness = np.mean(current_fitness_values)
            worst_fitness = np.max(current_fitness_values)

            self.avg_fitness_values.append(avg_fitness)
            self.worst_fitness_values.append(worst_fitness)

            # 更新全局最优适应值和位置
            best_fitness = np.min(current_fitness_values)
            best_index = np.argmin(current_fitness_values)
            if best_fitness < self.get_bestFitnessValue():
                self.set_bestFitnessValue(best_fitness)
                self.set_bestPosition(self.Particle_list[best_index].get_pos())

            self.fitness_val_list.append(self.get_bestFitnessValue())
        return self.fitness_val_list, self.get_bestPosition(), self.avg_fitness_values, self.worst_fitness_values

3.4 结果分析

对每一个函数都进行PSO，并记录每一代的最优值，最差值，平均值，有利于后期可视化。

if __name__ == "__main__":
    functions=[quadratic_function,schwefel_2_21_function,brown_almost_linear_function,rastrigin_function,ackley_function,sum_of_different_powers_function]

    for idx, func in enumerate(functions, start=1):
        print(f"\nExecuting Function {idx}: {func.__name__}")
        fit_fun = func
        pso = PSO(dim, size, iter_num, x_max, max_vel)
        fit_var_list1, best_pos1 ,avg_fitness_values_list,worst_fitness_values_list= pso.update()
        print("PSO最优位置:" + str(best_pos1))
        print("PSO最优解:" + str(fit_var_list1[-1]))
        fig = plt.figure(figsize=(10, 8))
        plt.plot(np.linspace(0, iter_num, iter_num), fit_var_list1, c="red", alpha=0.5, label="PSO_Best_Fitness")
        plt.plot(np.linspace(0, iter_num, iter_num), avg_fitness_values_list, c="green", alpha=0.5, label="PSO_Avg_Fitness")
        plt.plot(np.linspace(0, iter_num, iter_num), worst_fitness_values_list, c="blue", alpha=0.5,  label="PSO_Worst_Fitness")
        plt.legend()  # 显示lebel
        plt.title(f"{idx}: Fitness Evolution Over Iterations of %s" % func.__name__)
        plt.savefig("The Result of %s.png" % func.__name__,dpi=200)
        plt.show()

参数设置

超参数设置如下：

$$\begin{gathered} 粒子的维度dim=2 \\ 粒子个数size=10 \\ 迭代次数iter\_num=500 \\ 最大值x\_max=10 \\ 粒子最大速度max\_vel=0.05 \end{gathered}$$
（从结果来看，其实200代足矣）

结果可视化

得到如下结果：

3.4.1 Executing Function 1: quadratic_function

对函数
$$f(x)=\sum _{i=1}^n{x}_i^2$$
进行PSO分析之后得到最优解：
$$\begin{gathered} PSO最优位置:[8.056786108168028,-9.663970457813294] \\ PSO最优解:-19.208468319992637 \end{gathered}$$
设置迭代次数为500次

函数为单峰函数，过于简单，在50代之前就达到了最优。

3.4.2 Executing Function 2: schwefel_2_21_function

对于函数：

$$f(x)=\sum _{i=1}^n\left|x_i\right|+\prod _{i=1}^n\left|x_i\right|$$
设置迭代次数为500次，进行PSO分析之后得到最优解：
$$\begin{gathered} PSO最优位置:[8.097561628226853,6.479855087879195] \\ PSO最优解:-9.504676407906327 \end{gathered}$$

同样的，在120代左右best_fitness不再变化。

3.4.3 Executing Function 3: brown_almost_linear_function

对于函数
$$f(x)=\sum _{i=1}^n{\left(\sum _{j=1}^i{x}_j\right)}^2$$
设置迭代次数为500次，进行PSO分析之后得到最优解：
$$
PSO最优位置:[8.05601917420108, -9.666095939915335]\

PSO最优解:-19.208469570554662
$$
可视化如下

同样也很容易找到了最优解。

3.4.4 Executing Function 4: rastrigin_function

Rastrigin函数是一个用于全局优化问题的经典非凸函数。它包含了正弦函数和平方根，形成了复杂的结构。
$$f(x)=\sum _{i=1}^n\left(-x_i\sin \left(\sqrt{\left|x_i\right|}\right)\right)$$

def rastrigin_function(X_min=-50, X_max=50, Y_min=-50, Y_max=50):
    X, Y = get_X_AND_Y(X_min, X_max, Y_min, Y_max)
    Z = -X * np.sin(np.sqrt(np.abs(X))) -Y * np.sin(np.sqrt(np.abs(Y)))
    return X, Y, Z, 100, "rastrigin Function"
#%%
z_min=None
X, Y, Z, z_max, title = rastrigin_function()
draw_pic(X, Y, Z, z_max, title, z_min)

设置迭代次数为500次，进行PSO分析之后得到最优解：
$$\begin{gathered} PSO最优位置:[8.054819498769097,9.66463340986527] \\ PSO最优解:-19.2085021408069 \end{gathered}$$
可视化如下

3.4.5 Executing Function 5: ackley_function

Ackley函数是另一个用于优化问题的经典函数。它包含了平方项、余弦函数和常数，具有平坦而广泛的谷底，对于优化算法的测试具有挑战性。

$$f(x)=\sum _{i=1}^n\left[x_i^2-10\cos \left(2\pi x_i\right)+10\right]$$

设置迭代次数为500次，进行PSO分析之后得到最优解：
$$\begin{gathered} PSO最优位置:[8.096437231802385,-6.480112877146008] \\ PSO最优解:-9.50466874707662 \end{gathered}$$
可视化如下：

3.4.6 Executing Function 6: sum_of_different_powers_function

$$f(x)=20\left[1-\exp \left(-0.2\sqrt{\frac{1}{n}\sum _{i=1}^n{x}_i^2}\right)\right]+\exp (1)-\exp \left(\frac{1}{n}\sum _{i=1}^n\cos 2\pi x_i\right)$$

这是一个包含指数、平方根和余弦的函数，通常用于优化算法的测试。它的设计使得函数在高维空间中具有多个局部极小值，是优化问题的有趣挑战。

设置迭代次数为500次，进行PSO分析之后得到最优解：
$$\begin{gathered} PSO最优位置:[4.8532280877206,-9.701803691383306] \\ PSO最优解:-11.069548394827738 \end{gathered}$$
可视化如下：

4 总结

1. 性能一致性： PSO算法在不同测试函数上都找到了相对较好的最优解，显示出在无约束优化问题上的一致性和可靠性。
2. 对称性： 观察到对称函数（如F05和F06）的最优位置在坐标轴附近，这与问题的对称性一致。
3. 多峰函数： PSO在多峰函数（如F04、F05、F06）上也表现出色，成功找到了不同局部最优解。
4. 参数选择： 实验中采用的PSO参数（粒子个数、迭代次数、最大速度等）可能需要根据不同函数的特性进行调优，以进一步提升算法性能。这里为了方便起见，采用了同样的超参数。
5. 进一步研究： 结果表明PSO在处理不同性质的函数时都表现出良好的搜索能力，为进一步研究和优化PSO算法提供了基础。同时在处理单峰函数一般比多峰函数更快找到最优解，这也符合我们的认知。

通过本次实验，我不仅在计算智能方法中深入理解了粒子群算法（PSO），还通过图像绘制的实践学到了更多关于函数特性和问题可视化的技能。在PSO算法的实际应用中，通过选择不同的测试函数，我进一步了解了算法在不同情境下的性能表现。

实验中，通过编写PSO算法和图像绘制函数，我不仅提高了对PSO算法原理和应用的理解，还学到了如何将实验结果通过图像呈现，使得问题的特性更加直观。图像的绘制不仅帮助了对测试函数特性的深入理解，也在实验报告中提供了更具说服力的结果展示。

F05、F06）上也表现出色，成功找到了不同局部最优解。
4. 参数选择： 实验中采用的PSO参数（粒子个数、迭代次数、最大速度等）可能需要根据不同函数的特性进行调优，以进一步提升算法性能。这里为了方便起见，采用了同样的超参数。
5. 进一步研究： 结果表明PSO在处理不同性质的函数时都表现出良好的搜索能力，为进一步研究和优化PSO算法提供了基础。同时在处理单峰函数一般比多峰函数更快找到最优解，这也符合我们的认知。

通过本次实验，我不仅在计算智能方法中深入理解了粒子群算法（PSO），还通过图像绘制的实践学到了更多关于函数特性和问题可视化的技能。在PSO算法的实际应用中，通过选择不同的测试函数，我进一步了解了算法在不同情境下的性能表现。

实验中，通过编写PSO算法和图像绘制函数，我不仅提高了对PSO算法原理和应用的理解，还学到了如何将实验结果通过图像呈现，使得问题的特性更加直观。图像的绘制不仅帮助了对测试函数特性的深入理解，也在实验报告中提供了更具说服力的结果展示。

总的来说，这次实验强化了我对PSO算法的理解，并为将来在计算智能领域的研究打下了基础。同时，图像绘制的实践也为我提供了更灵活、更直观地展示问题和结果的能力。这两方面的收获相辅相成，使我更全面地认识到计算智能方法在实际问题中的应用和可视化分析的重要性。

如有错误请不吝指正！
Thanks