接着上一个问题，请使用鲸鱼优化算法优化XGBoost模型的参数，并且给出鲸鱼优化算法的原始代码和绘制学习曲线

好的，以下是使用鲸鱼优化算法优化XGBoost模型参数的步骤和代码。

步骤：

1. 定义目标函数：即需要被最小化的损失函数，例如均方误差(MSE)、平均绝对误差(MAE)等。

2. 定义超参数空间：即待优化的模型参数的取值范围。

3. 初始化鲸群：即随机生成一些初始鲸鱼个体。

4. 计算适应度：即计算每个鲸鱼个体在目标函数下的表现。

5. 更新位置：即根据鲸鱼的适应度和位置信息，更新鲸鱼的位置。

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

代码：

import xgboost as xgb
from whale_optimization import WhaleOptimizationAlgorithm as WOA
from sklearn.datasets import load_boston
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

# 加载数据
data = load_boston()
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)

# 定义目标函数
def objective_func(params):
    params['max_depth'] = int(params['max_depth'])
    dtrain = xgb.DMatrix(X_train, label=y_train)
    dtest = xgb.DMatrix(X_test, label=y_test)
    model = xgb.train(params, dtrain)
    y_pred = model.predict(dtest)
    mse = mean_squared_error(y_test, y_pred)
    return mse

# 定义超参数空间
params_space = {
    'eta': (0.01, 1),
    'max_depth': (2, 10),
    'subsample': (0.5, 1),
    'colsample_bytree': (0.5, 1),
    'min_child_weight': (1, 10)
}

# 初始化鲸群
woa = WOA(objective_func, params_space, max_iter=50, verbose=True)

# 运行优化算法
best_params, best_score = woa.optimize()

# 输出最佳参数和分数
print('Best score:', best_score)
print('Best params:', best_params)

# 训练最佳模型并计算测试集上的MSE
best_params['max_depth'] = int(best_params['max_depth'])
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
model = xgb.train(best_params, dtrain)
y_pred = model.predict(dtest)
mse = mean_squared_error(y_test, y_pred)
print('MSE:', mse)

鲸鱼优化算法的原始代码如下：

import numpy as np

class WhaleOptimizationAlgorithm:
    def __init__(self, objective_func, params_space, max_iter=100, population_size=10, a=2, b=1, c=0.5, l=1.5, verbose=False):
        self.objective_func = objective_func
        self.params_space = params_space
        self.max_iter = max_iter
        self.population_size = population_size
        self.a = a
        self.b = b
        self.c = c
        self.l = l
        self.verbose = verbose

    def optimize(self):
        # 初始化种群
        population = self.initialize_population()
        best_whale = None
        best_score = float('inf')

        # 迭代优化
        for i in range(self.max_iter):
            # 计算适应度
            fitness = self.calculate_fitness(population)

            # 更新最佳鲸鱼
            min_index = np.argmin(fitness)
            if fitness[min_index] < best_score:
                best_whale = population[min_index]
                best_score = fitness[min_index]

            if self.verbose:
                print(f'Iteration {i}: Best score = {best_score}')

            # 更新位置
            for j in range(self.population_size):
                a = 2 - i * ((2) / self.max_iter)
                r1 = np.random.uniform(0, 1)
                r2 = np.random.uniform(0, 1)
                A = 2 * a * r1 - a
                C = 2 * r2
                p = np.random.uniform(0, 1)

                if p < 0.5:
                    if np.abs(A) >= 1:
                        rand_leader_index = np.random.randint(0, self.population_size - 1)
                        X_rand = population[rand_leader_index]
                        D_X_rand = np.abs(C * X_rand - population[j])
                        new_position = X_rand - A * D_X_rand
                    else:
                        D_best = np.abs(C * best_whale - population[j])
                        new_position = best_whale - A * D_best
                else:
                    distance_to_best = np.abs(best_whale - population[j])
                    new_position = distance_to_best * np.exp(self.b * self.l) * np.cos(2 * np.pi * self.l) + best_whale

                population[j] = self.clip_position(new_position)

        # 返回最佳参数和分数
        best_params = self.decode_position(best_whale)
        return best_params, best_score

    def initialize_population(self):
        population = []
        for i in range(self.population_size):
            whale = np.zeros(len(self.params_space))
            for j, param_name in enumerate(self.params_space):
                param_range = self.params_space[param_name]
                whale[j] = np.random.uniform(*param_range)
            population.append(whale)
        return np.array(population)

    def calculate_fitness(self, population):
        fitness = []
        for whale in population:
            params = self.decode_position(whale)
            score = self.objective_func(params)
            fitness.append(score)
        return np.array(fitness)

    def decode_position(self, whale):
        params = {}
        for j, param_name in enumerate(self.params_space):
            param_range = self.params_space[param_name]
            param_value = param_range[0] + whale[j] * (param_range[1] - param_range[0])
            params[param_name] = param_value
        return params

    def clip_position(self, position):
        for i, param_name in enumerate(self.params_space):
            param_range = self.params_space[param_name]
            position[i] = np.clip(position[i], param_range[0], param_range[1])
        return position

绘制学习曲线的代码如下：

import matplotlib.pyplot as plt

# 记录每次迭代的最佳分数
scores = []
woa = WOA(objective_func, params_space, max_iter=50, verbose=True)
for i in range(woa.max_iter):
    best_params, best_score = woa.optimize()
    scores.append(best_score)

# 绘制学习曲线
plt.plot(range(len(scores)), scores)
plt.xlabel('Iteration')
plt.ylabel('Best score')
plt.show()

这段代码会运行50次优化算法，并记录每次迭代得到的最佳分数，最后绘制出学习曲线。