File size: 6,368 Bytes
7cae457 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
import numpy as np
import pyswarms as ps
def cargo_load_planning_pso_v2(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
max_positions, options=None, swarmsize=100, maxiter=100):
"""
使用二进制粒子群优化方法计算货物装载方案，最小化重心的变化量。
参数:
weights (list): 每个货物的质量列表。
cargo_names (list): 每个货物的名称。
cargo_types_dict (dict): 货物名称和占用的货位数量。
positions (list): 可用的货位编号。
cg_impact (list): 每个位置每kg货物对重心index的影响系数。
cg_impact_2u (list): 两个位置组合的重心影响系数。
cg_impact_4u (list): 四个位置组合的重心影响系数。
max_positions (int): 总货位的数量。
options (dict, optional): PSO算法的配置选项。
swarmsize (int, optional): 粒子群大小。
maxiter (int, optional): 最大迭代次数。
返回:
best_solution (np.array): 最优装载方案矩阵。
best_cg_change (float): 最优方案的重心变化量。
"""
# 将货物类型映射为对应的占用单位数
cargo_types = [cargo_types_dict[name] for name in cargo_names]
num_cargos = len(weights) # 货物数量
num_positions = len(positions) # 可用货位数量
dimension = num_cargos * max_positions # 每个粒子的维度：货物数量 × 可用货位数量
# 如果未提供options，使用默认配置
if options is None:
options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
# 定义适应度评估函数
def fitness_function(x):
"""
计算每个粒子的适应度值。
参数:
x (numpy.ndarray): 粒子的位置数组，形状为 (n_particles, dimension)。
返回:
numpy.ndarray: 每个粒子的适应度值。
"""
fitness = np.zeros(x.shape[0])
for idx, particle in enumerate(x):
# 将连续位置映射为离散起始位置
start_positions = []
penalty = 0
cg_change = 0.0
occupied = np.zeros(num_positions, dtype=int)
for i in range(num_cargos):
cargo_type = cargo_types[i]
pos_continuous = particle[i * max_positions:(i + 1) * max_positions]
# 根据粒子位置值选择最佳货位
start_pos = np.argmax(pos_continuous)
# 检查边界
if start_pos < 0 or start_pos + cargo_type > num_positions:
penalty += 1000
continue
# 检查对齐
if cargo_type == 2 and start_pos % 2 != 0:
penalty += 1000
if cargo_type == 4 and start_pos % 4 != 0:
penalty += 1000
# 检查重叠
if np.any(occupied[start_pos:start_pos + cargo_type]):
penalty += 1000
else:
occupied[start_pos:start_pos + cargo_type] = 1
start_positions.append(start_pos)
# 计算重心变化量
if cargo_type == 1:
cg_change += weights[i] * cg_impact[start_pos]
elif cargo_type == 2:
cg_change += weights[i] * cg_impact_2u[start_pos // 2]
elif cargo_type == 4:
cg_change += weights[i] * cg_impact_4u[start_pos // 4]
fitness[idx] = cg_change + penalty
return fitness
# 设置PSO的边界
# 对于每个货物，起始位置的范围根据货物类型对齐
lower_bounds = []
upper_bounds = []
for i in range(num_cargos):
cargo_type = cargo_types[i]
lower_bounds.append([0] * max_positions)
upper_bounds.append([1] * max_positions)
bounds = (np.array(lower_bounds), np.array(upper_bounds))
# 初始化PSO优化器
optimizer = ps.single.GlobalBestPSO(n_particles=swarmsize, dimensions=dimension, options=options, bounds=bounds)
# 运行PSO优化
best_cost, best_pos = optimizer.optimize(fitness_function, iters=maxiter)
# 将最佳位置映射为离散装载方案
best_start_positions = []
penalty = 0
cg_change = 0.0
occupied = np.zeros(num_positions, dtype=int)
for i in range(num_cargos):
cargo_type = cargo_types[i]
pos_continuous = best_pos[i * max_positions:(i + 1) * max_positions]
# 根据粒子位置值选择最佳货位
start_pos = np.argmax(pos_continuous)
# 检查边界
if start_pos < 0 or start_pos + cargo_type > num_positions:
penalty += 1000
best_start_positions.append(start_pos)
continue
# 检查对齐
if cargo_type == 2 and start_pos % 2 != 0:
penalty += 1000
if cargo_type == 4 and start_pos % 4 != 0:
penalty += 1000
# 检查重叠
if np.any(occupied[start_pos:start_pos + cargo_type]):
penalty += 1000
else:
occupied[start_pos:start_pos + cargo_type] = 1
best_start_positions.append(start_pos)
# 计算重心变化量
if cargo_type == 1:
cg_change += abs(weights[i] * cg_impact[start_pos])
elif cargo_type == 2:
cg_change += abs(weights[i] * cg_impact_2u[start_pos // 2])
elif cargo_type == 4:
cg_change += abs(weights[i] * cg_impact_4u[start_pos // 4])
total_cg_change = cg_change + penalty
# 构建装载方案矩阵
best_xij = np.zeros((num_cargos, num_positions), dtype=int)
for i, start_pos in enumerate(best_start_positions):
cargo_type = cargo_types[i]
for k in range(cargo_type):
pos = start_pos + k
if pos < num_positions:
best_xij[i, pos] = 1
# 检查是否有严重惩罚，判断是否找到可行解
if total_cg_change >= -999999:
return best_xij, total_cg_change
else:
return [], -1000000
# 示例调用
|