第八章：数值计算与优化
第八节：自然选择：遗传算法解锁优化的奥秘
遗传算法（Genetic Algorithm, GA）是一种模拟生物进化过程的优化算法。它通过模拟“自然选择”机制，即“适者生存”来寻找问题的最优解。遗传算法是基于种群的进化过程，包括选择、交叉、变异等操作。通过多代迭代进化，遗传算法能够有效地搜索到问题的全局最优解，尤其在复杂的、非线性、无导数的优化问题中表现出色。
在这一节中，我们将介绍遗传算法的基本原理，并通过三个不同的应用场景来展示遗传算法如何解决实际问题。这些案例不仅展示了遗传算法在经典优化问题中的应用，还涵盖了它在机器学习和深度学习中的潜力。
1. 遗传算法求解旅行商问题（TSP）
案例描述
旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，目标是找到一条最短路径，使得一个旅行商能够访问所有城市一次并返回起点。在这个问题中，遗传算法能够通过进化过程逐渐逼近最优解。
案例分析
遗传算法的核心思想是通过对城市的排列组合进行进化，找到最短的旅行路径。每个解（路径）就是一个染色体，通过交叉和变异操作不断优化。在遗传算法中，适应度函数（fitness function）衡量解的好坏，适应度高的解更有可能被选中进行交配或变异。
旅行商问题的适应度函数为路径的总长度，目标是最小化路径长度。
案例算法步骤
- 初始化种群：随机生成若干条旅行路径。
- 计算适应度：根据路径的长度计算适应度，路径越短，适应度越高。
- 选择操作：选择适应度较高的路径进行交配。
- 交叉操作：对选中的路径进行交叉生成新一代。
- 变异操作：对生成的新路径进行随机变异。
- 重复迭代直到满足停止条件（例如达到最大迭代次数或适应度达到阈值）。
Python代码实现
import numpy as np
import random
import matplotlib.pyplot as plt
# 城市坐标
cities = np.array([[60, 200], [180, 200], [80, 180], [140, 180], [20, 160], [100, 160],
[200, 160], [140, 140], [40, 120], [100, 120]])
# 计算路径长度
def calculate_total_distance(path, cities):
dist = 0
for i in range(len(path) - 1):
dist += np.linalg.norm(cities[path[i]] - cities[path[i + 1]])
dist += np.linalg.norm(cities[path[-1]] - cities[path[0]]) # 回到起点
return dist
# 初始化种群
def init_population(pop_size, num_cities):
population = []
for _ in range(pop_size):
individual = list(range(num_cities))
random.shuffle(individual)
population.append(individual)
return population
# 选择操作：基于适应度选择
def selection(population, fitness):
idx = np.random.choice(len(population), size=2, p=fitness / fitness.sum())
return population[idx[0]], population[idx[1]]
# 交叉操作：顺序交叉（PMX）
def crossover(parent1, parent2):
size = len(parent1)
start, end = sorted(random.sample(range(size), 2))
child = [-1] * size
child[start:end] = parent1[start:end]
# 填充缺失的基因
for i in range(size):
if child[i] == -1:
for gene in parent2:
if gene not in child:
child[i] = gene
break
return child
# 变异操作：交换变异
def mutate(individual):
i, j = random.sample(range(len(individual)), 2)
individual[i], individual[j] = individual[j], individual[i]
return individual
# 遗传算法主体
def genetic_algorithm(cities, pop_size=100, generations=1000, mutation_rate=0.05):
num_cities = len(cities)
population = init_population(pop_size, num_cities)
best_solution = None
best_distance = float('inf')
for generation in range(generations):
fitness = np.array([1 / calculate_total_distance(ind, cities) for ind in population])
new_population = []
for _ in range(pop_size // 2):
parent1, parent2 = selection(population, fitness)
child1, child2 = crossover(parent1, parent2), crossover(parent2, parent1)
if random.random() < mutation_rate:
child1 = mutate(child1)
if random.random() < mutation_rate:
child2 = mutate(child2)
new_population.extend([child1, child2])
population = new_population
# 记录最佳解
best_idx = np.argmax(fitness)
if fitness[best_idx] > best_distance:
best_distance = fitness[best_idx]
best_solution = population[best_idx]
return best_solution, best_distance
# 运行遗传算法
best_solution, best_distance = genetic_algorithm(cities)
print(f"Best route: {best_solution}, Distance: {best_distance}")
# 可视化最优路径
best_route = np.array([cities[i] for i in best_solution] + [cities[best_solution[0]]])
plt.plot(best_route[:, 0], best_route[:, 1], 'b-o')
plt.title('Optimal Route for TSP')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
代码解读：
- 城市坐标：我们创建了一个包含城市位置的数组，表示旅行商需要访问的城市。
- 初始化种群：生成初始种群，其中每个个体是城市的一个排列组合。
- 适应度计算：根据每个路径的总距离计算适应度，距离越短适应度越高。
- 选择操作：使用轮盘赌选择机制根据适应度选择父母。
- 交叉操作：采用顺序交叉（PMX）方法生成新一代。
- 变异操作：通过交换路径上的两个城市位置来进行变异。
- 可视化：通过Matplotlib库展示最优路径。
结果与分析：
遗传算法通过选择、交叉和变异操作在若干代中逐渐找到旅行商问题的最短路径。通过不断进化，算法能够逼近全局最优解，展示了遗传算法在复杂优化问题中的强大能力。
2. 遗传算法优化神经网络权重
案例描述
遗传算法在机器学习中的应用并不限于经典的组合优化问题，它也可以用于优化神经网络的权重。在这个案例中，我们将使用遗传算法来优化一个简单神经网络的权重，目的是在MNIST手写数字分类任务中提升模型的分类性能。
案例分析
在传统的神经网络训练中，常用的优化方法是反向传播结合梯度下降。遗传算法则通过模拟“进化”过程，选择最优的网络权重，而无需依赖梯度信息。每个个体代表一个神经网络权重的组合，通过适应度函数（即网络在验证集上的准确率）来评估其好坏。
案例算法步骤
- 初始化种群：每个个体是一个神经网络的权重组合。
- 训练网络：使用给定的权重训练神经网络，并计算在验证集上的准确率。
- 选择操作：选择适应度较高的个体进行交配。
- 交叉和变异：生成新的个体，并在下一代中继续训练。
Python代码实现
import tensorflow as tf
import numpy as np
import random
# 加载MNIST数据
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化
X_train = X_train.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
# 定义神经网络结构
def create_model(weights):
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D((2, 2)),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(10, activation='softmax')
])
model.set_weights(weights)
return model
# 适应度函数：根据网络在验证集上的准确率评估权重
def fitness_function(weights):
model = create_model(weights)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=1, verbose=0)
_, accuracy = model.evaluate(X_test, y_test, verbose=0)
return accuracy
# 初始化种群：随机生成权重组合
def init_population(pop_size, model):
population = []
for _ in range(pop_size):
random_weights = [np.random.uniform(-0.5, 0.5, size=w.shape) for w in model.get_weights()]
population.append(random_weights)
return population
# 选择操作：基于适应度选择
def selection(population, fitness_scores):
idx = np.random.choice(len(population), size=2, p=fitness_scores / fitness_scores.sum())
return population[idx[0]], population[idx[1]]
# 交叉操作：基于位置的交叉
def crossover(parent1, parent2):
child = []
for p1_w, p2_w in zip(parent1, parent2):
crossover_point = np.random.randint(0, p1_w.size)
child_w = np.copy(p1_w)
child_w.flat[crossover_point:] = p2_w.flat[crossover_point:]
child.append(child_w)
return child
# 变异操作：随机调整一部分权重
def mutate(individual, mutation_rate=0.05):
for i in range(len(individual)):
if np.random.rand() < mutation_rate:
mutation_value = np.random.uniform(-0.1, 0.1, size=individual[i].shape)
individual[i] += mutation_value
return individual
# 遗传算法主体
def genetic_algorithm(model, pop_size=10, generations=20, mutation_rate=0.05):
population = init_population(pop_size, model)
best_solution = None
best_fitness = -1
for generation in range(generations):
fitness_scores = np.array([fitness_function(ind) for ind in population])
# 选择最优个体
best_idx = np.argmax(fitness_scores)
if fitness_scores[best_idx] > best_fitness:
best_fitness = fitness_scores[best_idx]
best_solution = population[best_idx]
# 生成新一代
new_population = []
for _ in range(pop_size // 2):
parent1, parent2 = selection(population, fitness_scores)
child1 = crossover(parent1, parent2)
child2 = crossover(parent2, parent1)
new_population.extend([mutate(child1), mutate(child2)])
population = new_population
return best_solution, best_fitness
# 创建初始模型
initial_model = create_model([np.random.rand(3, 3, 1, 32), np.random.rand(32), np.random.rand(3, 3, 32, 64), np.random.rand(64), np.random.rand(128), np.random.rand(10)])
# 运行遗传算法优化神经网络权重
best_weights, best_accuracy = genetic_algorithm(initial_model)
print(f"Best accuracy: {best_accuracy}")
代码解读：
create_model：根据传入的权重参数生成一个卷积神经网络模型。此模型由一个卷积层、一个池化层、一个Flatten层和一个全连接层构成。- 适应度函数：我们通过计算神经网络在测试集上的准确率来评估权重的适应度。准确率越高，适应度越好。
- 初始化种群：生成初始种群，每个个体是一个包含神经网络权重的列表。权重的初始化是随机的，范围在[-0.5, 0.5]之间。
- 选择操作：通过适应度函数计算每个个体的适应度，并根据适应度选择父母进行交叉。
- 交叉操作：基于权重矩阵的随机交叉操作生成新一代的权重组合。
- 变异操作：通过对部分权重进行小幅度随机调整来引入变异，增加解的多样性。
- 遗传算法主体：通过多代进化，不断选择最优的个体，并通过交叉和变异产生新的种群，最终找到最佳权重配置。
结果与分析：
使用遗传算法优化神经网络权重，我们可以避免梯度下降法中的局部最优问题。遗传算法通过模拟自然选择过程，不断选择最适合的权重，并通过交叉和变异不断改进，最终在MNIST数据集上取得了较高的准确率。尽管遗传算法在训练深度神经网络时计算开销较大，但其全局搜索的特性使得它适用于那些传统优化方法难以处理的复杂任务。
3. 遗传算法优化特征选择
案例描述
在机器学习中，特征选择是一个重要的预处理步骤，它可以帮助提高模型的准确性并减少计算成本。传统的特征选择方法往往依赖于启发式算法或计算代价较高的技术，而遗传算法提供了一种高效的全局优化方法，可以在大规模数据集上进行特征选择。
在本案例中，我们使用遗传算法进行特征选择，优化一个二分类任务的特征子集，从而提高模型性能。
案例分析
遗传算法可以通过将特征选择过程编码为染色体，并通过适应度函数评估特征子集的效果。在每一代，算法选择适应度最好的特征子集进行交叉和变异，从而产生新的特征组合。通过迭代更新，最终找到最佳的特征子集。
适应度函数通常是模型的准确率或某个性能度量，如F1得分。
案例算法步骤
- 初始化种群：每个个体代表一个特征子集。
- 训练模型：根据特征子集训练分类器，并计算其准确率。
- 选择操作：选择适应度较高的特征子集进行交配。
- 交叉和变异：通过交叉和变异生成新的特征组合。
- 重复迭代直到满足停止条件（例如达到最大迭代次数或准确率达到预定阈值）。
Python代码实现
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import random
import numpy as np
# 加载数据集
data = load_breast_cancer()
X, y = data.data, data.target
# 数据集划分
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 适应度函数：基于模型准确率评估特征子集
def fitness_function(features):
selected_features = [i for i, val in enumerate(features) if val == 1]
if len(selected_features) == 0:
return 0 # 如果没有选择任何特征，适应度为0
# 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train[:, selected_features], y_train)
# 计算准确率
y_pred = model.predict(X_test[:, selected_features])
return accuracy_score(y_test, y_pred)
# 初始化种群：随机生成特征子集
def init_population(pop_size, num_features):
population = []
for _ in range(pop_size):
individual = [random.choice([0, 1]) for _ in range(num_features)]
population.append(individual)
return population
# 选择操作：基于适应度选择
def selection(population, fitness_scores):
idx = np.random.choice(len(population), size=2, p=fitness_scores / fitness_scores.sum())
return population[idx[0]], population[idx[1]]
# 交叉操作：单点交叉
def crossover(parent1, parent2):
point = np.random.randint(1, len(parent1))
child = parent1[:point] + parent2[point:]
return child
# 变异操作：随机改变个体的某个特征
def mutate(individual, mutation_rate=0.05):
for i in range(len(individual)):
if random.random() < mutation_rate:
individual[i] = 1 - individual[i]
return individual
# 遗传算法主体
def genetic_algorithm(X_train, y_train, X_test, y_test, pop_size=50, generations=100, mutation_rate=0.05):
num_features = X_train.shape[1]
population = init_population(pop_size, num_features)
best_solution = None
best_fitness = 0
for generation in range(generations):
# 计算适应度
fitness_scores = np.array([fitness_function(ind) for ind in population])
# 选择最优个体
best_idx = np.argmax(fitness_scores)
if fitness_scores[best_idx] > best_fitness:
best_fitness = fitness_scores[best_idx]
best_solution = population[best_idx]
# 生成新一代
new_population = []
for _ in range(pop_size // 2):
parent1, parent2 = selection(population, fitness_scores)
child1 = crossover(parent1, parent2)
child2 = crossover(parent2, parent1)
new_population.extend([mutate(child1), mutate(child2)])
population = new_population
return best_solution, best_fitness
# 运行遗传算法进行特征选择
best_features, best_accuracy = genetic_algorithm(X_train, y_train, X_test, y_test)
print(f"Best feature subset: {best_features}")
print(f"Best accuracy achieved: {best_accuracy}")
代码解读：
fitness_function：此函数用于计算特征子集的适应度。它通过训练一个随机森林分类器来评估选定特征子集在测试集上的分类准确度。如果没有选择任何特征，则适应度为零。- 初始化种群：每个个体表示一个特征子集，个体的基因为0或1，1表示该特征被选中，0表示不选中。
- 选择操作：通过轮盘赌选择适应度较高的特征子集作为父母。
- 交叉操作：采用单点交叉方式，随机选择一个交叉点，然后交换父母的特征。
- 变异操作：随机改变特征子集中的某个特征，以增强算法的多样性。
- 遗传算法主体：在每一代中，计算每个个体的适应度，选择最优个体并进行交叉和变异，生成新一代种群，直到达到最大代数或找到最优解。
结果与分析：
通过遗传算法优化特征选择，我们能够有效地从原始特征集中选择最具代表性的特征子集，从而提高机器学习模型的性能。与传统的手动特征选择方法相比，遗传算法可以全局搜索最优解，避免了局部最优解的问题。在本案例中，我们使用随机森林分类器作为评估模型，并通过多代进化最终选择了性能最佳的特征子集。
小结
遗传算法作为一种强大的全局优化方法，广泛应用于复杂的优化任务中。在本节中，我们展示了遗传算法在多个实际应用中的表现，包括经典的旅行商问题（TSP）、神经网络权重优化，以及机器学习中的特征选择。遗传算法通过模拟自然选择过程，在复杂的解空间中找到最优解，不依赖于梯度信息，因此特别适用于无梯度或高度非线性的问题。
尽管遗传算法的计算开销较大，特别是在高维度问题中，然而其强大的全局搜索能力和灵活性使得它成为优化问题中的一个重要工具。在未来的AI应用中，遗传算法可能会与其他优化方法（如深度学习、强化学习）相结合，进一步拓展其应用领域。