4. Scikit-learn 高级主题

4. Scikit-learn 高级主题

Scikit-learn 高级主题详解与实践

Scikit-learn (也称为 sklearn) 是 Python 中最受欢迎的机器学习库之一，它提供了广泛的算法和工具，用于数据挖掘和数据分析。虽然 Scikit-learn 以其易用性而闻名，但其背后也蕴藏着许多高级主题，掌握这些主题能够帮助我们构建更强大、更灵活、更高效的机器学习模型。

本文将涵盖以下高级主题：

1. Pipeline (管道): 构建清晰、可复用的机器学习工作流。

2. ColumnTransformer (列转换器): 对不同类型的数据列应用不同的预处理方法。

3. Custom Transformer (自定义转换器): 扩展 Scikit-learn 功能，实现特定的数据转换逻辑。

4. 高级模型评估指标: 超越简单的准确率，选择更合适的评估指标。

5. 模型持久化 (Model Persistence): 保存和加载训练好的模型。

6. 模型调优与超参数优化 (Hyperparameter Optimization) 的高级方法: 探索更高效的超参数搜索策略。

1. Pipeline (管道): 构建清晰、可复用的机器学习工作流

概念详解:

Pipeline 是 Scikit-learn 中一个强大的工具，它允许我们将多个数据处理步骤和模型估计器串联起来，形成一个清晰、有序的工作流程。Pipeline 的核心思想是将数据预处理、特征工程和模型训练等步骤封装成一个单一的对象，使得整个流程更加简洁、可读、可维护。

主要优势:

• 代码简洁性: 将多个步骤整合到一个 Pipeline 中，减少冗余代码，提高代码可读性。

• 避免数据泄露 (Data Leakage): Pipeline 确保预处理步骤仅在训练数据上拟合，然后应用于训练和测试数据，防止信息泄露。

• 参数网格搜索 (GridSearchCV) 的便利性: Pipeline 可以与 GridSearchCV 等超参数优化工具无缝集成，方便对整个工作流程进行参数调优。

• 模型部署的便利性: 训练好的 Pipeline 可以作为一个整体保存和加载，方便模型部署和复用。

代码实践:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score
# 1. 加载数据 (示例使用 Pandas DataFrame)
data = {
    'numeric_feature': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'categorical_feature': ['A', 'B', 'A', 'C', 'B', 'C', 'A', 'B', 'C', 'A'],
    'target': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
}
df = pd.DataFrame(data)
# 2. 划分特征和目标变量
X = df[['numeric_feature', 'categorical_feature']]
y = df['target']
# 3. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4. 定义预处理步骤 (使用 ColumnTransformer)
numeric_features = ['numeric_feature']
categorical_features = ['categorical_feature']
preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), numeric_features),
        ('cat', OneHotEncoder(), categorical_features)])
# 5. 定义模型 (逻辑回归)
model = LogisticRegression()
# 6. 构建 Pipeline
pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                           ('classifier', model)])
# 7. 训练 Pipeline
pipeline.fit(X_train, y_train)
# 8. 预测并评估
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")
​

代码详解:

• 数据加载和划分: 首先加载示例数据，并将其划分为特征矩阵 X 和目标向量 y，然后进一步划分为训练集和测试集。

• ColumnTransformer 定义预处理: ColumnTransformer 用于对不同类型的列应用不同的预处理方法。

  • transformers 参数是一个列表，包含多个元组，每个元组定义一个转换步骤。

  • ('num', StandardScaler(), numeric_features): 对 numeric_features 列应用 StandardScaler (标准化)。

  • ('cat', OneHotEncoder(), categorical_features): 对 categorical_features 列应用 OneHotEncoder (独热编码)。

• 模型定义: 使用 LogisticRegression 作为分类模型。

• Pipeline 构建: Pipeline 接受一个 steps 参数，这是一个列表，包含多个元组，每个元组定义一个 Pipeline 步骤。

  • ('preprocessor', preprocessor): 第一个步骤是预处理器 preprocessor (我们之前定义的 ColumnTransformer)。

  • ('classifier', model): 第二个步骤是分类器 model (逻辑回归)。

• Pipeline 训练和预测: Pipeline 的 fit 方法会自动依次调用所有步骤的 fit 和 transform 方法，最后调用模型的 fit 方法。predict 方法也会自动依次调用所有步骤的 transform 方法，最后调用模型的 predict 方法。

总结: Pipeline 是构建清晰、可复用机器学习工作流的关键工具。它可以有效地组织数据预处理和模型训练步骤，提高代码可读性和可维护性，并避免数据泄露问题。

2. ColumnTransformer (列转换器): 对不同类型的数据列应用不同的预处理方法

概念详解:

ColumnTransformer 是 Scikit-learn 中用于处理异构数据 (包含不同类型列的数据) 的重要工具。在实际应用中，数据集通常包含数值型特征、类别型特征、文本特征等多种类型。ColumnTransformer 允许我们针对不同类型的列应用不同的预处理方法，例如：

• 数值型特征: 标准化 (StandardScaler)、归一化 (MinMaxScaler)、缺失值填充 (SimpleImputer)。

• 类别型特征: 独热编码 (OneHotEncoder)、标签编码 (LabelEncoder)、序数编码 (OrdinalEncoder)。

• 文本特征: 词袋模型 (CountVectorizer)、TF-IDF (TfidfVectorizer)。

主要优势:

• 灵活性: 可以为不同类型的列定制不同的预处理策略。

• 代码简洁性: 将列的预处理逻辑集中在一个 ColumnTransformer 中，提高代码可读性。

• 与 Pipeline 的良好集成: ColumnTransformer 通常作为 Pipeline 的一个预处理步骤使用，构建完整的机器学习工作流。

代码实践:

(上面的 Pipeline 示例中已经包含了 ColumnTransformer 的使用，这里再提供一个更详细的 ColumnTransformer 的单独示例)

import pandas as pd
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
# 1. 创建包含不同类型列的数据集
data = {
    'numeric_feature_1': [1, 2, 3, 4, 5, None, 7, 8, 9, 10], # 包含缺失值
    'numeric_feature_2': [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000],
    'categorical_feature_1': ['A', 'B', 'A', 'C', 'B', 'C', 'A', 'B', 'C', 'A'],
    'categorical_feature_2': ['X', 'Y', 'X', 'Z', 'Y', 'Z', 'X', 'Y', 'Z', 'X']
}
df = pd.DataFrame(data)
# 2. 定义特征列类型
numeric_features = ['numeric_feature_1', 'numeric_feature_2']
categorical_features = ['categorical_feature_1', 'categorical_feature_2']
# 3. 创建 ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', Pipeline([('imputer', SimpleImputer(strategy='mean')), # 数值型特征先填充缺失值
                          ('scaler', StandardScaler())]), numeric_features), # 再标准化
        ('cat', OneHotEncoder(), categorical_features)]) # 类别型特征独热编码
)
# 4. 应用 ColumnTransformer 进行预处理
X_processed = preprocessor.fit_transform(df)
# 5. 查看处理后的数据 (转换为 DataFrame 方便查看)
processed_feature_names = preprocessor.get_feature_names_out() # 获取处理后的特征名称
df_processed = pd.DataFrame(X_processed, columns=processed_feature_names)
print(df_processed)
​

代码详解:

• 创建包含不同类型列的数据集: 示例数据包含数值型特征 (numeric_feature_1, numeric_feature_2) 和类别型特征 (categorical_feature_1, categorical_feature_2)，其中 numeric_feature_1 列包含缺失值。

• 定义特征列类型: 明确指定哪些列是数值型特征，哪些是类别型特征。

• 创建 ColumnTransformer:

  • transformers 参数定义了针对不同列的预处理步骤。

  • ('num', Pipeline(...), numeric_features): 对 numeric_features 列应用一个 Pipeline。

    • Pipeline 内部包含两个步骤: SimpleImputer(strategy='mean') 用于使用均值填充缺失值，StandardScaler() 用于标准化。

  • ('cat', OneHotEncoder(), categorical_features): 对 categorical_features 列应用 OneHotEncoder 进行独热编码。

• 应用 ColumnTransformer: fit_transform 方法对输入数据 df 进行预处理。

• 查看处理后的数据: get_feature_names_out() 方法获取预处理后的特征名称，然后将处理后的 NumPy 数组转换为 DataFrame，方便查看和理解预处理结果。

总结: ColumnTransformer 是处理异构数据的利器。通过为不同类型的列定义不同的预处理策略，可以有效地提升模型的性能。结合 Pipeline 使用，可以构建更加强大和灵活的机器学习工作流。

3. Custom Transformer (自定义转换器): 扩展 Scikit-learn 功能，实现特定的数据转换逻辑

概念详解:

Scikit-learn 提供了丰富的预定义转换器 (例如 StandardScaler, OneHotEncoder)，但在实际应用中，我们可能需要根据具体业务需求，实现一些 Scikit-learn 没有提供的自定义数据转换逻辑。Custom Transformer 允许我们扩展 Scikit-learn 的功能，创建满足特定需求的转换器。

实现自定义转换器的关键:

• 继承 BaseEstimator 和 TransformerMixin 类: 这是创建 Scikit-learn 兼容转换器的标准做法。BaseEstimator 提供 get_params 和 set_params 方法，用于参数管理。TransformerMixin 提供 fit_transform 方法的默认实现。

• 实现 fit 和 transform 方法:

  • fit(self, X, y=None): 学习转换所需的参数 (例如，计算均值、标准差等)。fit 方法应该返回 self。

  • transform(self, X): 使用 fit 方法学习到的参数，对输入数据 X 进行转换，并返回转换后的数据。

代码实践:

import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin
# 1. 自定义转换器:  平方根转换
class SquareRootTransformer(BaseEstimator, TransformerMixin):
    def __init__(self):
        pass # 无需参数
    def fit(self, X, y=None):
        return self # fit 方法无需学习任何参数，直接返回 self
    def transform(self, X):
        return np.sqrt(X)
# 2. 创建示例数据
data = {'feature': [1, 4, 9, 16, 25]}
df = pd.DataFrame(data)
# 3. 创建自定义转换器实例
sqrt_transformer = SquareRootTransformer()
# 4. 应用自定义转换器
X_transformed = sqrt_transformer.fit_transform(df)
print(X_transformed)
# 5. 将自定义转换器集成到 Pipeline 中
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
pipeline = Pipeline(steps=[
    ('sqrt_transform', SquareRootTransformer()),
    ('scaler', StandardScaler()),
    ('linear_regression', LinearRegression())
])
# (假设有训练数据 X_train, y_train)
# pipeline.fit(X_train, y_train)
​

代码详解:

• 定义 SquareRootTransformer 类:

  • 继承 BaseEstimator 和 TransformerMixin。

  • __init__ 方法: 初始化方法，这里无需参数，所以为空。

  • fit 方法: fit 方法对于平方根转换来说不需要学习任何参数，所以直接返回 self。

  • transform 方法: 实现平方根转换逻辑，使用 np.sqrt(X) 对输入数据 X 进行平方根运算。

• 创建示例数据和转换器实例: 创建示例 DataFrame 和 SquareRootTransformer 的实例。

• 应用自定义转换器: 使用 fit_transform 方法应用自定义转换器。

• 将自定义转换器集成到 Pipeline 中: 展示如何将自定义转换器 SquareRootTransformer 集成到 Pipeline 中，与其他预处理步骤和模型一起使用。

更复杂的自定义转换器示例 (特征交叉):

class FeatureCrossTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, feature_names):
        self.feature_names = feature_names
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        X_transformed = pd.DataFrame(X, columns=self.feature_names) # 转换为 DataFrame 方便操作
        for i in range(len(self.feature_names)):
            for j in range(i + 1, len(self.feature_names)):
                feature1 = self.feature_names[i]
                feature2 = self.feature_names[j]
                new_feature_name = f'{feature1}_x_{feature2}' # 新特征名称
                X_transformed[new_feature_name] = X_transformed[feature1] * X_transformed[feature2] # 特征交叉
        return X_transformed.values # 返回 NumPy 数组
# ... (使用示例数据) ...
feature_cross_transformer = FeatureCrossTransformer(feature_names=['numeric_feature_1', 'numeric_feature_2'])
X_crossed = feature_cross_transformer.fit_transform(df)
print(X_crossed)
​

代码详解 (特征交叉):

• FeatureCrossTransformer 类:

  • __init__ 方法: 接受 feature_names 参数，指定要进行特征交叉的特征列名。

  • transform 方法:

    • 将输入数据 X 转换为 DataFrame。

    • 使用嵌套循环遍历 feature_names 列表，生成所有可能的特征组合。

    • 对于每对特征，计算它们的乘积，并作为新的特征添加到 DataFrame 中。

    • 返回包含原始特征和交叉特征的 NumPy 数组。

总结: 自定义转换器是 Scikit-learn 的强大扩展机制。通过实现自定义转换器，我们可以根据具体需求，灵活地进行数据预处理和特征工程，从而提升模型的性能和适应性。

4. 高级模型评估指标: 超越简单的准确率，选择更合适的评估指标

概念详解:

准确率 (Accuracy) 是分类问题中最常用的评估指标之一，但它并非总是最佳选择。在某些情况下，例如类别不平衡 (Imbalanced Dataset) 问题中，准确率可能会产生误导。为了更全面地评估模型性能，我们需要了解和使用更高级的模型评估指标。

常用的高级评估指标:

• 混淆矩阵 (Confusion Matrix): 展示模型预测结果的详细信息，包括真正例 (TP)、真反例 (TN)、假正例 (FP)、假反例 (FN)。

• 精确率 (Precision): 在所有被预测为正例的样本中，真正例的比例。关注模型预测正例的准确性。

• 召回率 (Recall): 在所有实际为正例的样本中，被模型正确预测为正例的比例。关注模型捕捉正例的能力。

• F1-score: 精确率和召回率的调和平均值，综合考虑精确率和召回率。

• AUC-ROC (Area Under the Receiver Operating Characteristic curve): ROC 曲线下的面积，用于评估二分类模型在不同阈值下的性能，尤其适用于类别不平衡问题。

• AUC-PR (Area Under the Precision-Recall curve): PR 曲线下的面积，更关注正例的预测性能，也适用于类别不平衡问题。

• 对数损失 (Log Loss / Cross-Entropy Loss): 用于评估概率预测模型的性能，值越小越好。

• 均方误差 (Mean Squared Error, MSE): 回归问题常用的评估指标，计算预测值与真实值之间平方差的平均值。

• 均绝对误差 (Mean Absolute Error, MAE): 回归问题常用的评估指标，计算预测值与真实值之间绝对差的平均值。

• R 平方 (R-squared): 回归问题常用的评估指标，衡量模型对目标变量方差的解释程度，值越接近 1 越好。

代码实践:

from sklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score, f1_score, roc_auc_score, average_precision_score, log_loss, mean_squared_error, mean_absolute_error, r2_score
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification
# 1. 生成示例数据 (类别不平衡)
X, y = make_classification(n_classes=2, class_sep=2, weights=[0.1, 0.9],
                           n_informative=3, n_redundant=1, flip_y=0,
                           n_features=20, n_clusters_per_class=1,
                           n_samples=1000, random_state=10)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 2. 训练模型 (逻辑回归)
model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1] # 获取正例的预测概率
# 3. 计算各种评估指标
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nPrecision:", precision_score(y_test, y_pred))
print("Recall:", recall_score(y_test, y_pred))
print("F1-score:", f1_score(y_test, y_pred))
print("AUC-ROC:", roc_auc_score(y_test, y_prob))
print("AUC-PR:", average_precision_score(y_test, y_prob))
print("Log Loss:", log_loss(y_test, y_prob)) # 需要预测概率 y_prob
# (如果是回归问题，可以使用以下指标)
# y_pred_reg = model.predict(X_test) # 假设是回归模型的预测结果
# print("\nMean Squared Error (MSE):", mean_squared_error(y_test, y_pred_reg))
# print("Mean Absolute Error (MAE):", mean_absolute_error(y_test, y_pred_reg))
# print("R-squared:", r2_score(y_test, y_pred_reg))
​

代码详解:

• 生成示例数据 (类别不平衡): 使用 make_classification 生成一个类别不平衡的二分类数据集 (正例占比 90%，反例占比 10%)，模拟实际应用中常见的情况。

• 训练模型: 训练一个逻辑回归模型。

• 计算各种评估指标:

  • 使用 sklearn.metrics 模块中的各种评估指标函数，计算模型的性能。

  • 对于需要预测概率的指标 (例如 roc_auc_score, log_loss, average_precision_score)，需要使用 predict_proba 方法获取模型的概率预测结果。

  • 对于回归问题的评估指标 (MSE, MAE, R-squared)，需要使用回归模型的预测结果 (示例代码中注释掉了回归指标的计算，因为我们使用的是分类模型)。

选择合适的评估指标:

• 准确率 (Accuracy): 适用于类别均衡的数据集，但容易在类别不平衡数据集上产生误导。

• 精确率 (Precision) 和 召回率 (Recall): 适用于类别不平衡数据集，需要根据具体业务场景权衡精确率和召回率的重要性。例如，在垃圾邮件检测中，我们更关注精确率 (避免将正常邮件误判为垃圾邮件)，而在疾病诊断中，我们更关注召回率 (尽可能捕捉到所有患病的人)。

• F1-score: 综合考虑精确率和召回率，适用于需要平衡精确率和召回率的场景。

• AUC-ROC 和 AUC-PR: 适用于类别不平衡数据集，AUC-ROC 更关注模型对正负例的排序能力，AUC-PR 更关注正例的预测性能。

• 对数损失 (Log Loss): 适用于概率预测模型，评估模型预测概率的准确性。

• 回归指标 (MSE, MAE, R-squared): 适用于回归问题，根据具体业务场景选择合适的回归指标。

总结: 选择合适的模型评估指标至关重要，它直接影响我们对模型性能的判断和优化方向。在实际应用中，应该根据具体问题和数据集特点，选择最能反映模型性能的评估指标，并进行综合评估。

5. 模型持久化 (Model Persistence): 保存和加载训练好的模型

概念详解:

模型持久化是指将训练好的机器学习模型保存到磁盘，以便后续加载和使用，而无需重新训练。模型持久化在以下场景中非常重要：

• 模型部署: 将训练好的模型保存后，可以部署到生产环境中，用于在线预测或批量预测。

• 模型复用: 保存的模型可以被其他程序或模块加载和使用，避免重复训练。

• 模型版本管理: 可以保存不同版本的模型，方便进行模型比较和回滚。

Scikit-learn 中常用的模型持久化方法:

• pickle 模块: Python 标准库中的序列化模块，可以将 Python 对象 (包括 Scikit-learn 模型) 序列化为字节流，并保存到文件中。

• joblib 库: 专门为 NumPy 和 Scikit-learn 优化的序列化库，效率更高，尤其适用于大型 NumPy 数组和 Scikit-learn 模型。

代码实践 (使用 joblib):

import joblib
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# 1. 加载数据并训练模型
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LogisticRegression()
model.fit(X_train, y_train)
# 2. 保存模型到文件
model_filename = 'iris_logistic_model.joblib'
joblib.dump(model, model_filename) # 将模型保存到 joblib 文件
print(f"模型已保存到文件: {model_filename}")
# 3. 加载模型
loaded_model = joblib.load(model_filename) # 从 joblib 文件加载模型
# 4. 使用加载的模型进行预测
y_pred_loaded = loaded_model.predict(X_test)
# 5. 验证加载的模型是否与原始模型一致
from sklearn.metrics import accuracy_score
y_pred_original = model.predict(X_test)
print("原始模型准确率:", accuracy_score(y_test, y_pred_original))
print("加载模型准确率:", accuracy_score(y_test, y_pred_loaded))
# 验证预测结果是否一致
print("预测结果是否一致:", np.array_equal(y_pred_original, y_pred_loaded))
​

代码详解:

• 训练模型: 加载 Iris 数据集，训练一个逻辑回归模型。

• 保存模型:

  • 使用 joblib.dump(model, model_filename) 将训练好的模型 model 保存到名为 iris_logistic_model.joblib 的文件中。

• 加载模型:

  • 使用 joblib.load(model_filename) 从 iris_logistic_model.joblib 文件加载模型，并将加载的模型赋值给 loaded_model。

• 使用加载的模型进行预测和验证: 使用加载的模型 loaded_model 进行预测，并与原始模型 model 的预测结果进行比较，验证加载的模型是否与原始模型一致。

使用 pickle 模块 (类似方法):

import pickle
# ... (训练模型步骤与上面 joblib 示例相同) ...
# 2. 保存模型到文件 (使用 pickle)
model_filename_pickle = 'iris_logistic_model.pkl'
with open(model_filename_pickle, 'wb') as f: # 以二进制写入模式打开文件
    pickle.dump(model, f) # 将模型保存到 pickle 文件
print(f"模型已保存到文件: {model_filename_pickle}")
# 3. 加载模型 (使用 pickle)
with open(model_filename_pickle, 'rb') as f: # 以二进制读取模式打开文件
    loaded_model_pickle = pickle.load(f) # 从 pickle 文件加载模型
# ... (后续预测和验证步骤与上面 joblib 示例相同，使用 loaded_model_pickle) ...
​

选择 joblib 还是 pickle:

• joblib: 推荐用于 Scikit-learn 模型和 NumPy 数组的持久化，效率更高，尤其处理大型数据时。

• pickle: Python 标准库，通用性更强，可以序列化各种 Python 对象，但对于大型 NumPy 数组和 Scikit-learn 模型，效率可能不如 joblib。

安全注意事项: 加载来自不可信来源的 pickle 文件可能存在安全风险，因为 pickle 可以反序列化任意 Python 对象，包括恶意代码。如果加载的模型来自不可信来源，请谨慎操作。

总结: 模型持久化是机器学习模型部署和复用的关键步骤。joblib 和 pickle 是 Scikit-learn 中常用的模型持久化工具，选择 joblib 通常能获得更好的性能。

6. 模型调优与超参数优化 (Hyperparameter Optimization) 的高级方法: 探索更高效的超参数搜索策略

概念详解:

超参数 (Hyperparameters) 是在模型训练之前需要人为设定的参数，例如，LogisticRegression 中的 C 参数 (正则化强度)，DecisionTreeClassifier 中的 max_depth 参数 (最大树深度) 等。模型性能对超参数的选择非常敏感，因此超参数优化是机器学习模型开发的重要环节。

Scikit-learn 提供了多种超参数优化方法，除了常用的 GridSearchCV (网格搜索) 和 RandomizedSearchCV (随机搜索) 外，还有一些更高级的方法可以提高搜索效率和效果。

高级超参数优化方法:

• 贝叶斯优化 (Bayesian Optimization): 基于贝叶斯统计理论的优化方法，利用先验知识 (先前的搜索结果) 构建目标函数 (例如，交叉验证得分) 的概率模型，然后根据概率模型选择下一个采样点，从而更有效地找到最优超参数。

• 基于梯度的优化 (Gradient-based Optimization): 对于某些模型 (例如，神经网络)，可以利用梯度信息来优化超参数，例如，使用 Adam 或 SGD 等优化器来调整超参数。

• 进化算法 (Evolutionary Algorithms): 模拟生物进化过程的优化方法，例如，遗传算法 (Genetic Algorithm)、进化策略 (Evolution Strategy) 等，通过种群迭代和选择操作，搜索最优超参数。

• Hyperband: 一种高效的超参数优化算法，通过提前停止表现不佳的配置，快速探索大量超参数组合。