ブレンディングは、1,000,000ドルのNetflix機械学習コンテストで数百のモデルをプールしたバッチモデルを説明するために使用されてきました。そのため、ブレンディングは、Kaggleなどの機械学習コンテストでバッチ処理するための一般的な方法と名前のままです。 ..。特に、機械学習コースの新しいスレッドの開始のために、 Pythonで混合アンサンブルを開発および評価する方法を学習するチュートリアルを共有しています。このチュートリアルを完了すると、次のことがわかります。
- 混合アンサンブルは、k倍の相互検証中の予測ではなく、独立したテスト検証データセットの予測を使用してメタモデルがトレーニングされるモデルパッケージの一種です。
- 新しいデータに基づくモデルトレーニングと予測機能を含む、混合アンサンブルを開発する方法。
- 分類および予測回帰モデリングの問題について混合アンサンブルを評価する方法。
チュートリアルの概要
このチュートリアルは4つのパートに分かれています。はい、どうぞ：
- 混合アンサンブル。
- 混合アンサンブルの作成。
- 分類問題における混合アンサンブル。
- 回帰問題における混合アンサンブル。
混合アンサンブル
ブレンディングは、マシン学習モデルを使用して、複数のアンサンブルメンバーモデルからの予測を最適に組み合わせる方法を学習するアンサンブルマシン学習手法です。
したがって、ミキシングは、スタッキングと呼ばれるスタッキングの一般化と同じ です。ブレンディングとバッチ処理は、同じ記事またはモデルの説明で同じ意味で使用されることがよくあります。
多くの機械学習の実践者は、バッチ処理および関連する手法を使用して、個々のモデルの予測精度を向上させることに成功しています。一部のコンテキストでは、バッチ処理はブレンディングとも呼ばれます。ここでも用語を交換します。
機能加重線形スタッキング、2009年。
バッチモデルアーキテクチャには、レベル0モデルと呼ばれることが多い2つ以上のベースラインモデルと、ベースラインモデルの予測をレベル1モデルとして組み合わせたメタモデルが含まれています。メタモデルは、サンプル外のデータに基づいてベースモデルによって行われた予測に基づいてトレーニングされます。
- ( ) — , , .
- () — , .
ただし、ミキシングには、パッケージ化されたアンサンブルモデルを構築するための特定の意味があります。ブレンディングは、基本モデルが任意のタイプの機械学習モデルであり、メタモデルが基本モデルの予測を「ブレンド」する線形モデルであるスタックアンサンブルの開発を提供できます。たとえば、数値を予測する場合の線形回帰モデル、またはクラスラベルを予測する場合のロジスティック回帰モデルは、基本モデルによって行われた予測の加重和を計算し、混合予測として扱われます。
- 混合アンサンブル：バッチモデルアンサンブルのメタモデルとして、線形回帰やロジスティック回帰などの線形モデルを使用します。
ブレンディングは、2009年のNetflixコンペティションでパッケージ化されたアンサンブルに一般的に使用される用語でした。このコンテストでは、ネイティブのNetflixアルゴリズムよりも優れたパフォーマンスを発揮する予測モデルを探し ているチームが参加し、パフォーマンスが10％向上したチームに1,000,000ドルの賞金が授与されました。
RMSE = 0.8643 ^ 2のソリューションは、100を超える結果の線形混合です。[…]メソッドの説明全体を通して、最終的な混合ソリューションに参加した特定の予測子を強調します。
Netflix賞のBellKor2008ソリューション、2008年。
したがって、ミキシングは、バッチ処理などのモデルアーキテクチャを使用したアンサンブル学習の俗称です。競争での機械学習に関連するもの以外の教科書や学術論文で使用されることは、あったとしてもめったにありません。最も一般的には、ブレンディングという用語は、独立した検証データセットを使用してベースモデルによって作成された予測に基づいてメタモデルがトレーニングされる、バッチ処理の特定のアプリケーションを説明するために使用されます。このコンテキストでは、パッケージ化は、相互検証手順中に予測でトレーニングされたメタモデル用に予約されています。
- ブレンディング：独立したデータセットで行われた予測に基づいてメタモデルがトレーニングされるバッチタイプのアンサンブル。
- バッチ処理：メタモデルをk倍クロスバリデーション中に行われた予測に訓練されているバッチ式のアンサンブルを。
この区別は、Kaggleマシンラーニングコンペティションコミュニティでは一般的です。
ミキシングは、Netflixの受賞者によって造られた言葉です。一般化に非常に近いですが、少し単純で、情報漏えいのリスクが少なくなります。[…]混合することにより、トレーニングセットの相互検証中に予測を生成する代わりに、たとえばトレーニングセットの10％の小さな独立したセットを作成します。次に、バッチ処理モデルは、この小さなセットのみでトレーニングされます。
Kaggle Ensemble Guide、MLWave、2015年。
ブレンドの最後の定義を使用します。それがどのように実装されているか見てみましょう。
混合アンサンブル開発
この記事の執筆時点では、scikit-learnライブラリはそのままの混合をサポートしていません。しかし、scikit-learnモデルを使用して自分で実装することはできます。まず、基本モデルのセットを作成する必要があります。これは、回帰または分類の問題に適した任意のモデルにすることができます。モデルのリストを返すget_models（）関数を定義できます 。各モデルは、名前とカスタマイズされた分類子または回帰オブジェクトを持つタプルとして定義されます。たとえば、分類問題の場合、ロジスティック回帰、kNN、決定ツリー、SVM、およびナイーブベイジアンモデルを使用できます。
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
次に、ミキシングモデルをトレーニングする必要があります。基本モデルはトレーニングデータセットでトレーニングされていることを思い出してください。メタモデルは、独立したデータセットの各ベースモデルによって行われた予測に基づいてトレーニングされます。
まず、リスト内のモデルをループして、トレーニングデータセットで各モデルを順番にトレーニングできます。さらに、このサイクルでは、トレーニング済みモデルを使用して、独立したデータセットの予測（検証）を行い、将来の予測を保存できます。
...
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
これで、メタモデルのトレーニングに使用できる入力を表す「meta_X *」ができました。各列またはオブジェクトは、1つの基本モデルの出力を表します。各線は、独立したデータセットからの1つのサンプルを表します。hstack（）関数を使用して、機械学習モデルで期待されるように、このデータセットが2次元のnumpy配列であることを確認できます 。
...
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
これで、メタモデルをトレーニングできます。分類問題のロジスティック回帰など、好きなマシン学習モデルにすることができます。
...
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
トレーニングおよび独立した検証データセットを使用してブレンディングモデルをトレーニングするfit_ensemble（）と呼ばれる関数にすべてをまとめることができ ます。
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
次のステップは、ミキシングアンサンブルを使用して新しいデータを予測することです。これは2段階のプロセスです。最初のステップは、予測に各基本モデルを使用することです。次に、予測がまとめられ、混合モデルへの入力として使用されて、最終的な予測が行われます。
モデルをトレーニングするときと同じサイクルを使用できます。つまり、各基本モデルの予測をトレーニングデータセットに収集し、予測を合計して、このメタレベルデータセットとの混合モデルでpredict（）を呼び出し ます。Predict_ensemble（）関数 以下はこれらのアクションを実装します。基本モデルのリストのトレーニング、アンサンブルブレンダーのトレーニング、およびデータセット（テストデータセットや新しいデータなど）のデータセットを指定すると、一連の予測が返されます。
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
これで、分類または予測回帰モデリングの問題に混合アンサンブルを実装するために必要なすべての要素が揃いました。
分類問題の混合アンサンブル
このセクションでは、分類タスクでのブレンディングの使用について説明します。まず、 make_classification（）関数を使用して、10,000個の例と20個の入力フィーチャを含む合成バイナリ分類問題を作成できます。全体の例を以下に示します。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
例を実行すると、データセットが作成され、入力と出力が要約されます。
(10000, 20) (10000,)
次に、最初にデータセットをトレーニングセットとテストセットに分割し、次にトレーニングセットを基本モデルのトレーニングに使用するサブセットとメタモデルのトレーニングに使用するサブセットに分割する必要があります。この場合、トレーニングセットとテストセットに50-50分割を使用し、次にトレーニングセットと検証セットに67-33分割を使用します。
...
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
次に、前のセクションのget_models（）関数 を使用して、アンサンブルで使用される分類モデルを作成できます。次に、fit_ensemble（）関数 を呼び出して、これらのデータセットで混合アンサンブルをトレーニングし、predict_ensemble（）関数 を使用して、独立したデータセットで予測を行うことができます。
...
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
最後に、テストデータセットの分類精度を報告することにより、ブレンドモデルのパフォーマンスを評価できます。
...
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % score)
合成バイナリ分類問題で混合アンサンブルを推定する完全な例を以下に示します。
# blending ensemble for classification using hard voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC()))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))
例を実行すると、最初にすべてのデータセットの要約が報告され、次にテストデータセットのアンサンブルの精度が報告されます。
注： アルゴリズムや推定手順の確率的な性質、または数値の精度の違いにより、結果が異なる場合があります。例を複数回実行し、平均を比較することを検討してください。
ここでは、混合アンサンブルが約97.900％の分類精度を達成したことがわかります。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending Accuracy: 97.900
前の例では、明確なクラスラベルの予測は、ブレンディングモデルを使用して結合されました。これは一種の ハード投票です。別の方法は、各モデルがクラスの確率を予測し、メタモデルを使用して確率を混合する方法です。これは一種のソフト投票であり、パフォーマンスの向上につながる場合があります。まず、SVMモデルなど、確率を返すモデルを構成する必要があります。
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
次に、明確なクラスラベルではなく、基礎となるモデルを変更して確率を予測する必要があります。これは、基礎となるモデルのトレーニング中にfit_ensemble（）内で predict_proba（）を呼び出すことで実現できます 。
...
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
これは、メタモデルのトレーニングに使用されるメタデータセットが分類子ごとにn列になることを意味します。ここで、nは予測問題のクラスの数であり、この場合は2つのクラスがあります。また、ミキシングモデルを使用して新しいデータを予測する場合は、ベースモデルによって行われる予測を変更する必要があります。
...
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
合成バイナリ分類問題の予測クラス確率でミキシングを使用する例全体を以下に示します。
# blending ensemble for classification using soft voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))
例を実行すると、最初にすべてのデータセットの要約が報告され、次にテストセット内のアンサンブルの精度が報告されます。
注： アルゴリズムや推定手順の確率的な性質、または数値の精度の違いにより、結果が異なる場合があります。例を数回試して、平均結果を比較してください。
ここでは、クラス確率を混合すると、分類精度が最大約98.240％向上したことがわかります。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending Accuracy: 98.240
混合アンサンブルは、その中の個々のモデルのいずれかを上回ることができる場合にのみ効果的です。これは、各ベースモデルを個別に評価することで確認できます。各ベースラインモデルは、（ミキシングアンサンブルではなく）トレーニングデータセット全体でトレーニングし、（ミキシングアンサンブルと同様に）テストデータセットで評価できます。以下の例は、各ベースラインモデルを個別に評価することでこれを示しています。
# evaluate base models on the entire training dataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:
# fit the model on the training dataset
model.fit(X_train_full, y_train_full)
# make a prediction on the test dataset
yhat = model.predict(X_test)
# evaluate the predictions
score = accuracy_score(y_test, yhat)
# report the score
print('>%s Accuracy: %.3f' % (name, score*100))
例を実行すると、最初に3つのデータセットすべての要約が報告され、次にテストセット内の各基本モデルの精度が報告されます。
注： アルゴリズムの確率的性質、推定手順、または数値精度の違いにより、結果が異なる場合があります。例を数回試して、平均結果を比較してください。
この場合、すべてのモデルのパフォーマンスが混合アンサンブルよりも悪いことがわかります。興味深いことに、混合アンサンブルで達成された98,240％の精度と比較して、SVMは98,200％の精度の達成に非常に近いことがわかります。
Train: (5000, 20), Test: (5000, 20) >lr Accuracy: 87.800 >knn Accuracy: 97.380 >cart Accuracy: 88.200 >svm Accuracy: 98.200 >bayes Accuracy: 87.300
最終モデルとして混合アンサンブルを選択できます。これには、トレーニングデータセット全体でアンサンブルをトレーニングし、新しい例を使用して予測を行うことが含まれます。特に、トレーニングセット全体は、ベースモデルとメタモデルをそれぞれトレーニングするためのトレーニングセットと検証セットに分割され、アンサンブルを予測に使用できます。分類に混合アンサンブルを使用して新しいデータを予測する完全な例は、次のようになります。
# example of making a prediction with a blending ensemble for classification
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for _, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for _, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.30335011, 2.68066314, 2.07794281, 1.15253537, -2.0583897, -2.51936601, 0.67513028, -3.20651939, -1.60345385, 3.68820714, 0.05370913, 1.35804433, 0.42011397, 1.4732839, 2.89997622, 1.61119399, 7.72630965, -2.84089477, -1.83977415, 1.34381989]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted Class: %d' % (yhat))
この例を実行すると、データセットで混合アンサンブルモデルがトレーニングされ、アプリケーションでモデルを使用する場合と同様に、それを使用してデータの新しい行が予測されます。
Train: (6700, 20), Val: (3300, 20) Predicted Class: 1
混合アンサンブルの回帰を評価する方法を見てみましょう。
回帰問題の混合アンサンブル
このセクションでは、回帰問題にバッチ処理を使用する方法について説明します。まず、make_regression（）関数 を使用して、10,000個のサンプルと20個の入力フィーチャを含む合成回帰問題を作成できます。全体の例を以下に示します。
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
例を実行すると、データセットが作成され、入力コンポーネントと出力コンポーネントが要約されます。
(10000, 20) (10000,)
次に、ベースラインとして使用する回帰モデルのリストを定義できます。この場合、線形回帰、kNN、決定ツリー、およびSVMモデルを使用します。
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
アンサンブルのトレーニングに使用されるfit_ensemble（）関数 は、ミキシングに使用されるモデルを回帰に変更する必要があることを除いて、変更されません。ここでは、線形回帰モデルを使用します。
...
# define blending model
blender = LinearRegression()
これが回帰問題であるとすると、エラーメトリック、この場合は平均絶対エラー、または（省略された）MAEを使用してモデルのパフォーマンスを評価します。
...
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)
合成回帰予測モデリング問題の混合アンサンブルの全体的な例を以下に示します。
# evaluate blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LinearRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)
この例では、最初に3つのデータセットの要約を出力し、次にMAEをテストセットに出力します。
注： アルゴリズムや推定手順の確率的な性質、または数値の精度の違いにより、結果が異なる場合があります。例を数回試して、平均結果を比較してください。
ここでは、アンサンブルがテストデータセットで約0.237のMAEに達したことがわかります。
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending MAE: 0.237
分類と同様に、混合アンサンブルは、基本的なアンサンブルモデルのいずれよりもパフォーマンスが優れている場合にのみ役立ちます。
これをテストするには、各ベースラインモデルを個別に評価し、最初に（アンサンブルではなく）トレーニングセット全体でトレーニングし、（アンサンブルのように）テストデータセットで予測を行います。以下の例では、各ベースラインモデルは、合成予測回帰モデリングデータセットに対して個別に推定されています。
# evaluate base models in isolation on the regression dataset
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:
# fit the model on the training dataset
model.fit(X_train_full, y_train_full)
# make a prediction on the test dataset
yhat = model.predict(X_test)
# evaluate the predictions
score = mean_absolute_error(y_test, yhat)
# report the score
print('>%s MAE: %.3f' % (name, score))
例を実行すると、最初にトレーニングセットとテストセットが要約され、次にテストデータセット内の各基本モデルのMAEが要約されます。
注： アルゴリズムや推定手順の確率的な性質、または数値の精度の違いにより、結果が異なる場合があります。例を数回試して、平均結果を比較してください。
ここでは、実際、線形回帰モデルのパフォーマンスが混合アンサンブルよりもわずかに優れており、0.237と比較して0.236のMAEに達していることがわかります。これは、合成データセットがどのように構築されたかに関係している可能性があります。
ただし、この場合、まさにこのタスクに線形回帰モデルを使用することをお勧めします。この状況は、アンサンブルモデルを最終として受け入れる前に、貢献モデルのパフォーマンスを検証することの重要性を強調しています。
Train: (5000, 20), Test: (5000, 20) >lr MAE: 0.236 >knn MAE: 100.169 >cart MAE: 133.744 >svm MAE: 138.195
ここでも、混合アンサンブルを最終的な回帰モデルとして適用できます。このアプローチでは、データセット全体をトレーニングセットとテストセットに分割して、それぞれベースラインとメタモデルをトレーニングします。その後、アンサンブルを使用して新しいデータ行を予測できます。回帰問題の混合アンサンブルを使用して新しいデータから予測を行う完全な例を以下に示します。
# example of making a prediction with a blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for _, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LinearRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for _, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.24038754, 0.55423865, -0.48979221, 1.56074459, -1.16007611, 1.10049103, 1.18385406, -1.57344162, 0.97862519, -0.03166643, 1.77099821, 1.98645499, 0.86780193, 2.01534177, 2.51509494, -1.04609004, -0.19428148, -0.05967386, -2.67168985, 1.07182911]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted: %.3f' % (yhat[0]))
この例を実行すると、データセットでアンサンブルモデルがトレーニングされ、アプリケーションでモデルを使用する場合と同様に、それを使用してデータの新しい行が予測されます。
Train: (6700, 20), Val: (3300, 20) Predicted: 359.986
このセクションでは、このトピックについてさらに詳しく知りたい場合のリソースが含まれています。
また、バナー割引に10％を追加するプロモーションコードHABRを忘れないでください 。
