前言

今天给大家聊聊机器学习领域中，存在的一些自动化超参数寻优库。优化基模型选择的耳熟能详的支持向量机模型，就用不同的自动化寻参工具来实现SVM参数的优化。

介绍

Auto-Sklearn

Auto-Sklearn 是一个用于自动特征工程和机器学习模型选择的库，是 Scikit-Learn 的扩展。这个库因为不支持windows环境，所以这里就暂时不讲解了。

Optuna

Optuna 是一个为机器学习提供最优化超参数的框架。它包括了对未知搜索空间的支持，以及针对计算资源进行高效优化的能力。

import optuna
from sklearn import datasets, svm
from sklearn.model_selection import train_test_split
import pickle

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和验证集
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=0)

# 定义目标函数
def objective(trial):
    C = trial.suggest_loguniform('C', 1e-10, 1e10)
    gamma = trial.suggest_loguniform('gamma', 1e-10, 1e10)
    
    classifier_obj = svm.SVC(C=C, gamma=gamma)
    classifier_obj.fit(X_train, y_train)
    return classifier_obj.score(X_valid, y_valid)

# 创建一个study对象并找到最佳参数
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)

# 输出最佳参数
print('Best trial:')
trial = study.best_trial
print('Value: ', trial.value)
print('Params: ')
for key, value in trial.params.items():
    print('{}: {}'.format(key, value))

# 使用最佳参数创建模型
best_params = study.best_params
best_model = svm.SVC(**best_params)
best_model.fit(X_train, y_train)

# 保存模型
with open('best_model.pkl', 'wb') as f:
    pickle.dump(best_model, f)

Hyperopt

Hyperopt 是一个用于优化超参数的库。它使用了贝叶斯优化方法，并支持并行计算。

from sklearn import datasets, svm
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from hyperopt import hp, fmin, tpe, Trials, STATUS_OK
import pickle

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和验证集
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=0)

# 定义目标函数
def objective(params):
    classifier_obj = svm.SVC(**params)
    classifier_obj.fit(X_train, y_train)
    pred = classifier_obj.predict(X_valid)
    return {'loss': -accuracy_score(y_valid, pred), 'status': STATUS_OK}

# 定义搜索空间
space = {
    'C': hp.loguniform('C', -10, 10),
    'gamma': hp.loguniform('gamma', -10, 10)
}

# 执行优化
trials = Trials()
best = fmin(fn=objective, space=space, algo=tpe.suggest, max_evals=100, trials=trials)

# 输出最佳参数
print('Best: ', best)

# 使用最佳参数创建模型
best_model = svm.SVC(**best)
best_model.fit(X_train, y_train)

# 保存模型
with open('best_model.pkl', 'wb') as f:
    pickle.dump(best_model, f)

Tune

Ray Tune 是一个用于深度学习和强化学习的库。它支持多种搜索算法和早停策略。接下来还是以SVM优化举例。

from sklearn import datasets, svm
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from ray import tune

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和验证集
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=0)

def train_model(config):
    # 使用传入的参数创建模型
    model = svm.SVC(**config)
    model.fit(X_train, y_train)

    # 验证模型并返回准确率
    predictions = model.predict(X_valid)
    acc = accuracy_score(y_valid, predictions)
    
    tune.report(accuracy=acc)

# 定义搜索空间
search_space = {
    'C': tune.loguniform(1e-10, 1e10),
    'gamma': tune.loguniform(1e-10, 1e10)
}

# 执行优化
analysis = tune.run(train_model, config=search_space, num_samples=100, metric='accuracy', mode='max')

# 输出最佳参数
print('Best config: ', analysis.best_config)

# 使用最佳参数创建模型
best_model = svm.SVC(**analysis.best_config)
best_model.fit(X_train, y_train)

# 保存模型
import pickle
with open('best_model.pkl', 'wb') as f:
    pickle.dump(best_model, f)

Keras Tuner

Keras Tuner 是一个专门为 Keras 库设计的超参数调优框架。所以不能使用它来优化svm了，就随便举个例子。

from tensorflow import keras
from kerastuner.tuners import RandomSearch
from sklearn import datasets

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和验证集
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=0)

def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.Dense(units=hp.Int('units', min_value=32, max_value=512, step=32), activation='relu'))
    model.add(keras.layers.Dense(10, activation='softmax'))
    model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])), loss='categorical_crossentropy', metrics=['accuracy'])
    return model

tuner = RandomSearch(build_model, objective='val_accuracy', max_trials=5)
tuner.search(X_train, y_train, epochs=5, validation_data=(X_valid, y_valid))

TPOT (Tree-based Pipeline Optimization Tool)

TPOT 使用遗传算法优化机器学习管道。

from tpot import TPOTClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

# 加载数据
digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target,
                                                    train_size=0.75, test_size=0.25)

# 设置 SVM 的配置字典
tpot_config = {
    'sklearn.svm.SVC': {
        'C': [1.0, 10.0, 100.0],
        'kernel': ['linear', 'poly', 'rbf'],
        'degree': [1, 2, 3, 4, 5],
        'gamma': ['scale', 'auto']
    },
}

# 创建 TPOT 分类器实例
pipeline_optimizer = TPOTClassifier(generations=5, population_size=20, verbosity=2,
                                    config_dict=tpot_config)

# 在数据上训练 TPOT 分类器
pipeline_optimizer.fit(X_train, y_train)

# 打印最佳模型管道
print(pipeline_optimizer.fitted_pipeline_)

# 使用测试集评价模型性能
print(pipeline_optimizer.score(X_test, y_test))

Spearmint

Spearmint 是一个贝叶斯优化库，它将问题视作黑盒函数优化问题。

from sklearn import svm, datasets
from sklearn.model_selection import cross_val_score

# 加载数据集
iris = datasets.load_iris()

def svm_cv(C, kernel):
    # 创建一个 SVM 分类器
    svc = svm.SVC(C=C, kernel=kernel)
    
    # 使用交叉验证评估模型
    scores = cross_val_score(svc, iris.data, iris.target, cv=5)

    # 返回平均精度的负值（因为 Spearmint 进行最小化）
    return -scores.mean()

然后，创建一个 JSON 配置文件 (例如，config.json) 来指定优化的参数：

[
    {
        "name": "C",
        "type": "float",
        "min": 0.1,
        "max": 100.0
    },
    {
        "name": "kernel",
        "type": "enum",
        "options": ["linear", "poly", "rbf", "sigmoid"]
    }
]

接着，在命令行中运行 Spearmint：

spearmint svm.py --config config.json

SMAC (Sequential Model-based Algorithm Configuration)

SMAC 通常用于优化算法的配置，但也可以用于机器学习模型的超参数优化。

import numpy as np
from sklearn import datasets, svm
from sklearn.model_selection import cross_val_score
from smac.configspace import ConfigurationSpace
from ConfigSpace.hyperparameters import CategoricalHyperparameter, UniformFloatHyperparameter
from smac.scenario.scenario import Scenario
from smac.facade.smac_hpo_facade import SMAC4HPO

# 加载数据
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 定义一个目标函数
def svm_from_cfg(cfg):
    # 从配置中获取SVM参数
    C = cfg["C"]
    kernel = cfg["kernel"]

    # 创建并评估 SVM 分类器
    clf = svm.SVC(C=C, kernel=kernel, random_state=42)
    scores = cross_val_score(clf, X, y, cv=5)

    # SMAC 贝叶斯优化是最小化目标函数，因此我们取负值，即 - mean_accuracy
    return -1 * np.mean(scores)

# 创建配置空间
cs = ConfigurationSpace()

# 添加相关的超参数
C = UniformFloatHyperparameter("C", 0.001, 100.0, default_value=1.0)
kernel = CategoricalHyperparameter("kernel", ["linear", "poly", "rbf", "sigmoid"], default_value="rbf")

cs.add_hyperparameters([C, kernel])

# 定义 scenario
scenario = Scenario({"run_obj": "quality",
                     "runcount-limit": 50,
                     "cs": cs,
                     "deterministic": "true"
                     })

# 创建一个 SMAC 对象
smac = SMAC4HPO(scenario=scenario, rng=np.random.default_rng(42),
                tae_runner=svm_from_cfg)

# 运行优化过程
incumbent = smac.optimize()

# 输出优化结果
print("Optimized Value: %.2f" % -svm_from_cfg(incumbent))
print("Optimized Parameters: ", incumbent.get_dictionary())

FLAML

旨在自动化机器学习任务的各个方面，包括特征工程、模型选择和超参数调优。FLAML内置了很多集成模型和线性模型方法，但是不包括SVM，所以这里我们讲解怎么自定义模型。

from flaml import AutoML
from sklearn.datasets import load_digits

# 加载数据集
digits = load_digits()
X_train, y_train = digits.data, digits.target

# 初始化AutoML实例
automl = AutoML()

# 创建并添加一个新的学习器
class MySVMEstimator(LGBMEstimator):
    base_class = 'sklearn.svm.SVC'

automl.add_learner(learner_name='svm', learner_class=MySVMEstimator)

# 设置参数
settings = {
    "time_budget": 30,  # 总共运行时间（秒）
    "metric": 'accuracy',  # 评价指标
    "task": 'classification',  # 任务类型
    "estimator_list": ['svm'],  # 指定待调整模型
    "log_file_name": 'flaml.log',  # 输出日志文件
}

# 进行自动化的机器学习搜索
automl.fit(X_train=X_train, y_train=y_train, **settings)

# 检查是否选择了SVM模型
best_model = automl.model
if isinstance(best_model, MySVMEstimator):
    print("Selected model is SVM.")
    print("Best hyperparameters:", automl.best_config)
    print('Best accuracy on training data: {0:.4g}'.format(1-automl.best_loss))
else:
    print(f"Selected model is not SVM. It's {type(best_model)}.")

我试了一下，发现并不是优化的svm参数，我看了官网，说FLAML可能会选择它认为最好的模型，这可能包括其他类型的模型，例如集成模型。这是因为FLAML旨在自动化地找出最佳的模型和超参数。