ML モデルの選択。

1. はじめに

この記事では、さまざまなハイパーパラメータを持つ複数のモデルの中から最適なモデルを選択する方法を学びます。場合によっては、50 を超える異なるモデルがある場合もあります。データセットに最適なパフォーマンスのモデルを取得するには、モデルの選択方法を知ることが重要です。 .

最適な学習アルゴリズムと最適なハイパーパラメータの両方を選択することによってモデルの選択を行います。

その前に、ハイパーパラメータとは何ですか?これらはユーザーによって設定される追加設定であり、モデルがパラメーターを学習する方法に影響します。一方、パラメータは、トレーニング プロセス中にモデルが学習するものです。

2. 徹底的な検索を使用する。

徹底的な検索 では、さまざまなハイパーパラメーターを検索して最適なモデルを選択します。これを行うには、scikit-learn の GridSearchCV を利用します。

GridSearchCV の仕組み:

1. ユーザーは、1 つまたは複数のハイパーパラメータに使用可能な値のセットを定義します。
2. GridSearchCV は、すべての値または値の組み合わせを使用してモデルをトレーニングします。
3. 最高のパフォーマンスを備えたモデルが最高のモデルとして選択されます。

例
学習アルゴリズムとしてロジスティック回帰を設定し、2 つのハイパーパラメータ (C と正則化ペナルティ) を調整できます。ソルバーと最大反復回数という 2 つのパラメーターを指定することもできます。

C と正則化ペナルティ値の組み合わせごとに、モデルをトレーニングし、k 分割交差検証を使用して評価します。
C の可能な値は 10 個あるため、reg の可能な値は 2 個あります。ペナルティと 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 つの学習アルゴリズムを含む検索空間を定義できます。
2. ハイパーパラメータを指定し、classifier[ハイパーパラメータ名]_ の形式を使用してその候補値を定義します。

# 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. We use _FeatureUnion _to combine two preprocessing steps: standardize the feature values(StandardScaler) and principal component analysis(PCA) - this object is called the preprocess and contains both of our preprocessing steps.
2. Next we include preprocess in our pipeline with our learning algorithm.

This allows us to outsource the proper handling of fitting, transforming, and training the models with combinations of hyperparameters to scikit-learn.

Second Challenge:
Some preprocessing methods such as PCA have their own parameters, dimensionality reduction using PCA requires the user to define the number of principal components to use to produce the transformed features set. Ideally we would choose the number of components that produces a model with the greatest performance for some evaluation test metric.
Solution.
In scikit-learn when we include candidate component values in the search space, they are treated like any other hyperparameter to be searched over.

# 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

After the model selection is complete we can view the preprocessing values that produced the best model.

Preprocessing steps that produced the best modes

# View best n_components

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

5. Speeding Up Model Selection with Parallelization.

That time you need to reduce the time it takes to select a model.
We can do this by training multiple models simultaneously, this is done by using all the cores in our machine by setting 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. Speeding Up Model Selection ( Algorithm Specific Methods).

This a way to speed up model selection without using additional compute power.

This is possible because scikit-learn has model-specific cross-validation hyperparameter tuning.

Sometimes the characteristics of a learning algorithms allows us to search for the best hyperparameters significantly faster.

Example:
LogisticRegression is used to conduct a standard logistic regression classifier.
LogisticRegressionCV implements an efficient cross-validated logistic regression classifier that can identify the optimum value of the hyperparameter 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')

Note:A major downside to LogisticRegressionCV is that it can only search a range of values for C. This limitation is common to many of scikit-learn's model-specific cross-validated approaches.

I hope this Article was helpful in creating a quick overview of how to select a machine learning model.

以上がML モデルの選択。の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。