根据博客内容，文章主要提供了电力巡检无人机机巢布点选址算法的Python代码示例，但存在以下问题需要提取和补齐： ## 一、现有代码分析 文章中提供的Python代码片段使用了DEAP框架实现遗传算法，但存在以下不完整之处： ```python import numpy as np from deap import base, creator, tools, algorithms # 定义问题 creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0)) creator.create("Individual", list, fitness=creator.FitnessMin) # 初始化工具箱 toolbox = base.Toolbox() toolbox.register("attr_bool", np.random.randint, 0, 2) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=100) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # 定义适应度函数 def evalFitness(individual): cost = sum(individual) coverage = sum([1 for i in individual if i == 1]) return cost, -coverage toolbox.register("evaluate", evalFitness) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) # 运行遗传算法 population = toolbox.population(n=50) algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, verbose=False) ``` ## 二、代码补全与完整实现 ### 1. 完整的电力巡检无人机机巢布点选址算法（Python版） ```python """ 计及多约束的电力巡检无人机机巢布点选址算法 - 完整实现 作者：基于CSDN博客内容完善 日期：2024 """ import numpy as np import matplotlib.pyplot as plt from deap import base, creator, tools, algorithms from scipy.spatial import distance_matrix import random class PowerInspectionDroneNestPlacement: """ 电力巡检无人机机巢布点选址类 """ def __init__(self, facilities_locations, candidate_locations, drone_range, terrain_map=None, max_nests=None, budget=None): """ 初始化参数 :param facilities_locations: 电力设施位置列表 [(x1,y1), (x2,y2), ...] :param candidate_locations: 候选机巢位置列表 [(x1,y1), (x2,y2), ...] :param drone_range: 无人机最大飞行距离 :param terrain_map: 地形障碍物地图（可选） :param max_nests: 最大机巢数量（可选） :param budget: 预算限制（可选） """ self.facilities = np.array(facilities_locations) self.candidates = np.array(candidate_locations) self.drone_range = drone_range self.terrain_map = terrain_map self.max_nests = max_nests self.budget = budget # 计算覆盖矩阵 self.coverage_matrix = self._calculate_coverage_matrix() self.n_facilities = len(facilities_locations) self.n_candidates = len(candidate_locations) def _calculate_coverage_matrix(self): """ 计算覆盖矩阵：a_ij = 1 表示机巢i可以覆盖设施j """ coverage = np.zeros((self.n_candidates, self.n_facilities)) for i, nest_pos in enumerate(self.candidates): for j, fac_pos in enumerate(self.facilities): dist = np.linalg.norm(nest_pos - fac_pos) if dist <= self.drone_range: coverage[i, j] = 1 return coverage def _check_terrain_constraints(self, solution): """ 检查地形约束 :param solution: 二进制编码的解决方案 :return: 是否满足地形约束 """ if self.terrain_map is None: return True # 检查每个选中的机巢位置是否在可行区域 for i, selected in enumerate(solution): if selected == 1: pos = self.candidates[i] # 简化的地形检查（实际应用中需要更复杂的地形分析） if not self._is_position_feasible(pos): return False return True def _is_position_feasible(self, position): """ 检查位置是否可行（不在障碍物区域） :param position: (x, y)坐标 :return: 布尔值 """ # 这里需要根据实际地形数据进行实现 # 简化的示例：检查是否在指定区域内 x, y = position if self.terrain_map is None: return True # 假设terrain_map是二维数组，0表示可行，1表示障碍 return self.terrain_map[int(y), int(x)] == 0 def fitness_function(self, individual): """ 适应度函数：考虑成本、覆盖率和约束惩罚 """ # 解码个体：二进制编码，1表示在该候选位置布设机巢 selected_nests = np.array(individual) # 1. 成本计算（简化为机巢数量） nest_count = np.sum(selected_nests) cost = nest_count * 10000 # 假设每个机巢成本为10000 # 2. 覆盖计算 total_coverage = 0 for j in range(self.n_facilities): # 检查该设施是否被至少一个选中的机巢覆盖 for i in range(self.n_candidates): if selected_nests[i] == 1 and self.coverage_matrix[i, j] == 1: total_coverage += 1 break coverage_rate = total_coverage / self.n_facilities # 3. 约束惩罚 penalty = 0 # 覆盖约束惩罚 uncovered_facilities = self.n_facilities - total_coverage ాలుpenalty += uncovered_facilities * 100000 # 高惩罚系数 # 地形约束惩罚 if not self._check_terrain_constraints(individual): penalty += 50000 # 最大机巢数量约束 if self.max_nests is not None and nest_count > self.max_nests: penalty += (nest_count - self.max_nests) * 50000 # 预算约束 if self.budget is not None and cost > self.budget: penalty += (cost - self.budget) * 10 # 适应度值：最小化成本+惩罚，最大化覆盖率 fitness = cost + penalty - coverage_rate * 100000 return (fitness,) ాలుdef setup_genetic_algorithm(self): """ 设置遗传算法参数 """ # 创建适应度类和个体类 creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) # 最小化问题 creator.create("Individual", list, fitness=creator.FitnessMin) ాలు ాలుtoolboxాలు= baseాలు.Toolాలుbox() # 注册遗传算子 toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool,ాలుn=selfాలు.n_cాలుandidates) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # 注册评估函数 toolbox.register("evaluate", self.fitness_function) # 注册遗传操作 toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) return toolbox def run_optimization(self, population_size=50, generations=100, crossover_prob=0.7, mutation_prob=0.2): """ 运行优化算法 """ # 设置遗传算法 toolbox = self.setup_genetic_algorithm() # 初始化种群 population = toolbox.population(n=population_size) # 记录最佳个体 hof = tools.HallOfFame(1) # 运行遗传算法 algorithms.eaSimple(population, toolbox, cxpb=crossover_prob, mutpb=mutation_prob, ngen=generations, halloffame=hof, verbose=True) # 获取最佳解 best_individual = hof[0] best_fitness = best_individual.fitness.values[0] return best_individual, best_fitness def decode_solution(self, individual): """ 解码解决方案 """ selected_indices = [i for i, val in enumerate(individual) if val == 1] selected_locations = self.candidates[selected_indices] # 计算覆盖情况 coverage_info = {} for j in range(self.n_facilities): for i in selected_indices: if self.coverage_matrix[i, j] == 1: coverage_info[j] = i break return { 'selected_nests': selected_locations, 'selected_indices': selected_indices, 'nest_count': len(selected_indices), 'coverage_rate': len(coverage_info) / self.n_facilities, 'coverage_map': coverage_info } # 使用示例 if __name__ == "__main__": # 示例数据 np.random.seed(42) # 生成电力设施位置（随机生成50个设施） n_facilities = 50 facilities = np.random.rand(n_facilities, 2) * 100 # 生成候选机巢位置（随机生成30个候选点） n_candidates = 30 candidates = np.random.rand(n_candidates, 2) * 100 # 无人机飞行距离 drone_range = 20 # 创建优化问题实例 problem = PowerInspectionDroneNestPlacement( facilities_locations=facilities, candidate_locations=candidates, drone_range=drone_range ) # 运行优化 best_solution, best_fitness = problem.run_optimization( population_size=50, generations=100 ) # 解码结果 result = problem.decode_solution(best_solution) print(f"最佳适应度: {best_fitness}") print(f"选择机巢数量: {result['nest_count']}") print(f"覆盖率: {result['coverage_rate']:.2%}") print(f"选择的机巢位置: {result['selected_nests']}") ``` ### 2. 可视化代码补充 ```python def visualize_solution(facilities, candidates, solution_result, drone_range): """ 可视化解决方案 """ fig, ax = plt.subplots(1, 2, figsize=(15, 6)) # 子图1：设施和候选点分布 ax[0].scatter(facilities[:, 0], facilities[:, 1], c='blue', label='电力设施', alpha=0.6, s=50) ax[0].scatter(candidates[:, 0], candidates[:, 1], c='gray', label='候选机巢', alpha=0.4, s=30, marker='s') ax[0].set_title('电力设施和候选机巢分布') ax[0].set_xlabel('X坐标') ax[0].set_ylabel('Y坐标') ax[0].legend() ax[0].grid(True, alpha=0.3) # 子图2：选中的机巢和覆盖范围 ax[1].scatter(facilities[:, 0], facilities[:, 1], c='blue', label='电力设施', alpha=0.6, s=50) selected_nests = solution_result['selected_nestsాలుాలుాలుాలు'] ాలుాలుాలు for i, nest in enumerate(selected_nests): # 绘制选中的机巢 ax[1].scatter(nest[0], nest[1], c='red', s=100, marker='^', label='选中机巢' if i == 0 else "") # 绘制覆盖范围（圆形） circle = plt.Circle((nest[0], nest[1]), drone_range, color='red', alpha=0.1, fill=True) ax[1].add_patch(circle) # 标记被覆盖的设施 covered_indices = list(solution_result['coverage_map'].keys()) covered_facilities = facilities[covered_indices] ax[1].scatter(covered_facilities[:, 0], covered_facilities[:, 1], c='green', s=80, marker='*', label='已覆盖设施') ax[1].set_title(f'最优布点方案（覆盖率：{solution_result["coverage_rate"]:.1%}）') ax[1].set_xlabel('X坐标') ax[1].set_ylabel('Y坐标') ax[1].legend() ax[1].grid(True, alpha=0.3) ax[1].axis('equal') plt.tight_layout() plt.show() # 在main函数中添加可视化 if __name__ == "__main__": # ...（之前的代码）... # 可视化结果 visualize_solution(facilities, candidates, result, drone_range) ``` ### 3. 参数调优和结果分析代码 ```python def parameter_sensitivity_analysis(problem, param_ranges): """ 参数敏感性分析 """ results = [] for pop_size in param_ranges['population_sizes']: for gen in param_ranges['generations']: for cx_prob inాలుాలుాలుాలుాలుాలుparam_ranges['crossover_probs']: for mut_prob in param_ranges['mutation_probs']: # 运行优化 best_solution, best_fitness = problem.run_optimization( population_size=pop_size, generations=gen, crossover_prob=cx_prob, mutation_prob=mut_prob ) result = problem.decode_solution(best_solution) results.append({ 'params': { 'pop_size': pop_size, 'generations': gen, 'crossover_prob': cx_prob, 'mutation_prob': mut_prob }, 'fitness': best_fitness, 'nest_count': result['nest_count'], 'coverage_rate': result['coverage_rate'] }) return results def analyze_results(results): """ 分析优化结果 """ import pandas as pd df = pd.DataFrame(results) print("=== 参数敏感性分析结果 ===") print(f"总实验次数: {len(df)}") print(f"最佳覆盖率: {df['coverage_rate'].max():.2%}") print(f"平均覆盖率: {df['coverage_rate'].mean():.2%}") print(f"最小机巢数: {df['nest_count'].min()}") print(f"平均机巢数: {df['nest_count'].mean():.1f}") # 找到最优参数组合 best_idx = df['coverage_rate'].idxmax() best_params = df.iloc[best_idx] print("\n=== 最优参数组合 ===") print(f"种群大小: {best_params['params']['pop_size']}") print(f"迭代次数: {best_params['params']['generations']}") print(f"交叉概率: {best_params['params']['crossover_prob']}") print(f"变异概率: {best_params['params']['mutation_prob']}") print(f"覆盖率: {best_params['coverage_rate']:.2%}") print(f"机巢数: {best_params['nest_count']}") return df # 运行参数分析 if __name__ == "__main__": # ...（之前的代码）... # 参数敏感性分析 param_ranges = { 'population_sizes': [30, 50, 100], 'generations': [50, 100, 200], 'crossover_probs': [0.5, 0.7, 0.9], 'mutation_probs':ాలు[0.1, 0.2, 0.3] } analysis_results = parameter_sensitivity_analysis(problem, param_ranges) results_df = analyze_results(analysis_results) ``` ## 三、算法扩展和优化建议 ### 1. 多目标优化版本 ```python from deap import algorithms import array class MultiObjectiveNestPlacement(PowerInspectionDroneNestPlacement): """ 多目标优化版本：同时最小化成本和最大化覆盖率 """ def setup_multi_objective_ga(self): """ 设置多目标遗传算法（NSGA-II） """ creator.create("FitnessMulti", base.Fitness, weights=(-1.0, 1.0)) # 最小化成本，最大化覆盖率 creator.create("Individual", list, fitness=creator.FitnessMulti) toolbox = base.Toolbox() # 遗传算子注册 toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=self.n_candidates) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # 多目标评估函数 def evaluate_multi(individual): selected_nests = np.array(individual) nest_count = np.sum(selected_nests) cost = nest_count * 10000 # 计算覆盖率 total_coverage = 0 for j in range(self.n_facilities): for i in range(self.n_candidates): if selected_nests[i] == 1 and self.coverage_matrix[i, j] == 1: total_coverage += 1 break coverage_rate = total_coverage / self.n_facilities # 约束惩罚 penalty = 0 if not self._check_terrain_const