### 实现思路 实数编码遗传算法（Real-coded Genetic Algorithm, RCGA）通过直接使用实数表示个体基因，适用于连续优化问题。其核心步骤包括种群初始化、适应度评估、选择、交叉、变异和迭代优化。RCGA的优势在于无需编码/解码过程，能够更高效地搜索连续空间。 以下是一个完整的Python实现示例，用于求解一个简单的连续函数优化问题： ```python import numpy as np import random # 目标函数：二维函数最小化问题 def objective_function(individual): x, y = individual return (x - 3) ** 2 + (y + 2) ** 2 # 初始化种群 def initialize_population(pop_size, dim, bounds): population = np.zeros((pop_size, dim)) for i in range(pop_size): for j in range(dim): population[i][j] = np.random.uniform(bounds[j][0], bounds[j][1]) return population # 适应度计算（最小化问题） def calculate_fitness(population): fitness = np.zeros(len(population)) for i in range(len(population)): fitness[i] = objective_function(population[i]) return fitness # 锦标赛选择 def tournament_selection(population, fitness, tournament_size=3): selected = [] for _ in range(len(population)): idxs = np.random.choice(len(population), tournament_size) best_idx = idxs[np.argmin(fitness[idxs])] selected.append(population[best_idx]) return np.array(selected) # 模拟二进制交叉 (SBX) def sbx_crossover(parents, eta=15): offspring = np.zeros_like(parents) for i in range(0, len(parents), 2): if i + 1 >= len(parents): offspring[i] = parents[i] break p1, p2 = parents[i], parents[i + 1] for j in range(p1.shape[0]): u = np.random.rand() if u <= 0.5: beta = (2 * u) ** (1 / (eta + 1)) else: beta = (1 / (2 * (1 - u))) ** (1 / (eta + 1)) offspring[i][j] = 0.5 * ((1 + beta) * p1[j] + (1 - beta) * p2[j]) offspring[i + 1][j] = 0.5 * ((1 - beta) * p1[j] + (1 + beta) * p2[j]) return offspring # 多项式变异 def polynomial_mutation(offspring, pm=0.1, eta=20): for i in range(len(offspring)): for j in range(offspring.shape[1]): if np.random.rand() < pm: delta = np.random.rand() if delta <= 0.5: delta = (2 * delta) ** (1 / (eta + 1)) - 1 else: delta = 1 - (2 * (1 - delta)) ** (1 / (eta + 1)) offspring[i][j] += delta * 0.1 # 微小扰动 return offspring # 主遗传算法流程 def real_coded_ga(pop_size=50, generations=100, dim=2, bounds=None): if bounds is None: bounds = [(-5, 5)] * dim population = initialize_population(pop_size, dim, bounds) best_individual = None best_fitness = float('inf') for generation in range(generations): fitness = calculate_fitness(population) current_best_idx = np.argmin(fitness) current_best = population[current_best_idx] current_fitness = fitness[current_best_idx] if current_fitness < best_fitness: best_fitness = current_fitness best_individual = current_best selected = tournament_selection(population, fitness) offspring = sbx_crossover(selected) offspring = polynomial_mutation(offspring) combined_pop = np.vstack((population, offspring)) combined_fitness = calculate_fitness(combined_pop) sorted_idx = np.argsort(combined_fitness)[:pop_size] population = combined_pop[sorted_idx] if generation % 10 == 0: print(f"Generation {generation}: Best Fitness = {best_fitness}, Individual = {best_individual}") return best_individual, best_fitness # 运行算法 best_solution, best_value = real_coded_ga(pop_size=100, generations=200) print(f"Optimal Solution: {best_solution}, Fitness Value: {best_value}") ``` ### 关键点说明 - **编码方式**：直接使用实数表示个体，适用于连续变量优化问题[^1]。 - **选择机制**：采用锦标赛选择，增强算法的多样性与收敛性[^3]。 - **交叉操作**：使用模拟二进制交叉（SBX），在连续空间中生成高质量的子代。 - **变异策略**：多项式变异引入局部扰动，防止早熟收敛[^3]。 - **种群更新**：采用精英保留策略，确保每一代最优个体不被丢失[^4]。