机器学习模型选择

哈喽！大家好，很高兴又见面了，我是golang学习网的一名作者，今天由我给大家带来一篇《机器学习模型选择》，本文主要会讲到等等知识点，希望大家一起学习进步，也欢迎大家关注、点赞、收藏、转发! 下面就一起来看看吧！

一、简介

在本文中，我们将学习如何在具有不同超参数的多个模型之间选择最佳模型，在某些情况下，我们可以拥有 50 多个不同的模型，了解如何选择一个模型对于为您的数据集获得最佳性能的模型非常重要.

我们将通过选择最佳学习算法及其最佳超参数来进行模型选择。

但是首先什么是超参数？这些是用户设置的附加设置，将影响模型学习其参数的方式。 参数 另一方面是模型在训练过程中学习的内容。

2. 使用穷举搜索。

穷举搜索涉及通过搜索一系列超参数来选择最佳模型。为此，我们利用 scikit-learn 的 gridsearchcv.

gridsearchcv 的工作原理：

1. 用户为一个或多个超参数定义一组可能的值。
2. gridsearchcv 使用每个值和/或值的组合来训练模型。
3. 性能最佳的模型被选为最佳模型。

示例
我们可以设置逻辑回归作为我们的学习算法并调整两个超参数（c 和正则化惩罚）。我们还可以指定两个参数：求解器和最大迭代次数。

现在，对于 c 和正则化惩罚值的每种组合，我们训练模型并使用 k 折交叉验证对其进行评估。
因为我们有 10 个可能的 c 值，所以有 2 个可能的 reg 值。惩罚和 5 倍，我们总共有 (10 x 2 x 5 = 100) 个候选模型，从中选择最好的。

# load libraries
import numpy as np
from sklearn import linear_model, datasets
from sklearn.model_selection import gridsearchcv

# load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# create logistic regression
logistic = linear_model.logisticregression(max_iter=500, solver='liblinear')

# create range of candidate penalty hyperparameter values
penalty = ['l1','l2']

# create range of candidate regularization hyperparameter values
c = np.logspace(0, 4, 10)

# create dictionary of hyperparameter candidates
hyperparameters = dict(c=c, penalty=penalty)

# create grid search
gridsearch = gridsearchcv(logistic, hyperparameters, cv=5, verbose=0)

# fit grid search
best_model = gridsearch.fit(features, target)

# show the best model
print(best_model.best_estimator_)

# logisticregression(c=7.742636826811269, max_iter=500, penalty='l1',
solver='liblinear') # result

获得最佳模型：

# view best hyperparameters
print('best penalty:', best_model.best_estimator_.get_params()['penalty'])
print('best c:', best_model.best_estimator_.get_params()['c'])

# best penalty: l1 #result
# best c: 7.742636826811269 # result

3. 使用随机搜索。

当您想要一种比穷举搜索更便宜的计算方法来选择最佳模型时，通常会使用这种方法。

值得注意的是，randomizedsearchcv 本质上并不比 gridsearchcv 更快，但它通常只需通过测试更少的组合即可在更短的时间内实现与 gridsearchcv 相当的性能。

randomizedsearchcv 的工作原理:

1. 用户将提供超参数/分布（例如正态、均匀）。
2. 算法将随机搜索给定超参数值的特定数量的随机组合，而不进行替换。

示例

# load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# create logistic regression
logistic = linear_model.logisticregression(max_iter=500, solver='liblinear')

# create range of candidate regularization penalty hyperparameter values
penalty = ['l1', 'l2']

# create distribution of candidate regularization hyperparameter values
c = uniform(loc=0, scale=4)

# create hyperparameter options
hyperparameters = dict(c=c, penalty=penalty)

# create randomized search
randomizedsearch = randomizedsearchcv(
logistic, hyperparameters, random_state=1, n_iter=100, cv=5, verbose=0,
n_jobs=-1)

# fit randomized search
best_model = randomizedsearch.fit(features, target)

# print best model
print(best_model.best_estimator_)

# logisticregression(c=1.668088018810296, max_iter=500, penalty='l1',
solver='liblinear') #result.

获得最佳模型：

# view best hyperparameters
print('best penalty:', best_model.best_estimator_.get_params()['penalty'])
print('best c:', best_model.best_estimator_.get_params()['c'])

# best penalty: l1 # result
# best c: 1.668088018810296 # result

注意：训练的候选模型数量在n_iter（迭代次数）设置中指定。

4. 从多种学习算法中选择最佳模型。

在这一部分中，我们将了解如何通过搜索一系列学习算法及其各自的超参数来选择最佳模型。

我们可以通过简单地创建候选学习算法及其超参数的字典来用作 gridsearchcv.

步骤：

1. 我们可以定义一个包含两种学习算法的搜索空间。
2. 我们指定超参数，并使用格式分类器[超参数名称]_定义它们的候选值。

# load libraries
import numpy as np
from sklearn import datasets
from sklearn.linear_model import logisticregression
from sklearn.ensemble import randomforestclassifier
from sklearn.model_selection import gridsearchcv
from sklearn.pipeline import pipeline

# set random seed
np.random.seed(0)

# load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# create a pipeline
pipe = pipeline([("classifier", randomforestclassifier())])

# create dictionary with candidate learning algorithms and their hyperparameters
search_space = [{"classifier": [logisticregression(max_iter=500,
solver='liblinear')],
"classifier__penalty": ['l1', 'l2'],
"classifier__c": np.logspace(0, 4, 10)},
{"classifier": [randomforestclassifier()],
"classifier__n_estimators": [10, 100, 1000],
"classifier__max_features": [1, 2, 3]}]

# create grid search
gridsearch = gridsearchcv(pipe, search_space, cv=5, verbose=0)

# fit grid search
best_model = gridsearch.fit(features, target)

# print best model
print(best_model.best_estimator_)

# pipeline(steps=[('classifier',
                 logisticregression(c=7.742636826811269, max_iter=500,
                      penalty='l1', solver='liblinear'))])

最佳模特：
搜索完成后，我们可以使用best_estimator_查看最佳模型的学习算法和超参数。

5. 预处理时选择最佳模型。

有时我们可能希望在模型选择过程中包含预处理步骤。
最好的解决方案是创建一个包含预处理步骤及其任何参数的管道：

第一个挑战：
gridseachcv 使用交叉验证来确定性能最高的模型。

然而，在交叉验证中，我们假装未看到测试集时保留的折叠，因此不属于任何预处理步骤（例如缩放或标准化）。

因此，预处理步骤必须是 gridsearchcv 所采取的操作集的一部分。

解决方案
scikit-learn 提供了 featureunion，它允许我们正确组合多个预处理操作。
步骤：

1. 我们使用_featureunion _组合两个预处理步骤：标准化特征值（standardscaler）和主成分分析（pca） ) - 该对象称为预处理，包含我们的两个预处理步骤。
2. 接下来，我们使用学习算法在管道中加入预处理。

这使我们能够将拟合、转换和训练具有超参数组合的模型的正确处理外包给 scikit-learn。

第二个挑战：
一些预处理方法（例如 pca）有自己的参数，使用 pca 进行降维需要用户定义用于生成转换后的特征集的主成分数量。理想情况下，我们会选择能够生成针对某些评估测试指标具有最佳性能的模型的组件数量。
解决方案。
在 scikit-learn 中，当我们在搜索空间中包含候选组件值时，它们会像任何其他要搜索的超参数一样被对待。

# load libraries
import numpy as np
from sklearn import datasets
from sklearn.linear_model import logisticregression
from sklearn.model_selection import gridsearchcv
from sklearn.pipeline import pipeline, featureunion
from sklearn.decomposition import pca
from sklearn.preprocessing import standardscaler

# set random seed
np.random.seed(0)

# load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# create a preprocessing object that includes standardscaler features and pca
preprocess = featureunion([("std", standardscaler()), ("pca", pca())])

# create a pipeline
pipe = pipeline([("preprocess", preprocess),
               ("classifier", logisticregression(max_iter=1000,
               solver='liblinear'))])

# create space of candidate values
search_space = [{"preprocess__pca__n_components": [1, 2, 3],
"classifier__penalty": ["l1", "l2"],
"classifier__c": np.logspace(0, 4, 10)}]

# create grid search
clf = gridsearchcv(pipe, search_space, cv=5, verbose=0, n_jobs=-1)

# fit grid search
best_model = clf.fit(features, target)

# print best model
print(best_model.best_estimator_)

# pipeline(steps=[('preprocess',
     featureunion(transformer_list=[('std', standardscaler()),
                                    ('pca', pca(n_components=1))])),
    ('classifier',
    logisticregression(c=7.742636826811269, max_iter=1000,
                      penalty='l1', solver='liblinear'))]) # result

模型选择完成后，我们可以查看生成最佳模型的预处理值。

产生最佳模式的预处理步骤

# view best n_components

best_model.best_estimator_.get_params() 
# ['preprocess__pca__n_components'] # results

5. 通过并行化加速模型选择。

那个时候你需要减少选择模型的时间。
我们可以通过同时训练多个模型来做到这一点，这是通过设置 n_jobs=-1
使用我们机器中的所有核心来完成的

# load libraries
import numpy as np
from sklearn import linear_model, datasets
from sklearn.model_selection import gridsearchcv

# load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# create logistic regression
logistic = linear_model.logisticregression(max_iter=500, 
                                           solver='liblinear')

# create range of candidate regularization penalty hyperparameter values
penalty = ["l1", "l2"]

# create range of candidate values for c
c = np.logspace(0, 4, 1000)

# create hyperparameter options
hyperparameters = dict(c=c, penalty=penalty)

# create grid search
gridsearch = gridsearchcv(logistic, hyperparameters, cv=5, n_jobs=-1, 
                             verbose=1)

# fit grid search
best_model = gridsearch.fit(features, target)

# print best model
print(best_model.best_estimator_)

# fitting 5 folds for each of 2000 candidates, totalling 10000 fits
# logisticregression(c=5.926151812475554, max_iter=500, penalty='l1',
                                                  solver='liblinear')

6. 加速模型选择（算法特定方法）。

这是一种无需使用额外计算能力即可加速模型选择的方法。

这是可能的，因为 scikit-learn 具有特定于模型的交叉验证超参数调整。

有时学习算法的特性使我们能够更快地搜索最佳超参数。

示例：
logisticregression 用于进行标准逻辑回归分类器。
logisticregressioncv 实现了一个高效的交叉验证逻辑回归分类器，可以识别超参数 c 的最佳值。

# Load libraries
from sklearn import linear_model, datasets

# Load data
iris = datasets.load_iris()
features = iris.data
target = iris.target

# Create cross-validated logistic regression
logit = linear_model.LogisticRegressionCV(Cs=100, max_iter=500,
                                            solver='liblinear')

# Train model
logit.fit(features, target)

# Print model
print(logit)

# LogisticRegressionCV(Cs=100, max_iter=500, solver='liblinear')

注意：logisticregressioncv 的一个主要缺点是它只能搜索 c 的一系列值。这种限制对于许多 scikit-learn 特定于模型的交叉验证方法来说很常见。

我希望本文有助于快速概述如何选择机器学习模型。

本篇关于《机器学习模型选择》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！