基于鸢尾花数据集的PSO-lightGBM

PSO-lightGBM算法是一种基于粒子群优化和lightGBM算法的集成学习方法，用于解决分类和回归问题。鸢尾花数据集是一个经典的分类问题，包含三种不同的鸢尾花，每种花有四个特征：萼片长度、萼片宽度、花瓣长度、花瓣宽度。该数据集共有150个样本。

以下是基于鸢尾花数据集的PSO-lightGBM算法的步骤：

1. 导入数据集并进行数据预处理，将数据集分为训练集和测试集。

2. 定义适应度函数，即使用lightGBM算法对训练集进行训练，并在测试集上进行预测，计算预测准确率作为适应度值。

3. 定义粒子的初始位置和速度，即lightGBM算法的超参数，如学习率、树的深度、叶子节点数等。

4. 在每个迭代中，计算每个粒子的适应度值，并更新全局最优位置和局部最优位置。

5. 根据全局最优位置和局部最优位置更新粒子的速度和位置。

6. 重复步骤4和步骤5，直到达到最大迭代次数或满足停止条件。

7. 使用全局最优位置的超参数训练lightGBM模型，并在测试集上进行预测，计算预测准确率。

8. 输出模型预测准确率和超参数。

代码示例：

import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

# 导入数据集
iris = load_iris()
X = iris.data
y = iris.target

# 数据预处理
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义适应度函数
def fitness(params):
    clf = lgb.LGBMClassifier(**params)
    clf.fit(X_train, y_train)
    y_pred = clf.predict(X_test)
    return accuracy_score(y_test, y_pred)

# 定义粒子群优化算法
class PSO:
    def __init__(self, n_particles, dim, max_iter, w, c1, c2, v_min, v_max, fitness_func):
        self.n_particles = n_particles
        self.dim = dim
        self.max_iter = max_iter
        self.w = w
        self.c1 = c1
        self.c2 = c2
        self.v_min = v_min
        self.v_max = v_max
        self.fitness_func = fitness_func
        self.global_best = None
        self.particle_best = None
        self.swarm = None

    def init_swarm(self):
        self.swarm = np.random.uniform(low=-1, high=1, size=(self.n_particles, self.dim))
        self.particle_best = self.swarm
        self.global_best = self.swarm[np.argmin([self.fitness_func(params) for params in self.swarm])]

    def run(self):
        self.init_swarm()
        velocity = np.zeros((self.n_particles, self.dim))
        for i in range(self.max_iter):
            for j in range(self.n_particles):
                r1 = np.random.random(self.dim)
                r2 = np.random.random(self.dim)
                velocity[j] = self.w * velocity[j] + \
                              self.c1 * r1 * (self.particle_best[j] - self.swarm[j]) + \
                              self.c2 * r2 * (self.global_best - self.swarm[j])
                velocity[j] = np.clip(velocity[j], self.v_min, self.v_max)
                self.swarm[j] += velocity[j]
                self.swarm[j] = np.clip(self.swarm[j], -1, 1)
                if self.fitness_func(self.swarm[j]) > self.fitness_func(self.particle_best[j]):
                    self.particle_best[j] = self.swarm[j]
                if self.fitness_func(self.swarm[j]) > self.fitness_func(self.global_best):
                    self.global_best = self.swarm[j]

        return self.global_best

# 设置粒子群优化算法的参数
n_particles = 50
dim = 6
max_iter = 100
w = 0.9
c1 = 2
c2 = 2
v_min = -0.5
v_max = 0.5

# 定义超参数搜索空间
param_space = {
    'learning_rate': np.linspace(0.01, 0.1, dim),
    'num_leaves': np.arange(10, 60, 10),
    'max_depth': np.arange(3, 8),
    'min_child_samples': np.arange(5, 20, 5),
    'subsample': np.linspace(0.5, 1, dim),
    'colsample_bytree': np.linspace(0.5, 1, dim)
}

# 运行粒子群优化算法搜索最优超参数
pso = PSO(n_particles=n_particles, dim=dim, max_iter=max_iter, w=w, c1=c1, c2=c2, v_min=v_min, v_max=v_max, fitness_func=fitness)
params = pso.run()

# 输出最优超参数和预测准确率
clf = lgb.LGBMClassifier(**params)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print('Best Parameters:', params)
print('Accuracy:', accuracy_score(y_test, y_pred))