关于标准PSO和基于高斯变异的PSO比较问题
请利用Python或者MATLAB制作一个表和一个图。表是在10次仿真结果下的标准PSO和基于高斯变异的PSO的四个参数大小的对比情况，分别是：最优值，最优值次数，平均值，标准差。图是标准PSO和基于高斯变异的PSO的适应度值变化情况。
标准PSO如下图：
惯性权重的计算式如下：
高斯变异表达式如下：
基于高斯变异的粒子位置更新如下：
粒子群算法的相关参数如下：最大迭代次数Tmax=50，种群规模M=100，学习因子C1=C2=2，惯性权重最大值=0.9，最小值=0.4。
提供小小示例代码，代码构思：将生成一个包含四个参数（最优值、最优值次数、平均值和标准差）的表格，以及一个显示标准PSO和基于高斯变异的PSO的适应度值变化的图形。你可以将模拟数据替换为自己的数据，并根据需要修改参数名称和图形标签等设置。
参考示例：
import numpy as np
import matplotlib.pyplot as plt
# 生成模拟数据
sim_results = np.random.rand(10, 4)
# 参数名称
param_names = ['最优值', '最优值次数', '平均值', '标准差']
# 创建表格
table_data = np.column_stack((param_names, sim_results[:, :-1].mean(axis=0), sim_results[:, 3]))
table = plt.table(cellText=table_data.flatten(), loc='best')
# 绘制图形
plt.plot(sim_results[:, 0], sim_results[:, 3], 'bo-', label='标准PSO')
plt.plot(sim_results[:, 1], sim_results[:, 3], 'go-', label='基于高斯变异的PSO')
plt.legend(loc='best')
plt.xlabel('迭代次数')
plt.ylabel('适应度值')
plt.show()
#如有帮助，恭请采纳
假设使用的数据保存在两个csv文件中（分别为"standard_pso.csv"和"gaussian_pso.csv"，并且为了方便读取数据使用了pandas库：
import pandas as pd
import matplotlib.pyplot as plt
# 读取数据
df_standard = pd.read_csv("standard_pso.csv")
df_gaussian = pd.read_csv("gaussian_pso.csv")
# 计算四个参数，并保存到列表中
standard_params = []
gaussian_params = []
for df, params in [(df_standard, standard_params), (df_gaussian, gaussian_params)]:
best_val = df['best_val'].max()
best_val_count = (df['best_val'] == best_val).sum()
mean_val = df['best_val'].mean()
std_val = df['best_val'].std()
params.append(best_val)
params.append(best_val_count)
params.append(mean_val)
params.append(std_val)
# 构建数据表
data = {
'Parameter': ["Best Value", "Best Value Count", "Mean Value", "Std Value"],
'Standard PSO': standard_params,
'Gaussian PSO': gaussian_params
}
df_table = pd.DataFrame(data)
# 输出表格
print(df_table)
# 绘制适应度值变化图
plt.plot(df_standard['iter'], df_standard['best_val'], label='Standard PSO')
plt.plot(df_gaussian['iter'], df_gaussian['best_val'], label='Gaussian PSO')
plt.xlabel('Iterations')
plt.ylabel('Fitness Value')
plt.title('Fitness Value Comparison')
plt.legend()
plt.show()
注意，上面代码中的两个csv文件需要包含"best_val"和"iter"两列数据，分别表示每一次迭代的最优适应度值和迭代次数。
如果使用MATLAB绘图，则可以使用类似下面的代码：
% 读取数据
standard_data = csvread('standard_pso.csv', 1, 0);
gaussian_data = csvread('gaussian_pso.csv', 1, 0);
% 计算四个参数，并保存到列表中
standard_params = [];
gaussian_params = [];
for df = [standard_data, gaussian_data]
best_val = max(df(:,1));
best_val_count = length(find(df(:,1)==best_val));
mean_val = mean(df(:,1));
std_val = std(df(:,1));
standard_params = [standard_params, best_val, best_val_count, mean_val, std_val];
gaussian_params = [gaussian_params, best_val, best_val_count, mean_val, std_val];
end
% 构建数据表
data = {
'Parameter', 'Standard PSO', 'Gaussian PSO';
'Best Value', standard_params(1), gaussian_params(1);
'Best Value Count', standard_params(2), gaussian_params(2);
'Mean Value', standard_params(3), gaussian_params(3);
'Std Value', standard_params(4), gaussian_params(4)
};
table(data)
% 绘制适应度值变化图
plot(standard_data(:,2), standard_data(:,1), 'b-', 'LineWidth', 1.5)
hold on
plot(gaussian_data(:,2), gaussian_data(:,1), 'r-', 'LineWidth', 1.5)
hold off
xlabel('Iterations')
ylabel('Fitness Value')
title('Fitness Value Comparison')
legend('Standard PSO', 'Gaussian PSO')
下面是一个使用Python Matplotlib库实现的示例代码，该代码实现了PSO算法参数对比的表格和折线图，供您参考：
import numpy as np
import matplotlib.pyplot as plt
# 生成10次仿真结果的数据
n = 100
max_iter = 100
result1 = np.zeros((n, 4))
result2 = np.zeros((n, 4))
for i in range(n):
# 运行标准PSO
"""
psolist1 = ...
"""
best1 = np.min(psolist1[:, -1])
idx1 = np.where(psolist1[:, -1] == best1)[0][0]
mean1 = np.mean(psolist1[:, -1])
std1 = np.std(psolist1[:, -1])
result1[i] = [best1, idx1, mean1, std1]
# 运行基于高斯变异的PSO
"""
psolist2 = ...
"""
best2 = np.min(psolist2[:, -1])
idx2 = np.where(psolist2[:, -1] == best2)[0][0]
mean2 = np.mean(psolist2[:, -1])
std2 = np.std(psolist2[:, -1])
result2[i] = [best2, idx2, mean2, std2]
# 绘制表格
headers = ['最优值', '最优值次数', '平均值', '标准差']
plt.subplot(1, 2, 1)
plt.table(cellText=result1, colLabels=headers, loc='center')
plt.title('标准PSO运行结果')
plt.subplot(1, 2, 2)
plt.table(cellText=result2, colLabels=headers, loc='center')
plt.title('基于高斯变异的PSO运行结果')
# 绘制适应度函数变化折线图
fit1 = psolist1[:, -1]
fit2 = psolist2[:, -1]
plt.figure()
plt.plot(range(max_iter), fit1, label='标准PSO')
plt.plot(range(max_iter), fit2, label='基于高斯变异的PSO')
plt.legend()
plt.xlabel('迭代次数')
plt.ylabel('适应度函数值')
plt.title('PSO算法运行适应度变化图')
plt.show()
在上述代码中，我们随机生成了10组仿真结果的数据，然后对两种不同的PSO算法进行了运行并计算了最优值、最优值次数、平均值、标准差等参数的值。接着，使用Matplotlib库的子图函数在同一张图中绘制表格，并使用另一张图绘制了标准PSO和基于高斯变异的PSO的适应度函数值变化曲线。需要注意的是，由于具体的PSO算法实现代码不在我们的讨论范围内，上述代码中的运行结果需要您根据实际情况进行相应的修改。
n (PSO)是一种全局优化方法，灵感来源于鸟群捕食行为。每个个体（也称粒子）根据自身经验和当前局部最优解来更新其位置和速度，直至整个群体达到全局最优解。 二、什么是变异因素？ 变异因素是指在PSO算法中加入一定的随机性来增加算法的多样性和搜索能力，通常使用高斯分布随机数产生变异因素。 三、基于高斯变异的PSO算法 基于高斯变异的PSO算法（MGPSO）是一种引入了变异因素的PSO算法，具体实现方法为：在标准PSO算法的基础上，对每个维度的速度进行的更新时，加入一定的随机变异因子与速度进行合成。其公式如下所示： V_ij(t+1) = w(t)V_ij(t) + c1r1(pbest_ij(t) - x_ij(t))+c2r2(gbest_j(t) - x_ij(t)) + sigma_iju_ij(t) 其中，sigma_ij为第i个粒子的第j维度的高斯变异因子，u_ij(t)为服从均值为0，方差为1的高斯分布的随机数，用于产生变异因子。 四、惯性权重的计算式 惯性权重w的计算式为： w(t) = w_max - t*(w_max - w_min)/Tmax 其中，w_max为惯性权重最大值，w_min为惯性权重最小值，Tmax为最大迭代次数，t为当前迭代次数。 五、代码实现（MATLAB）
清空环境变量和命令窗口
clc;
clear all;
定义迭代次数、种群大小、学习因子、惯性权重最大值、最小值、高斯变异标准差、随机数种子
Tmax = 50; %迭代次数
M = 100; %种群大小
c1 = 2; %学习因子1
c2 = 2; %学习因子2
w_max = 0.9; %惯性权重最大值
w_min = 0.4; %惯性权重最小值
sigma = 0.3; %高斯变异标准差
rand_seed = 1:10; %随机数种子
定义目标函数
f = @(x) x(1).^2 + x(2).^2;
初始化种群的位置和速度
for i=1:M
x(i,:) = randn(1,2); %初始位置
v(i,:) = randn(1,2); %初始速度
pbest(i,:) = x(i,:); %个体极值
end
[~,gbest_idx] = min(arrayfun(@(k) f(x(k,:)),1:M)); %全局极值的索引
gbest = x(gbest_idx,:); %全局极值
PSO算法迭代过程
for rnd_seed = rand_seed
rand('twister',rnd_seed); %设置随机数种子
for t=1:Tmax
w(t) = w_max - t*(w_max - w_min)/Tmax; %惯性权重的计算
for i=1:M
r1 = rand; r2 = rand;
sigma_i = sigma*randn(1,2); %个体的高斯变异因子
u_i = randn(1,2); %个体的随机数
v(i,:) = w(t)*v(i,:) + c1*r1*(pbest(i,:) - x(i,:)) + c2*r2*(gbest - x(i,:)) + sigma_i.*u_i; %速度更新
x(i,:) = x(i,:) + v(i,:); %位置更新
if f(x(i,:)) < f(pbest(i,:)) %更新个体极值
pbest(i,:) = x(i,:);
end
end
[~,gbest_idx] = min(arrayfun(@(k) f(x(k,:)),1:M)); %更新全局极值
gbest = x(gbest_idx,:);
end
%记录结果
end
计算四个参数的大小
best_soln = f(gbest); %最佳解
best_cnt = sum(arrayfun(@(k) f(x(k,:))==best_soln, 1:M)); %最佳解出现的次数
mean_soln = mean(arrayfun(@(k) f(x(k,:)), 1:M)); %平均值
std_soln = std(arrayfun(@(k) f(x(k,:)), 1:M)); %标准差
绘制适应度值变化情况图
for rnd_seed = rand_seed
rand('twister',rnd_seed);
for t=1:Tmax
w(t) = w_max - t*(w_max - w_min)/Tmax;
for i=1:M
r1 = rand; r2 = rand;
sigma_i = sigma*randn(1,2);
u_i = randn(1,2);
v(i,:) = w(t)*v(i,:) + c1*r1*(pbest(i,:) - x(i,:)) + c2*r2*(gbest - x(i,:)) + sigma_i.*u_i; %速度更新
x(i,:) = x(i,:) + v(i,:); %位置更新
if f(x(i,:)) < f(pbest(i,:))
pbest(i,:) = x(i,:);
end
end
[~,gbest_idx] = min(arrayfun(@(k) f(x(k,:)),1:M)); %更新全局极值
gbest = x(gbest_idx,:);
fitness(t) = f(gbest);
end
plot(fitness); %绘制适应度值变化曲线
hold on;
end
xlabel('迭代次数');
ylabel('适应度值');
title('标准PSO vs. 基于高斯变异的PSO');
legend(string(rand_seed),'Location','eastoutside');
完整代码
```MATLAB clc; clear all;
Tmax = 50; %迭代次数 M = 100; %种群大小 c1 = 2; %学习因子1 c2 = 2; %学习因子2 w_max = 0.9; %惯性权重最大值 w_min = 0.4; %惯性权重最小值 sigma = 0.3; %高斯变异标准差 rand_seed = 1:10; %随机数种子
%目标函数 f = @(x) x(1).^2 + x(2).^2;
%初始化种群 for i=1:M x(i,:) = randn(1,2); %初始位置 v(i,:) = randn(1,2); %初始速度 pbest(i,:) = x(i,:); %个体极值 end [~,gbest_idx] = min(arrayfun(@(k) f(x(k,:)),1:M)); %全局极值的索引 gbest = x(gbest_idx,:); %全局极值
for rnd_seed = rand_seed rand('twister',rnd_seed); %设置随机数种子 for t=1:Tmax w(t) = w_max - t(w_max - w_min)/Tmax; %惯性权重的计算 for i=1:M r1 = rand; r2 = rand; sigma_i = sigmarandn(1,2); %个体的高斯变异因子 u_i = randn(1,2); %个体的随机数 v(i,:) = w(t)v(i,:) + c1r1(pbest(i,:) - x(i,:)) + c2r2(gbest - x(i,:)) + sigma_i.u_i; %速度更新 x(i,:) = x(i,:) + v(i,:); %位置更新 if f(x(i,:)) < f(pbest(i,:)) %更新个体极值 pbest(i,:) = x(i,:); end end [~,gbest_idx] = min(arrayfun(@(k) f(x(k,:)),1:M)); %更新全局极值 gbest = x(gbest_idx,:); end %记录结果 best_soln = f(gbest); %最佳解 best_cnt = sum(arrayfun(@(k) f(x(k,:))==best_soln, 1:M)); %最佳解出现的次数 mean_soln = mean(arrayfun(@(k) f(x(k,:)), 1:M)); %平均值 std_soln = std(arrayfun(@(k) f(x(k,:)), 1:M)); %标准差 end
for rnd_seed = rand_seed rand('twister',rnd_seed); for t=1:Tmax w(t) = w_max - t*(w_max - w_min)/Tmax; for i=1:M r1 = rand;
优化算法 | 随机漂移粒子群优化算法（附标准PSO算法Python工具包）
基于粒子群算法(PSO)优化高斯过程回归(PSO-GPR)的数据回归预测，matlab代码，多变量输入模型。评价指标包括:R2、MAE、MSE、RMSE和MAPE等，代码质量极高，方便学习和替换数
import numpy as np
import matplotlib.pyplot as plt
# 定义参数
n_particles = 30
n_iterations = 100
n_dimensions = 2
c1 = 2
c2 = 2
w = 0.9
max_iter = 1000
sigma = 1.0
# 定义标准PSO算法和基于高斯变异的PSO算法
def standard_pso(x, p):
v = np.random.randn(n_particles, n_dimensions) * sigma
r1, r2 = np.random.rand(n_particles, n_dimensions), np.random.rand(n_particles, n_dimensions)
p_best = x.copy()
g_best = x[np.argmin([np.sum((p - x)**2) for x in x])]
p_best[np.argmin([np.sum((p - x)**2) for x in x])] = g_best
p_best_new = []
for i in range(n_iterations):
v1, v2 = w * v + c1 * r1, w * v + c2 * r2
y = p - v1[:, np.newaxis] * x - v2[:, np.newaxis] * r1[:, np.newaxis]
c = np.clip(y, -c1, c1)
p_best_new.append(p + c)
mask = (p_best_new < p).any(axis=1) & (p_best < p).any(axis=1)
p_best[mask] = p_best_new[mask]
mask = (p_best < g_best).any(axis=1)
if np.any(mask):
g_best = p_best[np.argmax([np.sum((p - x)**2) for x in p_best])]
if i % max_iter == 0:
fitness = [min([np.sum((p - x)**2) for x in x]) for p in p_best]
return np.array([np.min(fitness), len([f for f in fitness if f == min(fitness)])/len(fitness), np.mean(fitness), np.std(fitness)]), g_best
return np.array([np.min(fitness), len([f for f in fitness if f == min(fitness)])/len(fitness), np.mean(fitness), np.std(fitness)]), g_best
def gaussian_pso(x, p):
v = np.random.randn(n_particles, n_dimensions) * sigma
r1, r2 = np.random.rand(n_particles, n_dimensions), np.random.rand(n_particles, n_dimensions)
p_best = x.copy()
g_best = x[np.argmin([np.sum((p - x)**2) for x in x])]
p_best[np.argmin([np.sum((p - x)**2) for x in x])] = g_best
p_best_new = []
for i in range(n_iterations):
v1, v2 = w * v + c1 * r1, w * v + c2 * r2
y = p - v1[:, np.newaxis] * x - v2[:, np.newaxis] * r1[:, np.newaxis]
c = np.clip(y, -c1, c1)
p_best_new.append(p + c)
mask = (p_best < p).any(axis=1) & (p_best < p).any(axis=1)
p_best[mask] = p_best_new[mask]
标准PSO和基于高斯变异的PSO可以从它们在解决优化问题方面的性能进行比较。以下是两者之间的一些主要区别：
- 标准PSO：标准PSO是一种基于鸟群社会行为的流行优化算法。它使用一群粒子来探索搜索空间并找到最优解。每个粒子的速度基于其自己的最佳位置和群体的最佳位置进行更新。标准PSO已被证明在解决各种优化问题方面非常有效。
- 基于高斯变异的PSO：基于高斯变异的PSO是标准PSO算法的一种修改版本，它包含一个高斯变异算子。此算子用于向每个粒子的速度添加随机扰动，这可以帮助算法逃脱局部最优解。变异算子以一定的概率应用，通常设置为较小的值。
两种算法之间的一些主要区别是：
- 基于高斯变异的PSO更容易逃脱局部最优解，因为添加了变异算子。
- 基于高斯变异的PSO可能需要比标准PSO更多的计算资源，因为添加了额外的变异算子。
- 两种算法的性能可能因所解决的问题而异。在某些情况下，标准PSO可能表现更好，而在其他情况下，基于高斯变异的PSO可能表现更好。
总的来说，选择标准PSO和基于高斯变异的PSO取决于所解决的具体问题和可用于计算的资源。
% 先读取数据
standard_data = csvread('standard_pso.csv', 1, 0);
gaussian_data = csvread('gaussian_pso.csv', 1, 0);
% 计算四个参数，并保存到列表中
standard_params = [];
gaussian_params = [];
for df = [standard_data, gaussian_data]
best_val = max(df(:,1));
best_val_count = length(find(df(:,1)==best_val));
mean_val = mean(df(:,1));
std_val = std(df(:,1));
standard_params = [standard_params, best_val, best_val_count, mean_val, std_val];
gaussian_params = [gaussian_params, best_val, best_val_count, mean_val, std_val];
end
% 构建数据表
data = {
'Parameter', 'Standard PSO', 'Gaussian PSO';
'Best Value', standard_params(1), gaussian_params(1);
'Best Value Count', standard_params(2), gaussian_params(2);
'Mean Value', standard_params(3), gaussian_params(3);
'Std Value', standard_params(4), gaussian_params(4)
};
table(data)
% 绘制适应度值变化图
plot(standard_data(:,2), standard_data(:,1), 'b-', 'LineWidth', 1.5)
hold on
plot(gaussian_data(:,2), gaussian_data(:,1), 'r-', 'LineWidth', 1.5)
hold off
xlabel('Iterations')
ylabel('Fitness Value')
title('Fitness Value Comparison')
legend('Standard PSO', 'Gaussian PSO')
PSO算法的基本思想是将一群“粒子”置于解空间中，每个粒子代表一个解，每个粒子有一个位置向量和一个速度向量。在迭代的过程中，粒子的位置和速度不断更新，直到找到全局最优解或达到迭代次数的上限。
基于PSO粒子群优化算法Python仿真（完整源码+文档）：https://download.csdn.net/download/m0_62143653/87603833
import numpy as np
import matplotlib.pyplot as plt
# 仿真结果数据
data = {
'Standard PSO': {
'Best Value': [10, 15, 20, 25, 30, 35, 40, 45, 50, 55],
'Best Value Count': [2, 3, 5, 4, 6, 7, 8, 6, 4, 5],
'Average Value': [15, 17, 22, 20, 25, 30, 28, 32, 31, 35],
'Standard Deviation': [2, 3, 1, 4, 2, 1, 2, 3, 2, 1]
},
'Gaussian Mutated PSO': {
'Best Value': [12, 18, 22, 28, 32, 37, 42, 48, 52, 57],
'Best Value Count': [1, 4, 6, 3, 5, 7, 9, 7, 5, 6],
'Average Value': [16, 19, 23, 21, 27, 33, 29, 34, 33, 37],
'Standard Deviation': [1, 2, 1, 3, 1, 2, 1, 2, 1, 1]
}
}
# 创建表格
def create_table(data):
columns = ['Best Value', 'Best Value Count', 'Average Value', 'Standard Deviation']
rows = list(data.keys())
cell_text = []
for row in rows:
cell_text.append([data[row][col] for col in columns])
fig, ax = plt.subplots()
ax.axis('tight')
ax.axis('off')
table = ax.table(cellText=cell_text, colLabels=columns, rowLabels=rows, loc='center')
table.auto_set_font_size(False)
table.set_fontsize(12)
table.scale(1.2, 1.2)
plt.title('Comparison of Parameters')
plt.show()
# 创建适应度值变化的图表
def create_fitness_chart(data):
x = np.arange(1, 11)
fig, ax = plt.subplots()
for key, values in data.items():
ax.plot(x, values, label=key)
ax.set_xlabel('Iteration')
ax.set_ylabel('Fitness Value')
ax.set_title('Fitness Value Changes')
ax.legend()
plt.show()
# 调用函数生成表格和图表
create_table(data)
create_fitness_chart(data['Standard PSO'], data['Gaussian Mutated PSO'])
可以使用Python的Matplotlib库来实现
PSO算法是通过模拟鸟群或鱼群等自然界中群体的行为，以解决优化问题。算法将问题看作是在一个多维空间中的搜索过程，以找到最优解