Pembelajaran Mesin: Mencampur Ensemble dengan Python

Pencampuran adalah algoritma pembelajaran mesin ansambel. Ini adalah nama sehari-hari untuk generalisasi bertumpuk [selanjutnya kita akan menggunakan istilah "pengemasan" alih-alih istilah "penumpukan" yang diterima dalam karya ilmiah] atau ansambel pengemasan, di mana daripada melatih metamodel pada prediksi di luar kelompok yang dibuat oleh model dasar, model dilatih prediksi yang dibuat pada set data independen.



Pencampuran telah digunakan untuk mendeskripsikan model pengelompokan yang telah mengumpulkan ratusan model dalam kompetisi pembelajaran mesin Netflix senilai $ 1.000.000, dan dengan demikian, pencampuran tetap menjadi metode dan nama yang populer untuk pengelompokan dalam kontes pembelajaran mesin seperti Kaggle ... Terutama untuk memulai aliran baru kursus "Machine Learning"Kami membagikan tutorial tentang cara mengembangkan dan mengevaluasi ansambel campuran di python. Setelah menyelesaikan tutorial ini, Anda akan mengetahui:

• Ansambel campuran adalah jenis paket model di mana metamodel dilatih menggunakan prediksi pada set data validasi pengujian independen, bukan prediksi selama validasi silang k-fold.
• Cara mengembangkan ansambel campuran, termasuk pelatihan model dan fungsi prediksi berdasarkan data baru.
• Bagaimana mengevaluasi ansambel campuran untuk klasifikasi dan masalah pemodelan regresi prediktif.

---

Ringkasan tutorial

Tutorial ini dibagi menjadi empat bagian. Di sini mereka:

• Ansambel campuran.
• Penciptaan ansambel campuran.
• Ansambel campuran dalam masalah klasifikasi.
• Ansambel campuran dalam masalah regresi.

Ansambel campuran

Pencampuran adalah teknik pembelajaran mesin ansambel yang menggunakan model pembelajaran mesin untuk mencari tahu cara terbaik menggabungkan prediksi dari beberapa model anggota ansambel.



Jadi pencampuran sama dengan generalisasi susun yang dikenal sebagai susun. Blending dan batching sering digunakan secara bergantian dalam artikel atau deskripsi model yang sama.

Banyak praktisi pembelajaran mesin telah meraih keberhasilan menggunakan teknik batching dan terkait untuk meningkatkan akurasi prediksi atas model individual mana pun. Dalam beberapa konteks, batching juga disebut blending. Kami juga akan bertukar istilah di sini.

Penumpukan Linear Berbobot Fitur , 2009.

Arsitektur model batch berisi dua atau lebih model baseline, sering disebut sebagai model level nol, dan metamodel yang menggabungkan prediksi model baseline sebagai model level satu. Metamodel dilatih berdasarkan prediksi yang dibuat oleh model dasar pada data di luar sampel.

• Model level nol ( model dasar ) adalah model yang dilatih pada data pelatihan yang perkiraannya dikumpulkan.
• Model tingkat pertama ( metamodel ) adalah model yang belajar cara terbaik menggabungkan perkiraan model yang mendasarinya.

Namun, pencampuran memiliki konotasi tertentu untuk membangun model ansambel yang dikemas. Pencampuran dapat menawarkan pengembangan kumpulan tumpukan, di mana model dasarnya adalah semua jenis model pembelajaran mesin, dan metamodel adalah model linier yang "memadukan" prediksi model dasar. Misalnya, model regresi linier saat memprediksi nilai numerik, atau model regresi logistik saat memprediksi label kelas, menghitung jumlah tertimbang dari prediksi yang dibuat oleh model dasar dan akan diperlakukan sebagai prediksi campuran.

• Ansambel campuran : Gunakan model linier seperti regresi linier atau regresi logistik sebagai metamodel dalam ansambel model batch.

Pencampuran adalah istilah yang umum digunakan untuk ansambel yang dikemas selama kompetisi Netflix 2009. Kompetisi tersebut melibatkan tim yang mencari model prediktif yang berkinerja lebih baik daripada algoritme Netflix asli, dengan hadiah $ 1.000.000 diberikan kepada tim yang mencapai peningkatan kinerja 10 persen.

Solusi kami dengan RMSE = 0.8643 ^ 2 adalah campuran linier lebih dari 100 hasil. […] Sepanjang uraian metode, kami menyoroti prediktor spesifik yang berpartisipasi dalam solusi campuran akhir.

Solusi BellKor 2008 untuk Hadiah Netflix , 2008.

Jadi, pencampuran adalah istilah sehari-hari untuk pembelajaran ensembel dengan arsitektur model seperti batching. Jarang, jika pernah, digunakan dalam buku teks atau makalah akademis selain yang terkait dengan pembelajaran mesin dalam kompetisi. Paling umum, istilah "pencampuran" digunakan untuk menggambarkan aplikasi batching tertentu, di mana metamodel dilatih tentang prediksi yang dibuat oleh model dasar dengan kumpulan data validasi independen. Dalam konteks ini, pengemasan disediakan untuk metamodel yang dilatih tentang prediksi selama prosedur validasi silang.

• Blending : Ansambel tipe batching tempat metamodel dilatih tentang prediksi yang dibuat pada set data independen.
• Batching : Ansambel tipe batch tempat metamodel dilatih tentang prediksi yang dibuat selama validasi silang k-fold.

Perbedaan ini umum dalam komunitas kompetisi pembelajaran mesin Kaggle.

Pencampuran adalah kata yang diciptakan oleh para pemenang Netflix. Ini sangat mirip dengan generalisasi, tetapi sedikit lebih sederhana dan risiko kebocoran informasi lebih kecil. […] Dengan mencampur, alih-alih menghasilkan prediksi selama validasi silang untuk set pelatihan, Anda membuat set kecil independen, katakanlah, 10% dari set pelatihan. Model batching kemudian dilatih hanya pada set kecil ini.

Panduan Ensemble Kaggle , MLWave, 2015.

Kami menggunakan definisi terakhir dari pencampuran. Mari kita lihat bagaimana penerapannya.

Pengembangan ansambel campuran

Library scikit-learn tidak mendukung mixing out of the box pada saat penulisan ini. Tapi kita bisa mengimplementasikannya sendiri menggunakan model scikit-learn. Pertama, Anda perlu membuat satu set model dasar. Ini bisa menjadi model apa pun yang kita suka untuk masalah regresi atau klasifikasi. Kita bisa mendefinisikan fungsi get_models () yang mengembalikan daftar model, di mana setiap model didefinisikan sebagai tupel dengan nama dan pengklasifikasi yang disesuaikan atau objek regresi. Misalnya, untuk masalah klasifikasi, kita bisa menggunakan regresi logistik, kNN, pohon keputusan, SVM, dan model bayesian naif.

# 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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Selanjutnya, kita perlu melatih model pencampuran. Ingatlah bahwa model dasar dilatih pada set data pelatihan. Metamodel dilatih berdasarkan prediksi yang dibuat oleh setiap model dasar pada kumpulan data independen.



Pertama, kita dapat melakukan loop melalui model dalam daftar dan melatih masing-masing model pada set data pelatihan. Selain itu, dalam siklus ini, kita dapat menggunakan model terlatih untuk membuat prediksi pada dataset independen (validasi) dan menyimpan prediksi untuk masa depan.

...
# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Kami sekarang memiliki "meta_X *" yang mewakili input yang dapat digunakan untuk melatih metamodel. Setiap kolom atau objek mewakili output dari satu model dasar. Setiap baris mewakili satu sampel dari kumpulan data independen. Kita bisa menggunakan fungsi hstack () untuk memastikan bahwa kumpulan data ini adalah larik numpy dua dimensi, seperti yang diharapkan oleh model pembelajaran mesin.

...
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Sekarang kita bisa melatih model meta kita. Ini bisa berupa model pembelajaran mesin apa pun yang kita suka, seperti regresi logistik untuk masalah klasifikasi.

...
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Anda bisa menggabungkan semuanya menjadi fungsi yang disebut fit_ensemble () yang melatih model campuran menggunakan set data pelatihan dan validasi independen.

# 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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Langkah selanjutnya adalah menggunakan ansambel pencampuran untuk memprediksi data baru. Ini adalah proses dua langkah. Langkah pertama adalah menggunakan setiap model dasar untuk peramalan. Prediksi tersebut kemudian disatukan dan digunakan sebagai input pada model mixing untuk membuat prediksi akhir.



Kita bisa menggunakan siklus yang sama seperti saat melatih model. Yaitu, kumpulkan prediksi dari setiap model dasar ke dalam dataset pelatihan, tambahkan prediksi bersama-sama, dan panggil predict () pada model pencampuran dengan dataset metalevel tersebut. Predict_ensemble () fungsidi bawah mengimplementasikan tindakan ini. Dengan melatih daftar model dasar, melatih pencampur ansambel, dan kumpulan data (seperti kumpulan data uji atau data baru), ini akan mengembalikan kumpulan prediksi untuk kumpulan data.

# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Kami sekarang memiliki semua elemen yang diperlukan untuk mengimplementasikan ansambel campuran untuk klasifikasi atau masalah pemodelan regresi prediktif.

Ansambel campuran untuk masalah klasifikasi

Pada bagian ini, kita akan melihat penggunaan blending untuk tugas klasifikasi. Pertama, kita bisa menggunakan fungsi make_classification () untuk membuat masalah klasifikasi biner sintetik dengan 10.000 contoh dan 20 fitur masukan. Seluruh contoh ditampilkan di bawah ini.

# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh membuat kumpulan data dan merangkum masukan dan keluaran.

(10000, 20) (10000,)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Selanjutnya, kita perlu membagi dataset menjadi set pelatihan dan pengujian terlebih dahulu, lalu set pelatihan menjadi subset yang digunakan untuk melatih model dasar dan subset yang digunakan untuk melatih metamodel. Dalam kasus ini, kita akan menggunakan pemisahan 50-50 untuk set pelatihan dan pengujian, dan kemudian pemisahan 67-33 untuk set pelatihan dan validasi.

...
# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Anda kemudian dapat menggunakan fungsi get_models () dari bagian sebelumnya untuk membuat model klasifikasi yang digunakan dalam ansambel. Fungsi fit_ensemble () kemudian dapat dipanggil untuk melatih ensembel campuran pada kumpulan data ini, dan fungsi predict_ensemble () dapat digunakan untuk membuat prediksi pada kumpulan data independen.

...
# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Terakhir, kami dapat mengevaluasi performa model campuran dengan melaporkan keakuratan klasifikasi pada set data pengujian.

...
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % score)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Contoh lengkap memperkirakan ansambel campuran dalam masalah klasifikasi biner sintetis diberikan di bawah ini.

# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh terlebih dahulu melaporkan ringkasan semua kumpulan data dan kemudian ketepatan ansambel dalam kumpulan data pengujian.



Catatan: Hasil Anda mungkin berbeda karena sifat stokastik dari algoritma atau prosedur estimasi, atau perbedaan dalam ketepatan numerik. Pertimbangkan untuk menjalankan contoh beberapa kali dan membandingkan rata-rata.



Di sini kita melihat bahwa ensembel campuran mencapai akurasi klasifikasi sekitar 97.900%.

Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending Accuracy: 97.900
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Pada contoh sebelumnya, prediksi label kelas yang jelas digabungkan menggunakan model pencampuran. Ini adalah jenis voting yang sulit . Alternatif adalah metode di mana setiap model memprediksi probabilitas kelas dan menggunakan metamodel untuk mencampur probabilitas. Ini adalah jenis suara lunak yang terkadang dapat menghasilkan kinerja yang lebih baik. Pertama, kita perlu mengonfigurasi model yang mengembalikan probabilitas, seperti model 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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Kemudian model yang mendasarinya perlu dimodifikasi untuk memprediksi probabilitas, bukan label kelas yang jelas. Ini bisa dicapai dengan memanggil predict_proba () di dalam fit_ensemble () sambil melatih model yang mendasarinya.

...
# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Artinya, meta-dataset yang digunakan untuk melatih meta-model akan memiliki n kolom per pengklasifikasi, di mana n adalah jumlah kelas dalam masalah peramalan, dalam kasus kami ada dua kelas. Kami juga perlu mengubah prediksi yang dibuat oleh model dasar saat menggunakan model pencampuran untuk memprediksi data baru.

...
# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Seluruh contoh penggunaan pencampuran pada probabilitas kelas yang diprediksi untuk masalah klasifikasi biner sintetis diberikan di bawah ini.

# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh pertama-tama melaporkan ringkasan semua kumpulan data dan kemudian ketepatan ansambel dalam kumpulan pengujian.



Catatan: Hasil Anda dapat bervariasi karena sifat stokastik dari algoritme atau prosedur estimasi, atau perbedaan dalam ketepatan numerik. Coba contoh beberapa kali dan bandingkan hasil rata-rata.



Di sini kita melihat bahwa pencampuran probabilitas kelas menyebabkan peningkatan akurasi klasifikasi hingga sekitar 98,240%.

Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending Accuracy: 98.240
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Ansambel campuran hanya efektif jika dapat mengungguli model individu mana pun di dalamnya. Kami dapat mengonfirmasi hal ini dengan mengevaluasi setiap model dasar secara terpisah. Setiap model dasar dapat dilatih pada seluruh set data pelatihan (sebagai lawan dari ansambel pencampuran) dan dievaluasi pada set data pengujian (seperti dalam ansambel pencampuran). Contoh di bawah menunjukkan hal ini dengan mengevaluasi setiap model baseline secara terpisah.

# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh terlebih dahulu melaporkan ringkasan dari ketiga set data, lalu keakuratan setiap model dasar dalam set pengujian.



Catatan: Hasil Anda mungkin berbeda karena sifat stokastik dari algoritme, atau prosedur estimasi, atau perbedaan dalam ketepatan numerik. Coba contoh beberapa kali dan bandingkan hasil rata-rata.



Dalam kasus ini, kami melihat bahwa semua model berperforma lebih buruk daripada ansambel campuran. Hal yang menarik adalah kita dapat melihat bahwa SVM sangat mendekati akurasi 98.200% dibandingkan dengan akurasi 98.240% yang dicapai dengan mixed ensemble.

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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Kita dapat memilih ansambel campuran sebagai model terakhir kita. Ini termasuk melatih ansambel di seluruh set data pelatihan dan membuat prediksi menggunakan contoh baru. Secara khusus, seluruh set pelatihan dibagi menjadi set pelatihan dan validasi masing-masing untuk melatih basis dan metamodel, dan kemudian ensembel tersebut dapat digunakan dalam peramalan. Contoh lengkap meramalkan data baru menggunakan ansambel campuran untuk klasifikasi terlihat seperti ini:

# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh melatih model ansambel campuran pada set data dan kemudian menggunakannya untuk memprediksi baris data baru, seperti yang akan terjadi jika menggunakan model dalam aplikasi.

Train: (6700, 20), Val: (3300, 20)
Predicted Class: 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Mari kita lihat bagaimana kita bisa mengevaluasi ansambel campuran untuk regresi.

Ansambel campuran untuk masalah regresi

Di bagian ini, kita akan melihat penggunaan batching untuk masalah regresi. Pertama, kita dapat menggunakan fungsi make_regress () untuk membuat masalah regresi sintetik dengan 10.000 sampel dan 20 fitur masukan. Seluruh contoh ditampilkan di bawah ini.

# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh membuat kumpulan data dan merangkum komponen input dan output.

(10000, 20) (10000,)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Selanjutnya, Anda dapat menentukan daftar model regresi untuk digunakan sebagai baseline. Dalam hal ini, kami menggunakan model regresi linier, kNN, pohon keputusan dan 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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Fungsi fit_ensemble () yang digunakan untuk melatih ansambel tidak berubah, kecuali bahwa model yang digunakan untuk pencampuran harus diubah ke regresi. Di sini kami menggunakan model regresi linier.

...
# define blending model
blender = LinearRegression()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Mengingat ini adalah masalah regresi, kami akan mengevaluasi kinerja model menggunakan metrik kesalahan, dalam hal ini kesalahan absolut rata-rata, atau (disingkat) MAE.

...
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Seluruh contoh ansambel campuran untuk masalah pemodelan prediktif regresi sintetik diberikan di bawah ini:

# 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)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Contoh pertama mencetak ringkasan dari tiga set data dan kemudian MAE pada set pengujian.



Catatan: Hasil Anda dapat bervariasi karena sifat stokastik dari algoritme atau prosedur estimasi, atau perbedaan dalam ketepatan numerik. Coba contoh beberapa kali dan bandingkan hasil rata-rata.



Di sini kita melihat bahwa ensembel mencapai MAE sekitar 0,237 pada dataset pengujian.

Train: (3350, 20), Val: (1650, 20), Test: (5000, 20)
Blending MAE: 0.237
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Seperti halnya klasifikasi, ansambel campuran hanya berguna jika kinerjanya lebih baik daripada model ansambel dasar mana pun.



Kita dapat menguji ini dengan mengevaluasi setiap model dasar secara terpisah, pertama melatihnya di seluruh set pelatihan (sebagai lawan dari ansambel), dan membuat prediksi pada set data uji (seperti dalam ansambel). Pada contoh di bawah, masing-masing model dasar diperkirakan secara terpisah terhadap kumpulan data pemodelan regresi prediktif sintetik.

# 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))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh terlebih dahulu merangkum set pelatihan dan pengujian, lalu MAE dari setiap model dasar dalam set data pengujian.



Catatan: Hasil Anda dapat bervariasi karena sifat stokastik dari algoritme atau prosedur estimasi, atau perbedaan dalam ketepatan numerik. Coba contoh beberapa kali dan bandingkan hasil rata-rata.



Di sini Anda dapat melihat bahwa sebenarnya model regresi linier berkinerja sedikit lebih baik daripada ansambel campuran, mencapai MAE 0,236 dibandingkan dengan 0,237. Ini mungkin ada hubungannya dengan bagaimana kumpulan data sintetis dibuat.



Namun, dalam kasus ini, kami lebih suka menggunakan model regresi linier untuk tugas ini. Situasi ini menggarisbawahi pentingnya memvalidasi kinerja model yang berkontribusi sebelum menerima model ensemble sebagai final.

Train: (5000, 20), Test: (5000, 20)
>lr MAE: 0.236
>knn MAE: 100.169
>cart MAE: 133.744
>svm MAE: 138.195
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Sekali lagi, Anda dapat menerapkan ansambel campuran sebagai model regresi akhir. Pendekatan ini melibatkan pemisahan seluruh dataset menjadi set pelatihan dan pengujian untuk melatih baseline dan metamodel padanya, masing-masing, kemudian ensembel dapat digunakan untuk memprediksi baris data baru. Contoh lengkap untuk memprediksi data baru menggunakan ansambel campuran untuk masalah regresi diberikan di bawah ini.

# 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]))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Menjalankan contoh melatih model ansambel pada set data dan kemudian menggunakannya untuk memprediksi baris data baru, seperti jika menggunakan model dalam aplikasi.

Train: (6700, 20), Val: (3300, 20)
Predicted: 359.986
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Dan jangan lupakan kode promo HABR yang menambahkan 10% pada diskon banner.

• Kursus Machine Learning
• Kursus Lanjutan "Machine Learning Pro + Deep Learning"
• Kursus "Matematika dan Pembelajaran Mesin untuk Ilmu Data"

Artikel yang direkomendasikan

• Berapa Banyak Data Scientist Hasilkan: Gambaran Umum Gaji dan Pekerjaan di 2020
• Berapa Banyak Penghasilan Analis Data: Gambaran Umum Gaji dan Pekerjaan di 2020
• Bagaimana Menjadi Ilmuwan Data Tanpa Kursus Online
• 450 kursus gratis dari Ivy League
• Cara mempelajari Machine Learning 5 hari seminggu selama 9 bulan berturut-turut
• Pembelajaran Mesin dan Visi Komputer di Industri Pertambangan
• Pembelajaran Mesin dan Visi Komputer di pabrik penerima