File size: 7,820 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 175 176 177 178 179 |
import numpy as np
import random
from deap import base, creator, tools, algorithms
def cargo_load_planning_genetic(weights, cargo_names, cargo_types_dict, positions, cg_impact, cg_impact_2u, cg_impact_4u,
max_positions, population_size=100, generations=100, crossover_prob=0.7, mutation_prob=0.2):
"""
使用改进版遗传算法计算货物装载方案，最小化重心的变化量。
参数:
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): 总货位的数量。
population_size (int): 遗传算法的种群大小。
generations (int): 遗传算法的代数。
crossover_prob (float): 交叉操作的概率。
mutation_prob (float): 变异操作的概率。
返回:
best_solution (np.array): 最优装载方案矩阵。
best_cg_change (float): 最优方案的重心变化量。
"""
try:
# 将货物类型映射为对应的占用单位数
cargo_types = [cargo_types_dict[name] for name in cargo_names]
num_cargos = len(weights) # 货物数量
num_positions = len(positions) # 可用货位数量
# 定义适应度函数（最小化重心变化量）
if not hasattr(creator, "FitnessMin"):
creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) # 目标是最小化
if not hasattr(creator, "Individual"):
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
# 个体初始化函数
def init_individual():
individual = []
occupied = [False] * num_positions
for cargo_type in cargo_types:
if cargo_type == 1:
valid_positions = [j for j in range(num_positions) if not occupied[j]]
elif cargo_type == 2:
valid_positions = [j for j in range(0, num_positions - 1, 2) if not any(occupied[j + k] for k in range(cargo_type))]
elif cargo_type == 4:
valid_positions = [j for j in range(0, num_positions - 3, 4) if not any(occupied[j + k] for k in range(cargo_type))]
else:
valid_positions = []
if not valid_positions:
# 如果没有有效位置，随机选择一个符合类型对齐的起始位置
if cargo_type == 1:
start_pos = random.randint(0, num_positions - 1)
elif cargo_type == 2:
choices = [j for j in range(0, num_positions - 1, 2)]
if choices:
start_pos = random.choice(choices)
else:
start_pos = 0 # 默认位置
elif cargo_type == 4:
choices = [j for j in range(0, num_positions - 3, 4)]
if choices:
start_pos = random.choice(choices)
else:
start_pos = 0 # 默认位置
else:
start_pos = 0 # 默认位置
else:
start_pos = random.choice(valid_positions)
individual.append(start_pos)
# 标记占用的位置
for k in range(cargo_type):
pos = start_pos + k
if pos < num_positions:
occupied[pos] = True
return creator.Individual(individual)
toolbox.register("individual", init_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# 适应度评估函数
def evaluate(individual):
# 检查重叠和边界
occupied = [False] * num_positions
penalty = 0
cg_change = 0.0
for i, start_pos in enumerate(individual):
cargo_type = cargo_types[i]
weight = weights[i]
# 检查边界
if start_pos < 0 or start_pos + cargo_type > num_positions:
penalty += 10000 # 超出边界的严重惩罚
continue
# 检查重叠
overlap = False
for k in range(cargo_type):
pos = start_pos + k
if occupied[pos]:
penalty += 10000 # 重叠的严重惩罚
overlap = True
break
occupied[pos] = True
if overlap:
continue
# 计算重心变化量
if cargo_type == 1:
cg_change += abs(weight * cg_impact[start_pos])
elif cargo_type == 2:
if start_pos % 2 == 0 and (start_pos // 2) < len(cg_impact_2u):
cg_change += abs(weight * cg_impact_2u[start_pos // 2])
else:
penalty += 10000 # 不对齐的严重惩罚
elif cargo_type == 4:
if start_pos % 4 == 0 and (start_pos // 4) < len(cg_impact_4u):
cg_change += abs(weight * cg_impact_4u[start_pos // 4])
else:
penalty += 10000 # 不对齐的严重惩罚
return (cg_change + penalty,)
toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxOnePoint) # 改为单点交叉
toolbox.register("mutate", tools.mutShuffleIndexes, indpb=mutation_prob) # 使用交换变异
toolbox.register("select", tools.selRoulette) # 轮盘赌选择
# 初始化种群
population = toolbox.population(n=population_size)
# 运行遗传算法
try:
algorithms.eaSimple(population, toolbox, cxpb=crossover_prob, mutpb=1.0, ngen=generations,
verbose=False)
except ValueError as e:
print(f"遗传算法运行时出错: {e}")
return [], -1000000 # 返回空列表和一个负的重心变化量作为错误标志
# 选择最优个体
try:
best_individual = tools.selBest(population, 1)[0]
best_cg_change = evaluate(best_individual)[0]
except IndexError as e:
print(f"选择最优个体时出错: {e}")
return [], -1000000 # 返回空列表和一个负的重心变化量作为错误标志
# 构建装载方案矩阵
solution = np.zeros((num_cargos, num_positions))
for i, start_pos in enumerate(best_individual):
cargo_type = cargo_types[i]
for k in range(cargo_type):
pos = start_pos + k
if pos < num_positions:
solution[i, pos] = 1
return solution, best_cg_change
except Exception as e:
print(f"发生错误: {e}")
return [], -1000000
#
# # 示例输入和调用
# def main():
# weights = [500, 800, 1200, 300, 700, 1000, 600, 900] # 每个货物的质量
# cargo_names = ['LD3', 'LD3
|