117 lines
4.4 KiB
Python
117 lines
4.4 KiB
Python
import numpy as np
|
|
|
|
|
|
def PSO_multi_obj(fitness_func, n_particles, n_dims, n_objs, max_iter=100, w=0.7, c1=1.4, c2=1.4):
|
|
global individuals # 声明全局变量
|
|
# 定义初始的粒子群
|
|
swarm_position = np.empty((n_particles, n_dims))
|
|
for i in range(n_particles):
|
|
swarm_position[i] = individuals['chrom'][i]
|
|
|
|
# 定义粒子群速度
|
|
swarm_velocity = np.zeros((n_particles, n_dims))
|
|
|
|
# 定义粒子群最优位置
|
|
swarm_best_position = swarm_position.copy()
|
|
|
|
# 定义一个矩阵记录下所有东西
|
|
fitness_history = []
|
|
|
|
# 计算初始粒子群适应度
|
|
swarm_fitness = np.empty((n_particles, n_objs))
|
|
for i in range(n_particles):
|
|
swarm_fitness[i] = fitness_func(individuals['chrom'][i])
|
|
|
|
# TOPSIS!!!!!!!!!!!!!
|
|
colum2, colum3 = np.nanmin(swarm_fitness[:, 1]), np.nanmin(swarm_fitness[:, 2])
|
|
zhenglixiangjie1 = np.array([colum2, colum3])
|
|
distances1 = np.sqrt((swarm_fitness[:, 1] - colum2) ** 2 + (swarm_fitness[:, 2] - colum3) ** 2)
|
|
fitness_array = np.concatenate((zhenglixiangjie1, distances1))
|
|
|
|
fitness_history.append(fitness_array)
|
|
|
|
# 定义每个粒子历史最优位置
|
|
particle_best_position = swarm_position.copy()
|
|
|
|
# 定义每个粒子历史最优适应度
|
|
particle_best_fitness = swarm_fitness.copy()
|
|
|
|
# 定义全局最优位置
|
|
global_best_position = swarm_best_position[np.argmin(swarm_fitness[:, 0])]
|
|
|
|
# 定义全局最优适应度
|
|
global_best_fitness = np.min(swarm_fitness[:, 0])
|
|
|
|
swarm_fitness1 = np.empty((n_particles, n_objs))
|
|
fitness_history1 = [] # 记录每次适应度
|
|
# 进行迭代
|
|
min_values = [] # 初始化列表每一行的最小值
|
|
for t in range(max_iter):
|
|
# 更新粒子群速度和位置
|
|
swarm_velocity = w * swarm_velocity + \
|
|
c1 * np.random.rand(n_particles, n_dims) * (particle_best_position - swarm_position) + \
|
|
c2 * np.random.rand(n_particles, n_dims) * (global_best_position - swarm_position)
|
|
swarm_position += swarm_velocity
|
|
|
|
# 将超出边界的位置调整到边界内
|
|
for i in range(n_particles):
|
|
for j in range(n_dims):
|
|
if swarm_position[i][j] < unassigned_roads[j][0]:
|
|
swarm_position[i][j] = unassigned_roads[j][0]
|
|
if swarm_position[i][j] > unassigned_roads[j][1]:
|
|
swarm_position[i][j] = unassigned_roads[j][1]
|
|
|
|
# 计算新的适应度
|
|
|
|
for i in range(n_particles):
|
|
fitness = fitness_func(swarm_position[i])
|
|
swarm_fitness1[i] = fitness
|
|
|
|
# TOPSIS!!!!!!!!!!!!!!!!!!!
|
|
colum22, colum33 = np.nanmin(swarm_fitness1[:, 1]), np.nanmin(swarm_fitness1[:, 2])
|
|
if t == 0:
|
|
if colum2 > colum22:
|
|
colum2 = colum22
|
|
if colum3 > colum33:
|
|
colum3 = colum33
|
|
|
|
else:
|
|
if colum22 > np.min(fitness_history1[t - 1][0]):
|
|
colum2 = np.min(fitness_history1[t - 1][0])
|
|
else:
|
|
colum2 = colum22
|
|
if colum33 > np.min(fitness_history1[t - 1][1]):
|
|
colum3 = np.min(fitness_history1[t - 1][1])
|
|
else:
|
|
colum3 = colum33
|
|
|
|
zhenglixiangjie1 = np.array([colum2, colum3])
|
|
|
|
distances1 = np.sqrt((swarm_fitness1[:, 1] - colum2) ** 2 + (swarm_fitness1[:, 2] - colum3) ** 2)
|
|
fitness_array = np.concatenate((zhenglixiangjie1, distances1))
|
|
fitness_history1.append(fitness_array)
|
|
|
|
# 更新粒子历史最优位置
|
|
for i in range(n_particles):
|
|
if np.min(swarm_fitness[i]) < np.min(particle_best_fitness[i]):
|
|
particle_best_fitness[i] = swarm_fitness[i]
|
|
particle_best_position[i] = swarm_position[i]
|
|
|
|
# 更新粒子群最优位置
|
|
for i in range(n_particles):
|
|
if np.min(particle_best_fitness[i]) < np.min(swarm_fitness[i]):
|
|
swarm_best_position[i] = particle_best_position[i]
|
|
|
|
# 更新全局最优位置
|
|
if np.min(swarm_fitness) < global_best_fitness:
|
|
global_best_fitness = np.min(swarm_fitness)
|
|
global_best_position = swarm_position[np.argmin(swarm_fitness[:, 0])]
|
|
|
|
# 记录每一次迭代的全局最优适应度
|
|
trace.append(global_best_fitness)
|
|
|
|
fitness_history2 = np.array(fitness_history1)
|
|
# 返回最终的全局最优位置和适应度
|
|
return global_best_position,global_best_fitness
|
|
|