5.01py打卡-CSDN博客

本文链接：https://blog.csdn.net/2403_89678402/article/details/147646774

@浙大疏锦行

超参数调整专题2

1. 三种启发式算法的示例代码：遗传算法、粒子群算法、退火算法

2. 学习优化算法的思路（避免浪费无效时间）

题目：今天以自由探索的思路为主，尝试检索资料、视频、文档，用尽可能简短但是清晰的语言看是否能说清楚这三种算法每种算法的实现逻辑，帮助更深入的理解。

import pandas as pd    #用于数据处理和分析，可处理表格数据。
import numpy as np     #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt    #用于绘制各种类型的图表
import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
# 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False    # 正常显示负号
data  = pd.read_csv('heart.csv')
# 提取连续值特征
continuous_features = ['age', 'trestbps', 'chol', 'thalach', 'oldpeak']
# 提取离散值特征
discrete_features = ['sex', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'ca', 'thal', 'target']
# 定义映射字典
mapping = {
    'cp': {0: 0, 1: 1, 2: 2, 3: 3},
    'restecg': {0: 0, 1: 1, 2: 2},
    'slope': {0: 0, 1: 1, 2: 2},
    'ca': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4},
    'thal': {0: 0, 1: 1, 2: 2, 3: 3}
}
# 使用映射字典进行转换
for feature, mapping in mapping.items():
    data[feature] = data[feature].map(mapping)
columns_to_encode = ['sex','fbs','exang']
# Purpose 独热编码
data = pd.get_dummies(data, columns=columns_to_encode)
data2 = pd.read_csv("heart.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
for i in data.columns:
    if i not in data2.columns:
        list_final.append(i) # 这里打印出来的就是独热编码后的特征名
for i in list_final:
    data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名
# 划分训练集和测试机
from sklearn.model_selection import train_test_split
X = data.drop(['target'], axis=1)  # 特征，axis=1表示按列删除
y = data['target']  # 标签
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集
import lightgbm as lgb #LightGBM分类器
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标
from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵
import warnings #用于忽略警告信息
import time
warnings.filterwarnings("ignore") # 忽略所有警告信息
print("--- 1. 默认参数LightGBM (训练集 -> 测试集) ---")
start_time = time.time() # 记录开始时间
lgb_model = lgb.LGBMClassifier(random_state=42)
lgb_model.fit(X_train, y_train) # 在训练集上训练
lgb_pred = lgb_model.predict(X_test) # 在测试集上预测
end_time = time.time() # 记录结束时间
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认LightGBM 在测试集上的分类报告：")
print(classification_report(y_test, lgb_pred))
print("默认LightGBM 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, lgb_pred))
from deap import base, creator, tools, algorithms # DEAP是一个用于遗传算法和进化计算的Python库
import random
# --- 2. 遗传算法优化LightGBM ---
print("\n--- 2. 遗传算法优化LightGBM (训练集 -> 测试集) ---")
# 定义适应度函数和个体类型
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
# 定义超参数范围
n_estimators_range = (50, 200)
max_depth_range = (10, 30)
num_leaves_range = (20, 40)
# 初始化工具盒
toolbox = base.Toolbox()
# 定义基因生成器
toolbox.register("attr_n_estimators", random.randint, *n_estimators_range)
toolbox.register("attr_max_depth", random.randint, *max_depth_range)
toolbox.register("attr_num_leaves", random.randint, *num_leaves_range)
# 定义个体生成器
toolbox.register("individual", tools.initCycle, creator.Individual,
                (toolbox.attr_n_estimators, toolbox.attr_max_depth,
                toolbox.attr_num_leaves), n=1)
# 定义种群生成器
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
# 定义评估函数
def evaluate(individual):
    n_estimators, max_depth, num_leaves= individual
    model = lgb.LGBMClassifier(n_estimators=n_estimators,
                                max_depth=max_depth,
                                um_leaves=num_leaves,
                                random_state=42)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    return accuracy,
# 注册评估函数
toolbox.register("evaluate", evaluate)
# 注册遗传操作
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutUniformInt, low=[n_estimators_range[0],     max_depth_range[0],num_leaves_range[0]],
up=[n_estimators_range[1], max_depth_range[1],num_leaves_range[1]], indpb=0.1)
toolbox.register("select", tools.selTournament, tournsize=3)
# 初始化种群
pop = toolbox.population(n=20)
# 遗传算法参数
NGEN = 10
CXPB = 0.5
MUTPB = 0.2
start_time = time.time()
# 运行遗传算法
for gen in range(NGEN):
    offspring = algorithms.varAnd(pop, toolbox, cxpb=CXPB, mutpb=MUTPB)
    fits = toolbox.map(toolbox.evaluate, offspring)
    for fit, ind in zip(fits, offspring):
        ind.fitness.values = fit
    pop = toolbox.select(offspring, k=len(pop))
end_time = time.time()
# 找到最优个体
best_ind = tools.selBest(pop, k=1)[0]
best_n_estimators, best_max_depth, best_num_leaves= best_ind
print(f"遗传算法优化耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", {
    'n_estimators': best_n_estimators,
    'max_depth': best_max_depth,
    'num_leaves': best_num_leaves,
})
# 使用最佳参数的模型进行预测
best_model = lgb.LGBMClassifier(n_estimators=best_n_estimators,
                                    max_depth=best_max_depth,
                                    num_leaves=best_num_leaves,
                                    random_state=42)
best_model.fit(X_train, y_train)
best_pred = best_model.predict(X_test)
print("\n遗传算法优化后的LightGBM 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("遗传算法优化后的LightGBM 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))

1. 遗传算法 (Genetic Algorithm, GA)：模拟生物进化

想象场景： 假设你是一个育种专家，想培育出一种产量最高的玉米。
核心概念：
- 基因 (Gene): 玉米的各种特征，比如高度、叶子大小、抗病性等等，这些都是基因。
- 染色体 (Chromosome): 玉米的所有基因组合在一起，就形成了一条染色体。你可以理解为玉米的“基因组”。
- 种群 (Population): 你有很多株玉米，它们组成了一个种群。
- 适应度 (Fitness): 玉米的产量，产量越高，适应度越高，说明这株玉米越优秀。
算法步骤：
1. 初始化种群： 随机生成一批玉米（也就是随机生成一批“染色体”）。
2. 评估适应度： 测量每株玉米的产量（计算每条“染色体”的“适应度”）。
3. 选择 (Selection): 选择产量最高的那些玉米，让它们有机会繁殖后代（选择“适应度”高的“染色体”）。你可以想象成“优胜劣汰”。
4. 交叉 (Crossover): 让选出来的玉米进行杂交，产生新的玉米（让选出来的“染色体”进行“交叉”，产生新的“染色体”）。你可以理解为“基因重组”。
5. 变异 (Mutation): 偶尔让一些玉米发生基因突变（随机改变“染色体”上的某些“基因”）。你可以理解为“给种群带来新的可能性”。
6. 重复： 重复步骤2-5，直到找到产量最高的玉米，或者达到你设定的迭代次数。
优化逻辑： 通过模拟生物进化中的“优胜劣汰”、“基因重组”和“基因突变”，不断地改进玉米的基因，最终找到产量最高的玉米。

2. 粒子群算法 (Particle Swarm Optimization, PSO)：模拟鸟群觅食

想象场景： 假设有一群鸟在寻找食物，但是它们不知道食物在哪里。
核心概念：
- 粒子 (Particle): 每只鸟就是一个粒子。
- 位置 (Position): 每只鸟当前所在的位置，代表一个可能的解决方案。
- 速度 (Velocity): 每只鸟飞行的速度和方向，决定了它下一步飞向哪里。
- 个体最佳位置 (Personal Best Position, pBest): 每只鸟自己找到的最好的食物位置。
- 全局最佳位置 (Global Best Position, gBest): 整个鸟群中找到的最好的食物位置。
算法步骤：
1. 初始化粒子群： 随机生成一群鸟（随机生成一批“粒子”，每个粒子都有一个“位置”和“速度”）。
2. 评估适应度： 评估每只鸟当前位置的食物丰富程度（计算每个“粒子”当前“位置”的“适应度”）。
3. 更新个体最佳位置： 如果某只鸟当前位置的食物比它之前找到的最好的位置还要好，就更新它的“个体最佳位置”。
4. 更新全局最佳位置： 如果某只鸟当前位置的食物比整个鸟群之前找到的最好的位置还要好，就更新“全局最佳位置”。
5. 更新速度和位置： 每只鸟根据自己的“个体最佳位置”和“全局最佳位置”来调整自己的飞行速度和方向（根据“pBest”和“gBest”来更新“速度”和“位置”）。你可以理解为“向自己和群体中最优秀的个体学习”。
6. 重复： 重复步骤2-5，直到找到食物最丰富的位置，或者达到你设定的迭代次数。
优化逻辑： 通过模拟鸟群觅食的行为，让每个粒子都向自己和群体中最优秀的个体学习，从而不断地向食物最丰富的位置靠拢。

3. 退火算法 (Simulated Annealing, SA)：模拟金属退火

想象场景： 假设你要打造一把锋利的宝剑，需要对金属进行退火处理。
核心概念：
- 状态 (State): 金属当前的内部结构，代表一个可能的解决方案。
- 能量 (Energy): 金属内部结构的能量，能量越低，结构越稳定，宝剑的质量越好。
- 温度 (Temperature): 控制退火过程的参数，温度越高，金属内部的原子越活跃，更容易跳出局部最优解。
算法步骤：
1. 初始化状态： 随机生成一个金属的内部结构（随机生成一个“状态”）。
2. 计算能量： 计算当前金属内部结构的能量（计算当前“状态”的“能量”）。
3. 扰动： 稍微改变金属的内部结构（对当前“状态”进行一个小的扰动，产生一个新的“状态”）。
4. 计算新能量： 计算新的金属内部结构的能量（计算新的“状态”的“能量”）。
5. 接受或拒绝：
  - 如果新的能量比旧的能量低，就接受新的状态（如果新的“能量”比旧的“能量”低，就接受新的“状态”）。这相当于“无条件接受更好的解”。
  - 如果新的能量比旧的能量高，就以一定的概率接受新的状态（如果新的“能量”比旧的“能量”高，就以一定的概率接受新的“状态”）。这个概率取决于当前的“温度”，温度越高，接受的概率越高。这相当于“以一定的概率接受更差的解，避免陷入局部最优”。
6. 降低温度： 逐渐降低温度，让金属内部的原子逐渐稳定下来（逐渐降低“温度”，让算法逐渐收敛）。
7. 重复： 重复步骤3-6，直到温度降到足够低，或者达到你设定的迭代次数。
优化逻辑： 通过模拟金属退火的过程，让算法在搜索过程中既能找到更好的解，又能以一定的概率接受更差的解，从而避免陷入局部最优解，最终找到全局最优解。