7 Scikit-Belajar Rahsia Yang Mungkin Anda Tidak Tahu

Sebagai saintis data dengan kemahiran pengaturcaraan Python, kami banyak menggunakan Scikit-Learn. Ia adalah pakej pembelajaran mesin yang biasanya diajar kepada pengguna baharu pada mulanya dan boleh digunakan terus hingga pengeluaran. Walau bagaimanapun, kebanyakan perkara yang diajar adalah pelaksanaan asas, dan Scikit-Learn mengandungi banyak rahsia untuk meningkatkan aliran kerja data kami.

Artikel ini akan membincangkan tujuh rahsia daripada Scikit-Learn yang mungkin anda tidak tahu. Tanpa berlengah lagi, mari kita masuk ke dalamnya.

1. Penentukuran Kebarangkalian

Beberapa model tugas klasifikasi model pembelajaran mesin menyediakan output kebarangkalian untuk setiap kelas. Masalah dengan output anggaran kebarangkalian ialah ia tidak semestinya ditentukur dengan baik, yang bermaksud bahawa ia tidak menggambarkan kemungkinan sebenar output.

Sebagai contoh, model anda mungkin memberikan 95% daripada output kelas "penipuan", tetapi hanya 70% daripada ramalan itu adalah betul. Penentukuran kebarangkalian akan bertujuan untuk melaraskan kebarangkalian untuk mencerminkan kemungkinan sebenar.

Terdapat beberapa kaedah penentukuran, walaupun yang paling biasa ialah penentukuran sigmoid dan regresi isotonik. Kod berikut menggunakan Scikit-Learn untuk menentukur teknik dalam pengelas.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.svm import SVC

svc = SVC(probability=False)
calibrated_svc = CalibratedClassifierCV(base_estimator=svc, method='sigmoid', cv=5)
calibrated_svc.fit(X_train, y_train)
probabilities = calibrated_svc.predict_proba(X_test)

Anda boleh menukar model asalkan ia menyediakan output kebarangkalian. Kaedah ini membolehkan anda menukar antara "sigmoid" atau "isotonik".

Sebagai contoh, berikut ialah pengelas Hutan Rawak dengan penentukuran isotonik.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(random_state=42)
calibrated_rf = CalibratedClassifierCV(base_estimator=rf, method='isotonic', cv=5)
calibrated_rf.fit(X_train, y_train)
probabilities = calibrated_rf.predict_proba(X_test)

Jika model anda tidak memberikan ramalan yang diingini, pertimbangkan untuk menentukur pengelas anda.

2. Kesatuan Ciri

Rahsia seterusnya yang akan kami terokai ialah pelaksanaan kesatuan ciri. Jika anda tidak tahu mengenainya, gabungan ciri ialah Kelas Scikit yang menyediakan cara untuk menggabungkan berbilang objek pengubah menjadi satu pengubah.

Ia adalah kelas yang berharga apabila kami ingin melakukan pelbagai transformasi dan pengekstrakan daripada set data yang sama dan menggunakannya secara selari untuk pemodelan pembelajaran mesin kami.

Mari lihat cara ia berfungsi dalam kod berikut.

from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest
from sklearn.svm import SVC

combined_features = FeatureUnion([
    ("pca", PCA(n_components=2)),
    ("select_best", SelectKBest(k=1))
])

pipeline = Pipeline([
    ("features", combined_features),
    ("svm", SVC())
])

pipeline.fit(X_train, y_train)

Dalam kod di atas, kita dapat melihat bahawa kita menggabungkan dua kaedah pengubah untuk pengurangan dimensi dengan PCA dan memilih ciri teratas terbaik ke dalam satu saluran paip pengubah dengan gabungan ciri. Menggabungkannya dengan saluran paip akan membolehkan kesatuan ciri kami digunakan dalam proses tunggal.

Ia juga mungkin untuk merantai kesatuan ciri jika anda ingin mengawal manipulasi dan prapemprosesan ciri dengan lebih baik. Berikut ialah contoh kaedah sebelumnya yang kami bincangkan dengan kesatuan ciri tambahan.

# First FeatureUnion
first_union = FeatureUnion([
    ("pca", PCA(n_components=5)),
    ("select_best", SelectKBest(k=5))
])

# Second FeatureUnion
second_union = FeatureUnion([
    ("poly", PolynomialFeatures(degree=2, include_bias=False)),
    ("scaled", StandardScaler())
])

pipeline = Pipeline([
    ("first_union", first_union),
    ("second_union", second_union),
    ("svm", SVC())
])

pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)

Ia merupakan metodologi yang sangat baik untuk mereka yang memerlukan prapemprosesan yang meluas pada permulaan proses pemodelan pembelajaran mesin.

3. Penggabungjalinan Ciri

Rahsia seterusnya yang akan kami terokai ialah aglomerasi ciri. Ini ialah kaedah pemilihan ciri daripada Scikit-Learn tetapi menggunakan pengelompokan hierarki untuk menggabungkan ciri yang serupa.

Penggabungan ciri ialah metodologi pengurangan dimensi, yang bermaksud ia berguna apabila terdapat banyak ciri dan beberapa ciri berkorelasi dengan ketara antara satu sama lain. Ia juga berdasarkan pengelompokan hierarki, menggabungkan ciri berdasarkan kriteria kaitan dan ukuran jarak yang kami tetapkan.

Mari lihat cara ia berfungsi dalam kod berikut.

from sklearn.cluster import FeatureAgglomeration

agglo = FeatureAgglomeration(n_clusters=10)
X_reduced = agglo.fit_transform(X)

Kami menyediakan bilangan ciri yang kami mahu dengan menetapkan nombor kluster. Mari lihat bagaimana kita menukar ukuran jarak kepada persamaan kosinus.

agglo = FeatureAgglomeration(metric='cosine')

Kami juga boleh menukar kaedah pautan dengan kod berikut.

agglo = FeatureAgglomeration(linkage='average')

Kemudian, kita juga boleh menukar fungsi untuk mengagregat ciri untuk ciri baharu.

import numpy as np 
agglo = FeatureAgglomeration(pooling_func=np.median)

Cuba bereksperimen dengan aglomerasi ciri untuk memperoleh set data terbaik untuk pemodelan anda.

4. Pemisahan Pratakrif

Pemisahan yang dipratentukan ialah kelas Scikit-Learn yang digunakan untuk strategi pengesahan silang tersuai. Ia menentukan skema semasa latihan dan pemisahan data ujian. Ini merupakan kaedah yang berharga apabila kami ingin membahagikan data kami dengan cara tertentu, dan lipatan K standard atau lipatan K berstrata tidak mencukupi.

Mari cuba perpecahan yang dipratentukan menggunakan kod di bawah.

from sklearn.model_selection import PredefinedSplit, GridSearchCV

# -1 for training, 0 for test
test_fold = [-1 if i < 100 else 0 for i in range(len(X))]
ps = PredefinedSplit(test_fold)

param_grid = {'parameter': [1, 10, 100]}
grid_search = GridSearchCV(model, param_grid, cv=ps)
grid_search.fit(X, y)

Dalam contoh di atas, kami menetapkan skema pemisahan data dengan memilih ratus data pertama sebagai latihan dan selebihnya sebagai ujian.

Strategi untuk berpecah bergantung pada keperluan anda. Kita boleh mengubahnya dengan proses pemberat.

sample_weights = np.random.rand(100)
test_fold = [-1 if i < 80 else 0 for i in range(len(X))]
ps = PredefinedSplit(test_fold)

Strategi ini menawarkan pandangan baru tentang proses pemisahan data, jadi cubalah untuk melihat sama ada ia menawarkan faedah kepada anda.

5. Permulaan Hangat

Pernahkah anda melatih model pembelajaran mesin yang memerlukan set data yang luas dan ingin melatihnya dalam kelompok? Atau adakah anda menggunakan pembelajaran dalam talian yang memerlukan pembelajaran tambahan menggunakan data penstriman? Jika anda mendapati diri anda dalam kes ini, anda tidak mahu melatih semula model dari awal.

Di sinilah permulaan yang hangat boleh membantu anda.

Permulaan hangat ialah parameter dalam model Scikit-Learn yang membolehkan kami menggunakan semula penyelesaian terlatih kami yang terakhir apabila memasang model semula. Kaedah ini berharga apabila kita tidak mahu melatih semula model kita dari awal.

Sebagai contoh, kod di bawah menunjukkan proses permulaan yang hangat apabila kami menambah lebih banyak pokok pada model dan melatihnya semula tanpa bermula dari awal.

from sklearn.ensemble import GradientBoostingClassifier

#100 trees
model = GradientBoostingClassifier(n_estimators=100, warm_start=True)
model.fit(X_train, y_train)

# Add 50 trees
model.n_estimators += 50
model.fit(X_train, y_train)

Anda juga boleh melakukan latihan kelompok dengan ciri permulaan yang hangat.

from sklearn.linear_model import SGDClassifier

model = SGDClassifier(max_iter=1000, warm_start=True)

# Train on first batch
model.fit(X_batch_1, y_batch_1)

# Continue training on second batch
model.fit(X_batch_2, y_batch_2)

Eksperimen dengan permulaan yang hangat untuk sentiasa mempunyai model terbaik tanpa mengorbankan masa latihan.

6. Pembelajaran Bertambah

Dan bercakap tentang pembelajaran tambahan, kita boleh menggunakan Scikit-Learn untuk melakukannya juga. Seperti yang dinyatakan di atas, pembelajaran tambahan — atau pembelajaran dalam talian — ialah proses latihan pembelajaran mesin di mana kami memperkenalkan data baharu secara berurutan.

Ia sering digunakan apabila set data kami adalah luas, atau data dijangka masuk dari semasa ke semasa. Ia juga digunakan apabila kami menjangkakan pengedaran data berubah dari semasa ke semasa, jadi latihan semula berterusan diperlukan, tetapi bukan dari awal.

Dalam kes ini, beberapa algoritma daripada Scikit-Learn menyediakan sokongan pembelajaran tambahan menggunakan kaedah muat separa. Ia akan membolehkan latihan model dijalankan secara berkelompok.

Mari lihat contoh kod.

from sklearn.linear_model import SGDClassifier
import numpy as np

classes = np.unique(y_train)
model = SGDClassifier()
for batch_X, batch_y in data_stream:
    model.partial_fit(batch_X, batch_y, classes=classes)

Pembelajaran tambahan akan terus berjalan selagi gelung berterusan.

Ia juga mungkin untuk melaksanakan pembelajaran tambahan bukan sahaja untuk latihan model tetapi juga untuk prapemprosesan.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
for batch_X, batch_y in data_stream:
    batch_X = scaler.partial_fit_transform(batch_X)
    model.partial_fit(batch_X, batch_y, classes=classes)

Jika pemodelan anda memerlukan pembelajaran tambahan, cuba gunakan kaedah muat separa daripada Scikit-Learn.

7. Mengakses Ciri Eksperimen

Tidak semua kelas dan fungsi dari Scikit-Learn telah dikeluarkan dalam versi yang stabil. Sesetengahnya masih dalam percubaan, dan kita mesti mendayakannya sebelum menggunakannya.

Jika kami ingin mendayakan ciri, kami perlu melihat ciri yang masih dalam percubaan dan mengimport API percubaan daya daripada Scikit-Learn.

Mari lihat contoh kod di bawah.

# Enable the experimental feature
from sklearn.experimental import enable_iterative_imputer  
from sklearn.impute import IterativeImputer

imputer = IterativeImputer(random_state=0)

Pada masa artikel ini ditulis, kelas IterativeImputer masih dalam fasa percubaan dan kami perlu mengimport pemboleh pada mulanya sebelum kami menggunakan kelas tersebut.

Satu lagi ciri yang masih dalam fasa percubaan ialah metodologi carian separuh.

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingRandomSearchCV
from sklearn.model_selection import HalvingGridSearchCV

Jika anda menemui ciri berguna dalam Scikit-Learn tetapi tidak dapat mengaksesnya, ia mungkin berada dalam fasa percubaan, jadi cuba aksesnya dengan mengimport pemboleh.

Kesimpulan

Scikit-Learn ialah perpustakaan popular yang digunakan dalam banyak pelaksanaan pembelajaran mesin. Terdapat begitu banyak ciri dalam perpustakaan yang sudah pasti banyak yang anda tidak sedari. Untuk mengkaji semula, tujuh rahsia yang kami bincangkan dalam artikel ini ialah:

  1. Penentukuran Kebarangkalian
  2. Kesatuan Ciri
  3. Penggabungjalinan Ciri
  4. Pemisahan Pratakrif
  5. Permulaan Hangat
  6. Pembelajaran Bertambah
  7. Mengakses Ciri Percubaan

Saya harap ini telah membantu!