145 lines
7.9 KiB
Python
145 lines
7.9 KiB
Python
import random
|
||
import numpy as np
|
||
from data_structures import Config # 算法配置参数类
|
||
from chromosome_utils import ChromosomeUtils # 染色体工具类
|
||
class GeneticOperator:
|
||
"""遗传操作类：实现交叉和变异操作，用于产生新个体（整数化）"""
|
||
def __init__(self, config: Config, utils: ChromosomeUtils):
|
||
"""
|
||
初始化遗传操作器
|
||
:param config: 算法配置参数（如交叉概率、变异概率等）
|
||
:param utils: 染色体工具类实例（提供染色体修复等功能）
|
||
"""
|
||
self.config = config # 配置参数
|
||
self.utils = utils # 染色体工具
|
||
def two_point_crossover(self, parent1: np.ndarray, parent2: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
|
||
"""
|
||
两点交叉：在染色体上随机选择两个点，交换两点之间的基因片段
|
||
:param parent1: 父代染色体1（整数）
|
||
:param parent2: 父代染色体2（整数）
|
||
:return: 两个子代染色体（经过修复，整数）
|
||
"""
|
||
length = self.utils.chromosome_length # 染色体总长度
|
||
if length < 2: # 染色体长度不足2时无法交叉，直接返回父代副本
|
||
return parent1.copy().astype(int), parent2.copy().astype(int)
|
||
# 随机选择两个交叉点（point1 < point2）
|
||
point1 = random.randint(0, length // 2)
|
||
point2 = random.randint(point1 + 1, length - 1)
|
||
# 复制父代基因并交换片段
|
||
child1 = parent1.copy()
|
||
child2 = parent2.copy()
|
||
child1[point1:point2] = parent2[point1:point2] # 交换point1到point2之间的基因
|
||
child2[point1:point2] = parent1[point1:point2]
|
||
# 修复染色体（确保满足约束条件）
|
||
child1 = self.utils.repair_chromosome(child1)
|
||
child2 = self.utils.repair_chromosome(child2)
|
||
return child1.astype(int), child2.astype(int)
|
||
def uniform_mutation(self, chromosome: np.ndarray) -> np.ndarray:
|
||
"""
|
||
均匀变异：对染色体的三层基因（企业层、能力层、数量层）进行随机变异（整数化）
|
||
:param chromosome: 待变异的染色体（整数）
|
||
:return: 变异后的染色体（经过修复，整数）
|
||
"""
|
||
mutated = chromosome.copy().astype(int) # 确保为整数
|
||
# 拆分染色体为三层
|
||
enterprise_layer, capacity_layer, quantity_layer = self.utils._split_chromosome(mutated)
|
||
split_points = np.cumsum(self.utils.material_enterprise_count)
|
||
# ========== 第一步：记录原始企业层状态 ==========
|
||
original_enterprise_layer = enterprise_layer.copy()
|
||
# ========== 第二步：企业层变异 ==========
|
||
start = 0
|
||
for i in range(self.utils.I):
|
||
end = split_points[i]
|
||
for idx in range(start, end):
|
||
if random.random() < self.config.mutation_prob:
|
||
enterprise_layer[idx] = 1 - enterprise_layer[idx]
|
||
start = end
|
||
# 修复企业层
|
||
enterprise_layer = self.utils.repair_enterprise_layer(enterprise_layer)
|
||
# ========== 第三步：同步更新能力和数量层（整数） ==========
|
||
start = 0
|
||
for i in range(self.utils.I):
|
||
end = split_points[i]
|
||
ents = self.utils.material_optional_enterprises[i]
|
||
for idx in range(start, end):
|
||
current_ent_selected = enterprise_layer[idx] # 变异后的选择状态
|
||
original_ent_selected = original_enterprise_layer[idx] # 变异前的选择状态
|
||
# 情况1：企业从选中变为未选中（1→0）
|
||
if original_ent_selected == 1 and current_ent_selected == 0:
|
||
capacity_layer[idx] = 0 # 产能设为0（整数）
|
||
quantity_layer[idx] = 0 # 数量设为0（整数）
|
||
# 情况2：企业从未选中变为选中（0→1）
|
||
elif original_ent_selected == 0 and current_ent_selected == 1:
|
||
ent = ents[idx - start]
|
||
qi = self.utils.order.Q[i]
|
||
# 初始化产能（整数）
|
||
if ent == 0:
|
||
min_cap = self.utils.risk.C0_i_min[i]
|
||
max_cap = self.utils.risk.C0_total_max
|
||
else:
|
||
supplier_id = ent - 1
|
||
min_cap = self.utils.supplier.Cj_i_min[supplier_id][i]
|
||
max_cap = self.utils.supplier.Cj_total_max[supplier_id]
|
||
capacity_layer[idx] = random.randint(min_cap, max_cap)
|
||
# 初始化数量（整数）
|
||
if ent == 0:
|
||
min_q = 0
|
||
max_q = qi
|
||
else:
|
||
supplier_id = ent - 1
|
||
min_q = self.utils.supplier.MinOrder[supplier_id][i]
|
||
max_q = self.utils.supplier.MaxOrder[supplier_id][i]
|
||
quantity_layer[idx] = random.randint(min_q, max_q)
|
||
# 情况3：企业保持选中（1→1）或保持未选中（0→0）
|
||
# 保持不变，后续的变异步骤会处理
|
||
start = end
|
||
# ========== 第四步：能力层变异（仅对保持选中的企业，整数） ==========
|
||
start = 0
|
||
for i in range(self.utils.I):
|
||
end = split_points[i]
|
||
ents = self.utils.material_optional_enterprises[i]
|
||
e_segment = enterprise_layer[start:end]
|
||
for idx in range(start, end):
|
||
# 只对保持选中的企业进行变异（1→1的情况）
|
||
if e_segment[idx - start] == 1 and original_enterprise_layer[idx] == 1:
|
||
if random.random() < self.config.mutation_prob:
|
||
ent = ents[idx - start]
|
||
if ent == 0:
|
||
min_cap = self.utils.risk.C0_i_min[i]
|
||
max_cap = self.utils.risk.C0_total_max
|
||
else:
|
||
supplier_id = ent - 1
|
||
min_cap = self.utils.supplier.Cj_i_min[supplier_id][i]
|
||
max_cap = self.utils.supplier.Cj_total_max[supplier_id]
|
||
# 变异后产能为整数
|
||
capacity_layer[idx] = random.randint(min_cap, max_cap)
|
||
start = end
|
||
# 修复能力层（考虑所有选中企业的产能）
|
||
capacity_layer = self.utils.repair_capacity_layer(enterprise_layer, capacity_layer)
|
||
# ========== 第五步：数量层变异（仅对保持选中的企业，整数） ==========
|
||
start = 0
|
||
for i in range(self.utils.I):
|
||
end = split_points[i]
|
||
ents = self.utils.material_optional_enterprises[i]
|
||
e_segment = enterprise_layer[start:end]
|
||
for idx in range(start, end):
|
||
# 只对保持选中的企业进行变异（1→1的情况）
|
||
if e_segment[idx - start] == 1 and original_enterprise_layer[idx] == 1:
|
||
if random.random() < self.config.mutation_prob:
|
||
ent = ents[idx - start]
|
||
qi = self.utils.order.Q[i]
|
||
# 变异后数量为整数
|
||
if ent == 0:
|
||
min_q = 0
|
||
max_q = qi
|
||
else:
|
||
supplier_id = ent - 1
|
||
min_q = self.utils.supplier.MinOrder[supplier_id][i]
|
||
max_q = self.utils.supplier.MaxOrder[supplier_id][i]
|
||
quantity_layer[idx] = random.randint(min_q, max_q)
|
||
start = end
|
||
# 修复数量层（考虑所有选中企业的分配）
|
||
quantity_layer = self.utils.repair_quantity_layer(enterprise_layer, quantity_layer)
|
||
# 合并三层
|
||
mutated = self.utils._merge_chromosome(enterprise_layer, capacity_layer, quantity_layer)
|
||
return mutated.astype(int) |