Scikit-Learn Eğitimi: Nasıl Kurulur ve Scikit-Learn Örnekleri
Evelyn Clarke
Scikit-learn nedir?
Scikit-öğrenme açık kaynaklı Python makine öğrenimi için kütüphane. KNN, XGBoost, rastgele orman ve SVM gibi son teknoloji algoritmaları destekler. NumPy üzerine kurulmuştur. Scikit-learn, Kaggle rekabetinde ve önde gelen teknoloji şirketlerinde yaygın olarak kullanılır. Ön işleme, boyut azaltma (parametre seçimi), sınıflandırma, regresyon, kümeleme ve model seçiminde yardımcı olur.
Scikit-learn tüm açık kaynak kütüphaneler arasında en iyi dokümantasyona sahiptir. Size şu adreste etkileşimli bir grafik sunar: https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html.
Scikit-learn'ün kullanımı çok zor değildir ve mükemmel sonuçlar verir. Ancak scikit Learn paralel hesaplamaları desteklemez. Bununla derin bir öğrenme algoritması çalıştırmak mümkündür ancak özellikle TensorFlow'u nasıl kullanacağınızı biliyorsanız bu optimal bir çözüm değildir.
Scikit-learn Nasıl İndirilir ve Kurulur
Şimdi bunda Python Scikit-learn eğitimi, Scikit-learn'ün nasıl indirilip kurulacağını öğreneceğiz:
Seçenek 1: AWS
scikit-learn AWS üzerinden kullanılabilir. Lütfen başvurmak Scikit-learn'in önceden yüklendiği liman işçisi görüntüsü.
Geliştirici sürümünü kullanmak için şu komutu kullanın: Jupyter
import sys
!{sys.executable} -m pip install git+git://github.com/scikit-learn/scikit-learn.git
Seçenek 2: Mac veya Windows Anaconda'yı kullanma
Anaconda kurulumu hakkında bilgi edinmek için bkz. https://www.guru99.com/download-install-tensorflow.html
Son zamanlarda scikit geliştiricileri, mevcut sürümde karşılaşılan yaygın sorunları çözen bir geliştirme sürümü yayınladı. Güncel sürüm yerine geliştirici sürümünü kullanmayı daha uygun bulduk.
Conda Environment ile scikit-learn nasıl kurulur
Scikit-learn'ü conda ortamıyla yüklediyseniz lütfen 0.20 sürümüne güncelleme adımını izleyin.
) 1 Adım Tensorflow ortamını etkinleştirin
source activate hello-tf
) 2 Adım Conda komutunu kullanarak scikit yalınını kaldırın
conda remove scikit-learn
) 3 Adım Geliştirici sürümünü yükleyin.
Scikit Learn geliştirici sürümünü gerekli kütüphanelerle birlikte yükleyin.
conda install -c anaconda git pip install Cython pip install h5py pip install git+git://github.com/scikit-learn/scikit-learn.git
NOT: Windows kullanıcının yüklemesi gerekecek Microsoft Görsel C++ 14. Şu adresten alabilirsiniz: okuyun
Makine Öğrenimi ile Scikit-Learn Örneği
Bu Scikit eğitimi iki bölüme ayrılmıştır:
- Scikit-learn ile makine öğrenimi
- LIME ile modelinize nasıl güvenebilirsiniz?
İlk bölümde bir boru hattının nasıl oluşturulacağı, bir modelin nasıl oluşturulacağı ve hiperparametrelerin nasıl ayarlanacağı ayrıntılarıyla açıklanırken, ikinci bölümde model seçimi açısından son durum sunulmaktadır.
Adım 1) Verileri içe aktarın
Bu Scikit öğrenme eğitimi sırasında yetişkinlere yönelik veri kümesini kullanacaksınız.
Bu veri kümesinin arka planı için bkz. Tanımlayıcı istatistikler hakkında daha fazla bilgi edinmek istiyorsanız lütfen Dalış ve Genel Bakış araçlarını kullanın.
Toplam Bu eğitimde Dalış ve Genel Bakış hakkında daha fazla bilgi edinin
Veri kümesini Pandas ile içe aktarırsınız. Sürekli değişkenlerin türünü float biçiminde dönüştürmeniz gerektiğini unutmayın.
Bu veri kümesi sekiz kategorik değişken içerir:
Kategorik değişkenler CATE_FEATURES'ta listelenmiştir
- çalışma sınıfı
- eğitim
- evlilik
- işgal
- ilişki
- yarış
- seks
- ana vatan
ayrıca altı sürekli değişken:
Sürekli değişkenler CONTI_FEATURES içinde listelenmiştir
- yaş
- fnlwgt
- eğitim_num
- Sermaye kazancı
- sermaye_kaybı
- saat_hafta
Hangi sütunları kullandığımız hakkında daha iyi bir fikir sahibi olmanız için listeyi elle doldurduğumuzu unutmayın. Kategorik veya sürekli bir liste oluşturmanın daha hızlı bir yolu şunu kullanmaktır:
## List Categorical
CATE_FEATURES = df_train.iloc[:,:-1].select_dtypes('object').columns
print(CATE_FEATURES)
## List continuous
CONTI_FEATURES = df_train._get_numeric_data()
print(CONTI_FEATURES)
Verileri içe aktarmak için gereken kod:
# Import dataset
import pandas as pd
## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
'hours_week', 'native_country', 'label']
### Define continuous list
CONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
## Prepare the data
features = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
'hours_week', 'native_country']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_train[CONTI_FEATURES] =df_train[CONTI_FEATURES].astype('float64')
df_train.describe()
| yaş | fnlwgt | eğitim_num | Sermaye kazancı | sermaye_kaybı | saat_hafta | |
|---|---|---|---|---|---|---|
| saymak | 32561.000000 | 3.256100e + 04 | 32561.000000 | 32561.000000 | 32561.000000 | 32561.000000 |
| ortalama | 38.581647 | 1.897784e + 05 | 10.080679 | 1077.648844 | 87.303830 | 40.437456 |
| std | 13.640433 | 1.055500e + 05 | 2.572720 | 7385.292085 | 402.960219 | 12.347429 |
| dk | 17.000000 | 1.228500e + 04 | 1.000000 | 0.000000 | 0.000000 | 1.000000 |
| 25% | 28.000000 | 1.178270e + 05 | 9.000000 | 0.000000 | 0.000000 | 40.000000 |
| 50% | 37.000000 | 1.783560e + 05 | 10.000000 | 0.000000 | 0.000000 | 40.000000 |
| 75% | 48.000000 | 2.370510e + 05 | 12.000000 | 0.000000 | 0.000000 | 45.000000 |
| maksimum | 90.000000 | 1.484705e + 06 | 16.000000 | 99999.000000 | 4356.000000 | 99.000000 |
Native_country özelliklerinin benzersiz değerlerinin sayısını kontrol edebilirsiniz. Hollanda-Hollanda'dan sadece bir hanenin geldiğini görüyorsunuz. Bu hane bize herhangi bir bilgi getirmeyecek ama eğitim sırasında bir hata yapacak.
df_train.native_country.value_counts()
United-States 29170 Mexico 643 ? 583 Philippines 198 Germany 137 Canada 121 Puerto-Rico 114 El-Salvador 106 India 100 Cuba 95 England 90 Jamaica 81 South 80 China 75 Italy 73 Dominican-Republic 70 Vietnam 67 Guatemala 64 Japan 62 Poland 60 Columbia 59 Taiwan 51 Haiti 44 Iran 43 Portugal 37 Nicaragua 34 Peru 31 France 29 Greece 29 Ecuador 28 Ireland 24 Hong 20 Cambodia 19 Trinadad&Tobago 19 Thailand 18 Laos 18 Yugoslavia 16 Outlying-US(Guam-USVI-etc) 14 Honduras 13 Hungary 13 Scotland 12 Holand-Netherlands 1 Name: native_country, dtype: int64
Bilgilendirici olmayan bu satırı veri kümesinden hariç tutabilirsiniz
## Drop Netherland, because only one row df_train = df_train[df_train.native_country != "Holand-Netherlands"]
Daha sonra sürekli özelliklerin konumunu bir listede saklarsınız. Boru hattını oluşturmak için bir sonraki adımda buna ihtiyacınız olacak.
Aşağıdaki kod, CONTI_FEATURES içindeki tüm sütun adları üzerinde döngü yapacak ve konumunu (yani numarasını) alacak ve ardından bunu conti_features adlı bir listeye ekleyecektir.
## Get the column index of the categorical features
conti_features = []
for i in CONTI_FEATURES:
position = df_train.columns.get_loc(i)
conti_features.append(position)
print(conti_features)
[0, 2, 10, 4, 11, 12]
Aşağıdaki kod yukarıdakiyle aynı işi yapar ancak kategorik değişken için. Aşağıdaki kod, kategorik özellikler dışında daha önce yaptıklarınızı tekrarlar.
## Get the column index of the categorical features
categorical_features = []
for i in CATE_FEATURES:
position = df_train.columns.get_loc(i)
categorical_features.append(position)
print(categorical_features)
[1, 3, 5, 6, 7, 8, 9, 13]
Veri setine göz atabilirsiniz. Her kategorik özelliğin bir dize olduğunu unutmayın. Bir modeli dize değeriyle besleyemezsiniz. Veri kümesini yapay bir değişken kullanarak dönüştürmeniz gerekir.
df_train.head(5)
Aslında özellikteki her grup için bir sütun oluşturmanız gerekiyor. Öncelikle gereken toplam sütun miktarını hesaplamak için aşağıdaki kodu çalıştırabilirsiniz.
print(df_train[CATE_FEATURES].nunique(),
'There are',sum(df_train[CATE_FEATURES].nunique()), 'groups in the whole dataset')
workclass 9 education 16 marital 7 occupation 15 relationship 6 race 5 sex 2 native_country 41 dtype: int64 There are 101 groups in the whole dataset
Tüm veri seti yukarıda gösterildiği gibi 101 grup içerir. Örneğin, workclass'ın özellikleri dokuz gruba sahiptir. Grupların adını aşağıdaki kodlarla görselleştirebilirsiniz
Unique(), kategorik özelliklerin benzersiz değerlerini döndürür.
for i in CATE_FEATURES:
print(df_train[i].unique())
['State-gov' 'Self-emp-not-inc' 'Private' 'Federal-gov' 'Local-gov' '?' 'Self-emp-inc' 'Without-pay' 'Never-worked'] ['Bachelors' 'HS-grad' '11th' 'Masters' '9th' 'Some-college' 'Assoc-acdm' 'Assoc-voc' '7th-8th' 'Doctorate' 'Prof-school' '5th-6th' '10th' '1st-4th' 'Preschool' '12th'] ['Never-married' 'Married-civ-spouse' 'Divorced' 'Married-spouse-absent' 'Separated' 'Married-AF-spouse' 'Widowed'] ['Adm-clerical' 'Exec-managerial' 'Handlers-cleaners' 'Prof-specialty' 'Other-service' 'Sales' 'Craft-repair' 'Transport-moving' 'Farming-fishing' 'Machine-op-inspct' 'Tech-support' '?' 'Protective-serv' 'Armed-Forces' 'Priv-house-serv'] ['Not-in-family' 'Husband' 'Wife' 'Own-child' 'Unmarried' 'Other-relative'] ['White' 'Black' 'Asian-Pac-Islander' 'Amer-Indian-Eskimo' 'Other'] ['Male' 'Female'] ['United-States' 'Cuba' 'Jamaica' 'India' '?' 'Mexico' 'South' 'Puerto-Rico' 'Honduras' 'England' 'Canada' 'Germany' 'Iran' 'Philippines' 'Italy' 'Poland' 'Columbia' 'Cambodia' 'Thailand' 'Ecuador' 'Laos' 'Taiwan' 'Haiti' 'Portugal' 'Dominican-Republic' 'El-Salvador' 'France' 'Guatemala' 'China' 'Japan' 'Yugoslavia' 'Peru' 'Outlying-US(Guam-USVI-etc)' 'Scotland' 'Trinadad&Tobago' 'Greece' 'Nicaragua' 'Vietnam' 'Hong' 'Ireland' 'Hungary']
Bu nedenle eğitim veri seti 101 + 7 sütun içerecektir. Son yedi sütun sürekli özelliklerdir.
Scikit-learn dönüşümle ilgilenebilir. İki adımda yapılır:
- İlk önce dizeyi kimliğe dönüştürmeniz gerekir. Örneğin, State-gov ID 1'e, Self-emp-not-inc ID 2'ye vb. sahip olacaktır. LabelEncoder işlevi bunu sizin için yapar
- Her kimliği yeni bir sütuna aktarın. Daha önce de belirtildiği gibi veri kümesinde 101 grubun kimliği bulunmaktadır. Bu nedenle, tüm kategorik özellik gruplarını kapsayan 101 sütun olacaktır. Scikit-learn'de bu işlemi gerçekleştiren OneHotEncoder adında bir fonksiyon bulunmaktadır.
Adım 2) Eğitim/test setini oluşturun
Artık veri seti hazır olduğuna göre 80/20'ye bölebiliriz.
Eğitim seti için yüzde 80 ve test seti için yüzde 20.
train_test_split'i kullanabilirsiniz. İlk argüman veri çerçevesinin özellikler ve ikinci argüman ise etiket veri çerçevesidir. Test setinin boyutunu test_size ile belirleyebilirsiniz.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df_train[features],
df_train.label,
test_size = 0.2,
random_state=0)
X_train.head(5)
print(X_train.shape, X_test.shape)
(26048, 14) (6512, 14)
Adım 3) Boru hattını oluşturun
İşlem hattı, modelin tutarlı verilerle beslenmesini kolaylaştırır.
Arkasındaki fikir, işlemleri gerçekleştirmek için ham verileri bir 'boru hattına' koymaktır.
Örneğin mevcut veri seti ile sürekli değişkenleri standartlaştırmanız ve kategorik verileri dönüştürmeniz gerekiyor. İşlem hattının içinde herhangi bir işlemi gerçekleştirebileceğinizi unutmayın. Örneğin, veri kümesinde 'NA'lar varsa bunları ortalama veya medyanla değiştirebilirsiniz. Ayrıca yeni değişkenler de oluşturabilirsiniz.
Seçeneğiniz var; iki süreci sabit kodlayın veya bir işlem hattı oluşturun. İlk tercih veri sızıntısına yol açabilir ve zamanla tutarsızlıklar yaratabilir. Daha iyi bir seçenek boru hattını kullanmaktır.
from sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder from sklearn.compose import ColumnTransformer, make_column_transformer from sklearn.pipeline import make_pipeline from sklearn.linear_model import LogisticRegression
Boru hattı, lojistik sınıflandırıcıyı beslemeden önce iki işlem gerçekleştirecektir:
- Değişkeni standartlaştırın: `StandardScaler()“
- Kategorik özellikleri dönüştürün: OneHotEncoder(sparse=False)
Make_column_transformer'ı kullanarak iki adımı gerçekleştirebilirsiniz. Bu işlev scikit-learn'in mevcut sürümünde (0.19) mevcut değildir. Mevcut sürümde etiket kodlayıcıyı ve bir sıcak kodlayıcıyı üretim hattında gerçekleştirmek mümkün değildir. Geliştirici sürümünü kullanmaya karar vermemizin bir nedeni de budur.
make_column_transformer'ın kullanımı kolaydır. Dönüşümün hangi sütunlara uygulanacağını ve hangi dönüşümün işleneceğini tanımlamanız gerekir. Örneğin sürekli özelliği standartlaştırmak için şunları yapabilirsiniz:
- conti_features, make_column_transformer içindeki StandardScaler().
- conti_features: sürekli değişkenli liste
- StandardScaler: değişkeni standartlaştırın
make_column_transformer içindeki OneHotEncoder nesnesi etiketi otomatik olarak kodlar.
preprocess = make_column_transformer(
(conti_features, StandardScaler()),
### Need to be numeric not string to specify columns name
(categorical_features, OneHotEncoder(sparse=False))
)
Boru hattının fit_transform ile çalışıp çalışmadığını test edebilirsiniz. Veri kümesi aşağıdaki şekle sahip olmalıdır: 26048, 107
preprocess.fit_transform(X_train).shape
(26048, 107)
Veri transformatörü kullanıma hazırdır. Make_pipeline ile boru hattını oluşturabilirsiniz. Veriler dönüştürüldükten sonra lojistik regresyonu besleyebilirsiniz.
model = make_pipeline(
preprocess,
LogisticRegression())
Bir modeli scikit-learn ile eğitmek önemsizdir. Pipeline'dan önce gelen nesne uyumunu, yani modeli kullanmanız gerekir. Doğruluğu scikit-learn kütüphanesindeki puan nesnesi ile yazdırabilirsiniz.
model.fit(X_train, y_train)
print("logistic regression score: %f" % model.score(X_test, y_test))
logistic regression score: 0.850891
Son olarak, tahmin_proba ile sınıfları tahmin edebilirsiniz. Her sınıf için olasılığı döndürür. Toplamının bire eşit olduğunu unutmayın.
model.predict_proba(X_test)
array([[0.83576663, 0.16423337],
[0.94582765, 0.05417235],
[0.64760587, 0.35239413],
...,
[0.99639252, 0.00360748],
[0.02072181, 0.97927819],
[0.56781353, 0.43218647]])
Adım 4) Izgara aramasında boru hattımızı kullanma
Hiperparametreyi (gizli birimler gibi ağ yapısını belirleyen değişkenler) ayarlamak sıkıcı ve yorucu olabilir.
Modeli değerlendirmenin bir yolu eğitim setinin boyutunu değiştirmek ve performansları değerlendirmek olabilir.
Puan metriklerini görmek için bu yöntemi on kez tekrarlayabilirsiniz. Ancak bu çok fazla iş.
Bunun yerine scikit-learn, parametre ayarlama ve çapraz doğrulamayı gerçekleştirecek bir işlev sağlar.
Çapraz doğrulama
Çapraz Doğrulama, eğitim sırasında eğitim setinin n kez katlanarak kaydırılması ve ardından modelin n kez değerlendirilmesi anlamına gelir. Örneğin CV 10 olarak ayarlanırsa eğitim seti on kez eğitilir ve değerlendirilir. Her turda, sınıflandırıcı modeli eğitmek için rastgele dokuz kat seçer ve 10. kat değerlendirme içindir.
ızgara arama
Her sınıflandırıcının ayarlanması gereken hiperparametreleri vardır. Farklı değerleri deneyebilir veya bir parametre ızgarası ayarlayabilirsiniz. Scikit-learn resmi web sitesine giderseniz, lojistik sınıflandırıcının ayarlanması gereken farklı parametrelere sahip olduğunu görebilirsiniz. Eğitimi daha hızlı hale getirmek için C parametresini ayarlamayı seçersiniz. Düzenlileştirme parametresini kontrol eder. Olumlu olmalı. Küçük bir değer, düzenleyiciye daha fazla ağırlık verir.
GridSearchCV nesnesini kullanabilirsiniz. Ayarlamak için hiperparametreleri içeren bir sözlük oluşturmanız gerekir.
Hiperparametreleri ve ardından denemek istediğiniz değerleri listelersiniz. Örneğin, C parametresini ayarlamak için şunu kullanırsınız:
- 'logisticregression__C': [0.1, 1.0, 1.0]: Parametrenin önünde, küçük harfle, sınıflandırıcının adı ve iki alt çizgi bulunur.
Model dört farklı değeri deneyecektir: 0.001, 0.01, 0.1 ve 1.
Modeli 10 katlama kullanarak eğitiyorsunuz: cv=10
from sklearn.model_selection import GridSearchCV
# Construct the parameter grid
param_grid = {
'logisticregression__C': [0.001, 0.01,0.1, 1.0],
}
GridSearchCV'yi gri ve cv parametreleriyle kullanarak modeli eğitebilirsiniz.
# Train the model
grid_clf = GridSearchCV(model,
param_grid,
cv=10,
iid=False)
grid_clf.fit(X_train, y_train)
ÇIKTI
GridSearchCV(cv=10, error_score='raise-deprecating',
estimator=Pipeline(memory=None,
steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...ty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0, warm_start=False))]),
fit_params=None, iid=False, n_jobs=1,
param_grid={'logisticregression__C': [0.001, 0.01, 0.1, 1.0]},
pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',
scoring=None, verbose=0)
En iyi parametrelere erişmek için best_params_'ı kullanırsınız
grid_clf.best_params_
ÇIKTI
{'logisticregression__C': 1.0}
Model dört farklı düzenleme değeriyle eğitildikten sonra en uygun parametre şu şekildedir:
print("best logistic regression from grid search: %f" % grid_clf.best_estimator_.score(X_test, y_test))
grid aramasından en iyi lojistik regresyon: 0.850891
Tahmin edilen olasılıklara erişmek için:
grid_clf.best_estimator_.predict_proba(X_test)
array([[0.83576677, 0.16423323],
[0.9458291 , 0.0541709 ],
[0.64760416, 0.35239584],
...,
[0.99639224, 0.00360776],
[0.02072033, 0.97927967],
[0.56782222, 0.43217778]])
Scikit-learn ile XGBoost Modeli
Piyasadaki en iyi sınıflandırıcılardan birini eğitmek için Scikit-learn örneklerini deneyelim. XGBoost, rastgele ormana göre bir gelişmedir. Bu kapsamın dışında kalan sınıflandırıcının teorik arka planı Python Scikit öğreticisi. XGBoost'un birçok kaggle yarışmasını kazandığını unutmayın. Ortalama bir veri kümesi boyutuyla derin öğrenme algoritması kadar iyi, hatta daha iyi performans gösterebilir.
Sınıflandırıcının eğitilmesi zordur çünkü ayarlanması gereken çok sayıda parametre vardır. Elbette sizin için parametreyi seçmek için GridSearchCV'yi kullanabilirsiniz.
Bunun yerine, en uygun parametreleri bulmanın daha iyi bir yolunu nasıl kullanabileceğimizi görelim. GridSearchCV'nin çok sayıda değer iletilmesi durumunda eğitilmesi sıkıcı olabilir ve çok uzun sürebilir. Arama alanı parametre sayısıyla birlikte büyür. Tercih edilen bir çözüm RandomizedSearchCV'yi kullanmaktır. Bu yöntem, her yinelemeden sonra her hiperparametrenin değerinin rastgele seçilmesinden oluşur. Örneğin, sınıflandırıcı 1000 yinelemeden fazla eğitilmişse 1000 kombinasyon değerlendirilir. Aşağı yukarı şu şekilde çalışır. Izgara Arama CV'si
Xgboost'u içe aktarmanız gerekiyor. Kitaplık kurulu değilse lütfen pip3 install xgboost'u kullanın veya
use import sys
!{sys.executable} -m pip install xgboost
In Jupyter çevre
Daha sonra,
import xgboost from sklearn.model_selection import RandomizedSearchCV from sklearn.model_selection import StratifiedKFold
Bu Scikit'teki bir sonraki adım Python öğretici, ayarlanacak parametrelerin belirtilmesini içerir. Ayarlanacak tüm parametreleri görmek için resmi belgelere başvurabilirsiniz. uğruna Python Sklearn eğitiminde yalnızca her biri iki değere sahip iki hiper parametre seçersiniz. XGBoost'un eğitilmesi çok zaman alır; ızgarada ne kadar çok hiperparametre varsa, beklemeniz de o kadar uzun sürer.
params = {
'xgbclassifier__gamma': [0.5, 1],
'xgbclassifier__max_depth': [3, 4]
}
XGBoost sınıflandırıcısıyla yeni bir işlem hattı oluşturursunuz. 600 tahminci tanımlamayı seçersiniz. N_estimators'ın ayarlayabileceğiniz bir parametre olduğunu unutmayın. Yüksek bir değer, aşırı uyuma yol açabilir. Farklı değerleri kendiniz deneyebilirsiniz ancak bunun saatler sürebileceğini unutmayın. Diğer parametreler için varsayılan değeri kullanırsınız
model_xgb = make_pipeline(
preprocess,
xgboost.XGBClassifier(
n_estimators=600,
objective='binary:logistic',
silent=True,
nthread=1)
)
Katmanlı K-Folds çapraz doğrulayıcıyla çapraz doğrulamayı iyileştirebilirsiniz. Hesaplamayı hızlandırmak, ancak kaliteyi düşürmek için burada yalnızca üç kat oluşturursunuz. Sonuçları iyileştirmek için bu değeri evde 5 veya 10'a yükseltin.
Modeli dört yineleme üzerinden eğitmeyi seçersiniz.
skf = StratifiedKFold(n_splits=3,
shuffle = True,
random_state = 1001)
random_search = RandomizedSearchCV(model_xgb,
param_distributions=params,
n_iter=4,
scoring='accuracy',
n_jobs=4,
cv=skf.split(X_train, y_train),
verbose=3,
random_state=1001)
Rastgele arama kullanıma hazırdır, modeli eğitebilirsiniz
#grid_xgb = GridSearchCV(model_xgb, params, cv=10, iid=False) random_search.fit(X_train, y_train)
Fitting 3 folds for each of 4 candidates, totalling 12 fits [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8759645283888057, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8729701715996775, total= 1.0min [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8706519235199263, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8735460094437406, total= 1.3min [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8722791661868018, total= 57.7s [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8753886905447426, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8697304768486523, total= 1.3min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8740066797189912, total= 1.4min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8707671043538355, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8729701715996775, total= 1.2min [Parallel(n_jobs=4)]: Done 10 out of 12 | elapsed: 3.6min remaining: 43.5s [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8736611770125533, total= 1.2min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8692697535130154, total= 1.2min
[Parallel(n_jobs=4)]: Done 12 out of 12 | elapsed: 3.6min finished /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/model_selection/_search.py:737: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal. DeprecationWarning)
RandomizedSearchCV(cv=<generator object _BaseKFold.split at 0x1101eb830>,
error_score='raise-deprecating',
estimator=Pipeline(memory=None,
steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=1))]),
fit_params=None, iid='warn', n_iter=4, n_jobs=4,
param_distributions={'xgbclassifier__gamma': [0.5, 1], 'xgbclassifier__max_depth': [3, 4]},
pre_dispatch='2*n_jobs', random_state=1001, refit=True,
return_train_score='warn', scoring='accuracy', verbose=3)
Gördüğünüz gibi XGBoost önceki logisitc regresyondan daha iyi bir puana sahip.
print("Best parameter", random_search.best_params_)
print("best logistic regression from grid search: %f" % random_search.best_estimator_.score(X_test, y_test))
Best parameter {'xgbclassifier__max_depth': 3, 'xgbclassifier__gamma': 0.5}
best logistic regression from grid search: 0.873157
random_search.best_estimator_.predict(X_test)
array(['<=50K', '<=50K', '<=50K', ..., '<=50K', '>50K', '<=50K'], dtype=object)
Scikit-learn'de MLPClassifier ile DNN oluşturun
Son olarak scikit-learn ile derin öğrenme algoritmasını eğitebilirsiniz. Yöntem diğer sınıflandırıcıyla aynıdır. Sınıflandırıcı MLPClassifier'da mevcuttur.
from sklearn.neural_network import MLPClassifier
Aşağıdaki derin öğrenme algoritmasını tanımlayın:
- Adem çözücü
- Relu aktivasyon fonksiyonu
- Alfa = 0.0001
- parti büyüklüğü 150
- Sırasıyla 100 ve 50 nöronlu iki gizli katman
model_dnn = make_pipeline(
preprocess,
MLPClassifier(solver='adam',
alpha=0.0001,
activation='relu',
batch_size=150,
hidden_layer_sizes=(200, 100),
random_state=1))
Modeli geliştirmek için katman sayısını değiştirebilirsiniz
model_dnn.fit(X_train, y_train)
print("DNN regression score: %f" % model_dnn.score(X_test, y_test))
DNN regresyon puanı: 0.821253
LIME: Modelinize Güvenin
Artık iyi bir modele sahip olduğunuza göre, ona güvenebileceğiniz bir araca ihtiyacınız var. Makine öğrenme algoritma, özellikle rastgele orman ve sinir ağı, kara kutu algoritması olarak bilinir. Başka bir deyişle, işe yarıyor ama kimse nedenini bilmiyor.
Üç araştırmacı, bilgisayarın nasıl tahmin yaptığını görmek için harika bir araç geliştirdi. Makalenin adı Sana Neden Güvenmeliyim?
adında bir algoritma geliştirdiler. Yerel Yorumlanabilir Model-Agnostik Açıklamalar (LIME).
Bir örnek alın:
Bazen bir makine öğrenimi tahminine güvenip güvenemeyeceğinizi bilemezsiniz:
Örneğin bir doktor, sırf bilgisayar öyle söyledi diye tanıya güvenemez. Ayrıca modele üretime geçmeden önce güvenip güvenemeyeceğinizi de bilmeniz gerekir.
Herhangi bir sınıflandırıcının sinir ağları, rastgele ormanlar veya herhangi bir çekirdeğe sahip svm'ler gibi inanılmaz derecede karmaşık modellerde bile neden tahmin yaptığını anlayabildiğimizi hayal edin.
Arkasındaki nedenleri anlayabilirsek, bir tahmine güvenmemiz daha kolay hale gelecektir. Doktor örneğinden, eğer model ona hangi semptomların önemli olduğunu ona güveneceğinizi söylerse, modele güvenmemeniz gerektiğini anlamak da daha kolay olur.
Lime, sınıflandırıcının kararlarını hangi özelliklerin etkilediğini size söyleyebilir
Veri Hazırlama
LIME'ı çalıştırmak için değiştirmeniz gereken birkaç şey bunlar piton. Öncelikle terminale kireç takmanız gerekiyor. Pip kurulum kireçini kullanabilirsiniz
Lime, modele yerel olarak yaklaşmak için LimeTabularExplainer nesnesini kullanır. Bu nesne şunları gerektirir:
- numpy formatında bir veri kümesi
- Özelliklerin adı: feature_names
- Sınıfların adı: class_names
- Kategorik özellikler sütununun dizini: categorical_features
- Her kategorik özellik için grubun adı: kategorik_isimler
Numpy tren seti oluştur
Df_train'i pandalardan kopyalayıp dönüştürebilirsiniz. dizi çok kolayca
df_train.head(5) # Create numpy data df_lime = df_train df_lime.head(3)
Sınıf adını alın Etikete benzersiz() nesnesi ile erişilebilir. Görmelisin:
- "<=50K"
- '>50K'
# Get the class name class_names = df_lime.label.unique() class_names
array(['<=50K', '>50K'], dtype=object)
kategorik özellikler sütununun dizini
Grubun adını almak için daha önce eğildiğiniz yöntemi kullanabilirsiniz. Etiketi LabelEncoder ile kodlarsınız. İşlemi tüm kategorik özelliklerde tekrarlarsınız.
##
import sklearn.preprocessing as preprocessing
categorical_names = {}
for feature in CATE_FEATURES:
le = preprocessing.LabelEncoder()
le.fit(df_lime[feature])
df_lime[feature] = le.transform(df_lime[feature])
categorical_names[feature] = le.classes_
print(categorical_names)
{'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private',
'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'],
dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th',
'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad',
'Masters', 'Preschool', 'Prof-school', 'Some-college'],
dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'],
dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair',
'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners',
'Machine-op-inspct', 'Other-service', 'Priv-house-serv',
'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support',
'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child',
'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other',
'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba',
'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England',
'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras',
'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica',
'Japan', 'Laos', 'Mexico', 'Nicaragua',
'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan',
'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam',
'Yugoslavia'], dtype=object)}
df_lime.dtypes
age float64 workclass int64 fnlwgt float64 education int64 education_num float64 marital int64 occupation int64 relationship int64 race int64 sex int64 capital_gain float64 capital_loss float64 hours_week float64 native_country int64 label object dtype: object
Artık veri seti hazır olduğuna göre aşağıdaki Scikit öğrenme örneklerinde gösterildiği gibi farklı veri setini oluşturabilirsiniz. LIME ile ilgili hataları önlemek için aslında verileri işlem hattının dışında dönüştürürsünüz. LimeTabularExplainer'daki eğitim seti dizesiz bir numpy dizisi olmalıdır. Yukarıdaki yöntemle zaten dönüştürülmüş bir eğitim veri kümeniz olur.
from sklearn.model_selection import train_test_split
X_train_lime, X_test_lime, y_train_lime, y_test_lime = train_test_split(df_lime[features],
df_lime.label,
test_size = 0.2,
random_state=0)
X_train_lime.head(5)
Boru hattını XGBoost'tan en uygun parametrelerle yapabilirsiniz
model_xgb = make_pipeline(
preprocess,
xgboost.XGBClassifier(max_depth = 3,
gamma = 0.5,
n_estimators=600,
objective='binary:logistic',
silent=True,
nthread=1))
model_xgb.fit(X_train_lime, y_train_lime)
/Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/preprocessing/_encoders.py:351: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values. If you want the future behavior and silence this warning, you can specify "categories='auto'."In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly. warnings.warn(msg, FutureWarning)
Pipeline(memory=None,
steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=1))])
Bir uyarı alırsınız. Uyarı, boru hattından önce bir etiket kodlayıcısı oluşturmanıza gerek olmadığını açıklar. LIME kullanmak istemiyorsanız, Scikit-learn ile Makine Öğrenmesi öğreticisinin ilk bölümündeki yöntemi kullanabilirsiniz. Aksi takdirde, bu yöntemle devam edebilirsiniz, önce kodlanmış bir veri kümesi oluşturun, boru hattı içinde sıcak olanı kodlayıcıyı ayarlayın.
print("best logistic regression from grid search: %f" % model_xgb.score(X_test_lime, y_test_lime))
best logistic regression from grid search: 0.873157
model_xgb.predict_proba(X_test_lime)
array([[7.9646105e-01, 2.0353897e-01],
[9.5173013e-01, 4.8269872e-02],
[7.9344827e-01, 2.0655173e-01],
...,
[9.9031430e-01, 9.6856682e-03],
[6.4581633e-04, 9.9935418e-01],
[9.7104281e-01, 2.8957171e-02]], dtype=float32)
LIME'ı eylemde kullanmadan önce, yanlış sınıflandırmanın özelliklerine sahip bir numpy dizisi oluşturalım. Sınıflandırıcıyı neyin yanlış yönlendirdiğine dair bir fikir edinmek için bu listeyi daha sonra kullanabilirsiniz.
temp = pd.concat([X_test_lime, y_test_lime], axis= 1)
temp['predicted'] = model_xgb.predict(X_test_lime)
temp['wrong']= temp['label'] != temp['predicted']
temp = temp.query('wrong==True').drop('wrong', axis=1)
temp= temp.sort_values(by=['label'])
temp.shape
(826, 16)
Tahmini yeni verilerle modelden almak için bir lambda işlevi yaratırsınız. Yakında ihtiyacınız olacak.
predict_fn = lambda x: model_xgb.predict_proba(x).astype(float) X_test_lime.dtypes
age float64 workclass int64 fnlwgt float64 education int64 education_num float64 marital int64 occupation int64 relationship int64 race int64 sex int64 capital_gain float64 capital_loss float64 hours_week float64 native_country int64 dtype: object
predict_fn(X_test_lime)
array([[7.96461046e-01, 2.03538969e-01],
[9.51730132e-01, 4.82698716e-02],
[7.93448269e-01, 2.06551731e-01],
...,
[9.90314305e-01, 9.68566816e-03],
[6.45816326e-04, 9.99354184e-01],
[9.71042812e-01, 2.89571714e-02]])
Pandaların veri çerçevesini numpy dizisine dönüştürürsünüz
X_train_lime = X_train_lime.values X_test_lime = X_test_lime.values X_test_lime
array([[4.00000e+01, 5.00000e+00, 1.93524e+05, ..., 0.00000e+00,
4.00000e+01, 3.80000e+01],
[2.70000e+01, 4.00000e+00, 2.16481e+05, ..., 0.00000e+00,
4.00000e+01, 3.80000e+01],
[2.50000e+01, 4.00000e+00, 2.56263e+05, ..., 0.00000e+00,
4.00000e+01, 3.80000e+01],
...,
[2.80000e+01, 6.00000e+00, 2.11032e+05, ..., 0.00000e+00,
4.00000e+01, 2.50000e+01],
[4.40000e+01, 4.00000e+00, 1.67005e+05, ..., 0.00000e+00,
6.00000e+01, 3.80000e+01],
[5.30000e+01, 4.00000e+00, 2.57940e+05, ..., 0.00000e+00,
4.00000e+01, 3.80000e+01]])
model_xgb.predict_proba(X_test_lime)
array([[7.9646105e-01, 2.0353897e-01],
[9.5173013e-01, 4.8269872e-02],
[7.9344827e-01, 2.0655173e-01],
...,
[9.9031430e-01, 9.6856682e-03],
[6.4581633e-04, 9.9935418e-01],
[9.7104281e-01, 2.8957171e-02]], dtype=float32)
print(features,
class_names,
categorical_features,
categorical_names)
['age', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country'] ['<=50K' '>50K'] [1, 3, 5, 6, 7, 8, 9, 13] {'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private',
'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'],
dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th',
'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad',
'Masters', 'Preschool', 'Prof-school', 'Some-college'],
dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'],
dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair',
'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners',
'Machine-op-inspct', 'Other-service', 'Priv-house-serv',
'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support',
'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child',
'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other',
'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba',
'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England',
'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras',
'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica',
'Japan', 'Laos', 'Mexico', 'Nicaragua',
'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan',
'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam',
'Yugoslavia'], dtype=object)}
import lime
import lime.lime_tabular
### Train should be label encoded not one hot encoded
explainer = lime.lime_tabular.LimeTabularExplainer(X_train_lime ,
feature_names = features,
class_names=class_names,
categorical_features=categorical_features,
categorical_names=categorical_names,
kernel_width=3)
Test setinden rastgele bir hane seçelim ve model tahminini ve bilgisayarın seçimini nasıl yaptığını görelim.
import numpy as np np.random.seed(1) i = 100 print(y_test_lime.iloc[i]) >50K
X_test_lime[i]
array([4.20000e+01, 4.00000e+00, 1.76286e+05, 7.00000e+00, 1.20000e+01,
2.00000e+00, 4.00000e+00, 0.00000e+00, 4.00000e+00, 1.00000e+00,
0.00000e+00, 0.00000e+00, 4.00000e+01, 3.80000e+01])
Modelin arkasındaki açıklamayı kontrol etmek için açıklayıcıyı açıklayıcı_instance ile kullanabilirsiniz.
exp = explainer.explain_instance(X_test_lime[i], predict_fn, num_features=6) exp.show_in_notebook(show_all=False)
Sınıflandırıcının hane halkını doğru tahmin ettiğini görebiliriz. Gelir gerçekten 50 binin üzerinde.
Söyleyebileceğimiz ilk şey, sınıflandırıcının tahmin edilen olasılıklardan pek emin olmadığıdır. Makine, hane halkının %50 olasılıkla 64 binin üzerinde gelire sahip olduğunu tahmin ediyor. Bu %64 sermaye kazancı ve evlilikten oluşuyor. Mavi renk pozitif sınıfa olumsuz, turuncu çizgi ise olumlu katkı sağlar.
Sınıflandırıcının kafası karışık çünkü bu hane halkının sermaye kazancı sıfır, sermaye kazancı ise genellikle zenginliğin iyi bir göstergesi. Ayrıca hane haftada 40 saatten az çalışmaktadır. Yaş, meslek ve cinsiyet sınıflandırıcıya olumlu katkıda bulunur.
Medeni durum bekar olsaydı, sınıflandırıcı 50 binin altında bir gelir öngörürdü (0.64-0.18 = 0.46)
Yanlış sınıflandırılmış başka bir evle deneyebiliriz
temp.head(3) temp.iloc[1,:-2]
age 58 workclass 4 fnlwgt 68624 education 11 education_num 9 marital 2 occupation 4 relationship 0 race 4 sex 1 capital_gain 0 capital_loss 0 hours_week 45 native_country 38 Name: 20931, dtype: object
i = 1
print('This observation is', temp.iloc[i,-2:])
This observation is label <=50K predicted >50K Name: 20931, dtype: object
exp = explainer.explain_instance(temp.iloc[1,:-2], predict_fn, num_features=6) exp.show_in_notebook(show_all=False)
Sınıflandırıcı, doğru olmasa da 50 binin altında bir gelir öngördü. Bu ev tuhaf görünüyor. Sermaye kazancı da yok, sermaye kaybı da yok. Kendisi boşanmış, 60 yaşında ve eğitimli bir kişi, yani eğitim_numu > 12. Genel örneğe göre, bu hanenin, sınıflandırıcının da açıkladığı gibi, 50 binin altında bir gelir elde etmesi gerekiyor.
LIME ile oynamaya çalışıyorsun. Sınıflandırıcıdaki büyük hataları fark edeceksiniz.
Kütüphane sahibinin GitHub'unu kontrol edebilirsiniz. Görüntü ve metin sınıflandırması için ekstra belgeler sağlarlar.
ÖZET
Aşağıda scikit Learn sürümü >=0.20 olan bazı yararlı komutların listesi bulunmaktadır.
| eğitim/test veri kümesi oluştur | stajyerler ayrıldı |
| Bir boru hattı oluşturun | |
| sütunu seçin ve dönüşümü uygulayın | makecolumntransformer |
| dönüşüm türü | |
| standartlaştırmak | Standart Ölçekleyici |
| en az en çok | MinMaksÖlçekleyici |
| Normale | Normalleştirici |
| Eksik değeri yükle | atfetmek |
| Kategorik dönüştür | OneHotKodlayıcı |
| Verileri sığdırın ve dönüştürün | uyum_dönüşümü |
| Boru hattını yapın | make_pipeline |
| Temel model | |
| lojistik regresyon | Lojistik regresyon |
| XGBoost | XGBSınıflandırıcı |
| Sinir ağı | MLP Sınıflandırıcı |
| ızgara arama | IzgaraAramaCV |
| Rastgele arama | Rastgele AramaCV |
