Makine Öğrenmesi (Sınıflandırma Modelleri)
Makine öğrenmesi nedir?
Girdi verilerinden tahmini bir model oluşturan (eğiten) bir program veya sistem. Sistem öğrenilen modeli, modeli eğitmek için kullanılanla aynı dağıtımdan alınan yeni (daha önce hiç görülmemiş) verilerden yararlı tahminler yapmak için kullanır. Makine öğrenimi ayrıca bu programlar veya sistemlerle ilgili çalışma alanını da ifade eder.
Makine öğrenmesini öğrenme türüne göre üçe ayırabiliriz.
- Gözetimli Öğrenme (Supervised Mahine Learning)
Bir modelin giriş verilerinden ve ilgili etiketlerinden eğitimi. Denetimli makine öğrenimi, bir dizi soruyu ve karşılık gelen cevaplarını inceleyerek bir konuyu öğrenen bir öğrenciye benzer. Sorular ve cevaplar arasındaki haritalamada ustalaştıktan sonra, öğrenci aynı konuda yeni (daha önce hiç görülmemiş) sorulara cevap verebilir. Denetimsiz makine öğrenimi ile karşılaştırın.
- Gözetimsiz Öğrenme (Unsupervised Machine Learning)
Bir veri kümesinde, genellikle etiketlenmemiş bir veri kümesinde desen bulmak için bir modelin eğitilmesi.
- Pekiştirmeli Öğrenme (Reinforcement Learning)
Amacı, bir çevre ile etkileşime girerken getiriyi en üst düzeye çıkarmak olan optimal bir politika öğrenen algoritmalar ailesi.
Bu yazıda gözetimli öğrenme türlerinden olan sınıflandırma modellerini inceleyeceğiz.
Sınıflandırma Modelleri (Classification Models)
Gözetimli öğrenme türlerinden olan sınıflandırma, veri setinde bulunan bağımlı değişkenin sınıflardan(kategorik değişkenlerden) oluştuğu durumlarda kullanılan modelleme türüdür.(Örneğin; kadın/erkek, ödeyebilir/ödeyemez…)
İnceleyeceğimiz Algoritmalar
- Logistik Regresyon (Logistic Regression)
- K-En Yakın Komşu (K-Nearest Neighbors)
- Destek Vektör Makineleri (Support Vector Machines)
- Yapay Sinir Ağları (Artificial Nerual Network)
- CART (Classification and Regression Tree)
- Rastgele Ormanlar (Random Forests)
- Gradient Boosting Machine (GBM)
- XGBoost
- Light GBM
- CatBoost
Veri Seti ve Problem: Şeker Hastalığı Tahmini
Uygulama kısmında kullanacağımız veri setinin yüklenmesi.
In [1]:
import numpy as np
import pandas as pd
import statsmodels.api as sm
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import scale, StandardScaler
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.metrics import confusion_matrix, accuracy_score, mean_squared_error, r2_score, roc_auc_score, roc_curve, classification_report
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=FutureWarning)In [2]:
df = pd.read_csv('diabetes.csv')In [3]:
df.head()Out[3]:
In [4]:
df['Outcome'].value_counts()Out[4]:
0 500
1 268
Name: Outcome, dtype: int64In [5]:
df.describe().TOut[5]:
- Veri setini Train/Test Olarak Ayırma
In [6]:
y = df['Outcome']
X = df.drop(['Outcome'], axis=1)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)
Lojistik Regresyon(Logistic Regression)
Doğrusal bir modelin ham tahminini (y ′) 0 ile 1 arasında bir değere dönüştürmek için sigmoid işlevini kullanan bir sınıflandırma modelidir.
0 ile 1 arasındaki değeri aşağıdaki iki yoldan biriyle yorumlayabilirsiniz:
- Olası bir örnek olarak, ikili sınıflama probleminde pozitif sınıfa aittir.
- Bir sınıflandırma eşiğine göre karşılaştırılacak bir değer olarak. Değer, sınıflandırma eşiğine eşit veya bu değerin üzerindeyse, sistem örneği pozitif sınıf olarak sınıflandırır. Tersine, değer verilen eşiğin altındaysa, sistem örneği negatif sınıf olarak sınıflandırır.
Lojistik regresyon sıklıkla ikili sınıflandırma problemlerinde kullanılmasına rağmen, lojistik regresyon çok sınıflı sınıflandırma problemlerinde de kullanılabilir (burada çok sınıflı lojistik regresyon veya çok terimli regresyon olarak adlandırılır).
- Bağımlı değişken(y) kategoriktir.
- Adını bağımlı değişkene uygulanan logit dönüşümden alır.
- Bağımlı değişkenin 1 olarak tanımlanan değerinin gerçekleşme olasılığı hesaplanır. Dolayısıyla bağımlı değişkenin alacağı değer ile ilgilenilmez.
- Lojistik fonksiyon 0–1 arasında değerler üretir.
Lojistik Fonksiyon
Lojistik işlevi, herhangi bir gerçek girişi alan sigmoid bir işlevdir. Standart lojistik fonksiyon aşağıdaki gibi tanımlanır:
- y’ belirli bir örnek için lojistik regresyon modelinin çıktısıdır.
- z = b + w1 x1 + w2 x2 + … + wn xn
- w: modelin öğrenilen ağırlıkları(weights)
- b: bias
- x değerleri belirli bir örnek için özellik(feature) değerleridir.
Z ayrıca log-odds olarak da adlandırılır, çünkü sigmoid’in tersi, z’nin “1” etiketinin olasılığının günlüğü olarak “0” etiketinin olasılığına bölünmesiyle elde edilebilir:
Olasılık çıktısı:
- Model ve Tahmin
In [7]:
from sklearn.linear_model import LogisticRegressionIn [8]:
log_model = LogisticRegression(solver='liblinear').fit(X_train,y_train)In [9]:
# Sabit değeri verir. (bias)
log_model.intercept_Out[9]:
array([-5.76530081])In [10]:
# Ağırlık değerlerini verir. (weights)
log_model.coef_Out[10]:
array([[ 0.06122255, 0.02614805, -0.01666377, -0.00221258, -0.00028105,
0.06410685, 0.26148105, 0.02206304]])In [11]:
y_pred = log_model.predict(X_test)- Model değerlendirmesi
In [12]:
accuracy_score(y_test, y_pred)Out[12]:
0.7575757575757576In [13]:
cross_val_score(log_model, X_test, y_test, cv=21).mean()Out[13]:
0.7705627705627704In [14]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.80 0.83 0.82 151
1 0.66 0.61 0.64 80 accuracy 0.76 231
macro avg 0.73 0.72 0.73 231
weighted avg 0.75 0.76 0.76 231
In [15]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [16]:
logit_roc_auc = roc_auc_score(y_test, log_model.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, log_model.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % logit_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
K-En Yakın Komşu(K-Nearest Neighbors)
Sınıflandırmada kullanılan bu algoritmaya göre sınıflandırma sırasında çıkarılan özelliklerden, sınıflandırılmak istenen yeni bireyin daha önceki bireylerden k tanesine yakınlığına bakılmasıdır.
- Model ve Tahmin
In [17]:
from sklearn.neighbors import KNeighborsClassifierIn [18]:
knn = KNeighborsClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [19]:
knn_params = {"n_neighbors": np.arange(1,50)}In [20]:
knn_cv_model = GridSearchCV(knn, knn_params, cv=10).fit(X_train, y_train)In [21]:
knn_cv_model.best_params_Out[21]:
{'n_neighbors': 11}In [22]:
knn_cv_model.best_score_Out[22]:
0.748637316561845In [23]:
knn = KNeighborsClassifier(n_neighbors=11).fit(X_train, y_train)In [24]:
y_pred = knn.predict(X_test)- Model değerlendirmesi
In [25]:
accuracy_score(y_test, y_pred)Out[25]:
0.7316017316017316In [26]:
cross_val_score(knn, X_test, y_test, cv=21).mean()Out[26]:
0.6969696969696969In [27]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.78 0.81 0.80 151
1 0.62 0.57 0.60 80 accuracy 0.73 231
macro avg 0.70 0.69 0.70 231
weighted avg 0.73 0.73 0.73 231
In [28]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [29]:
knn_roc_auc = roc_auc_score(y_test, knn.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, knn.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % knn_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Destek Vektör Makineleri(Support Vector Machines)
Amaç iki sınıf arasındaki ayrımın optimum olmasını sağlayacak hiper-düzlemi bulmaktır.
xi ile temsil edilen her girdi, D özelliğine sahip olsun ve sadece yi = -1 ya da +1 sınıflarından birine ait olsun, bu durumda tüm girdileri şöyle gösterebiliriz:
- Model ve Tahmin
In [30]:
from sklearn.svm import SVCIn [31]:
svm = SVC()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [32]:
svm_params = {"C": np.arange(1,10), "kernel":["linear", "rbf"]}In [33]:
svm_cv_model = GridSearchCV(svm, svm_params, cv=5, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 5 folds for each of 18 candidates, totalling 90 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 33 tasks | elapsed: 40.0s
[Parallel(n_jobs=-1)]: Done 90 out of 90 | elapsed: 3.5min finished
In [34]:
svm_cv_model.best_score_Out[34]:
0.7839044652128765In [35]:
svm_cv_model.best_params_Out[35]:
{'C': 2, 'kernel': 'linear'}In [36]:
svm = SVC(C = 2, kernel='linear', probability=True).fit(X_train, y_train)In [37]:
y_pred = svm.predict(X_test)- Model değerlendirmesi
In [38]:
accuracy_score(y_test, y_pred)Out[38]:
0.7445887445887446In [39]:
cross_val_score(svm, X_test, y_test, cv=21).mean()Out[39]:
0.7575757575757576In [40]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.80 0.81 0.81 151
1 0.63 0.62 0.63 80 accuracy 0.74 231
macro avg 0.72 0.72 0.72 231
weighted avg 0.74 0.74 0.74 231
In [41]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [42]:
svm_roc_auc = roc_auc_score(y_test, svm.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, svm.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % svm_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Yapay Sinir Ağları(Artificial Nerual Network)
Sinir Ağı(Neural Network): Beyinden ilham alan bir model, basit bağlı birimlerden veya nöronlardan ve ardından doğrusal olmayan(en az biri gizli) katmanlardan oluşur. Amaç en küçük hata ile tahmin yapabilecek katsayılara erişmektir.
Yapay Sinir Hücresi(Neuron): Bir sinir ağında, tipik olarak çoklu giriş değerleri alan ve bir çıkış değeri üreten bir düğüm. Nöron, ağırlıklı bir girdi değerleri toplamına bir aktivasyon fonksiyonu (doğrusal olmayan dönüşüm) uygulayarak çıktı değerini hesaplar.
Aktivasyon Fonksiyonu: Bir önceki katmandaki tüm girdilerin ağırlıklı toplamını alan ve daha sonra bir çıkış değeri (tipik olarak doğrusal olmayan) üreten ve bir sonraki katmana geçiren bir işlev (örneğin, ReLU veya sigmoid).
Yapay sinir ağları birçok yapay sinir hücresinden oluşur.
Gizli Katman: Giriş katmanı (yani özellikler) ve çıkış katmanı (tahmin) arasındaki sinir ağı içindeki sentetik katman. Gizli katmanlar genellikle eğitim için bir aktivasyon fonksiyonu (ReLU gibi) içerir. Derin bir sinir ağı birden fazla gizli katman içerir.
- Model ve Tahmin
In [43]:
from sklearn.neural_network import MLPClassifierYapay sinir ağlarının daha doğru sonuç vermesi için veri setini ölçekleme işleminden geçiriyoruz.
In [44]:
scaler = StandardScaler()In [45]:
scaler.fit(X_train)
X_train_scaler = scaler.transform(X_train)scaler.fit(X_test)
X_test_scaler = scaler.transform(X_test)
In [46]:
mlpc = MLPClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [47]:
mlpc_params = {'alpha':[1, 5, 0.1, 0.01, 0.03, 0.005, 0.0001 ],
'hidden_layer_sizes': [(10,10), (100,100,100), (100,100), (3,5)]}In [48]:
mlpc = MLPClassifier(solver='lbfgs', activation='logistic')In [49]:
mlpc_cv_model = GridSearchCV(mlpc, mlpc_params, cv=10, n_jobs=-1, verbose=2).fit(X_train_scaler, y_train)Fitting 10 folds for each of 28 candidates, totalling 280 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 48 tasks | elapsed: 6.2s
[Parallel(n_jobs=-1)]: Done 170 tasks | elapsed: 39.1s
[Parallel(n_jobs=-1)]: Done 280 out of 280 | elapsed: 1.3min finished
In [50]:
mlpc_cv_modelOut[50]:
GridSearchCV(cv=10, error_score=nan,
estimator=MLPClassifier(activation='logistic', alpha=0.0001,
batch_size='auto', beta_1=0.9,
beta_2=0.999, early_stopping=False,
epsilon=1e-08, hidden_layer_sizes=(100,),
learning_rate='constant',
learning_rate_init=0.001, max_fun=15000,
max_iter=200, momentum=0.9,
n_iter_no_change=10,
nesterovs_momentum=True, power_t=0.5,
random_state=None, shuffle=True,
solver='lbfgs', tol=0.0001,
validation_fraction=0.1, verbose=False,
warm_start=False),
iid='deprecated', n_jobs=-1,
param_grid={'alpha': [1, 5, 0.1, 0.01, 0.03, 0.005, 0.0001],
'hidden_layer_sizes': [(10, 10), (100, 100, 100),
(100, 100), (3, 5)]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [51]:
mlpc_cv_model.best_params_Out[51]:
{'alpha': 1, 'hidden_layer_sizes': (3, 5)}In [52]:
mlpc = MLPClassifier(solver = 'lbfgs', alpha=1 , hidden_layer_sizes=(3,5), activation='logistic').fit(X_train_scaler, y_train)In [53]:
y_pred = mlpc.predict(X_test_scaler)- Model değerlendirmesi
In [54]:
accuracy_score(y_test, y_pred)Out[54]:
0.7575757575757576In [55]:
cross_val_score(mlpc, X_test_scaler, y_test, cv=21).mean()Out[55]:
0.7619047619047619In [56]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.80 0.84 0.82 151
1 0.67 0.60 0.63 80 accuracy 0.76 231
macro avg 0.73 0.72 0.73 231
weighted avg 0.75 0.76 0.75 231
In [57]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [58]:
mlpc_roc_auc = roc_auc_score(y_test, mlpc.predict(X_test_scaler))
fpr , tpr, thresholds = roc_curve(y_test, mlpc.predict_proba(X_test_scaler)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % mlpc_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
CART (Classification and Regression Tree)
Amaç veri setleri içerisindeki karmaşık yapıları basit karar yapılarına dönüşmektürmektir. Heterojen veri setleri belirlenmiş bir hedef değişkene göre homojen alt gruplara ayrılır.
- Model ve Tahmin
In [59]:
from sklearn.tree import DecisionTreeClassifierIn [60]:
cart = DecisionTreeClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [61]:
cart_params = {'max_depth': [1,3,5,8,10],
'min_samples_split': [2,3,5,10,20,50]}In [62]:
cart_cv_model = GridSearchCV(cart, cart_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 10 folds for each of 30 candidates, totalling 300 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 136 tasks | elapsed: 0.4s
[Parallel(n_jobs=-1)]: Done 300 out of 300 | elapsed: 0.7s finished
In [63]:
cart_cv_modelOut[63]:
GridSearchCV(cv=10, error_score=nan,
estimator=DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None,
criterion='gini', max_depth=None,
max_features=None,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
presort='deprecated',
random_state=None,
splitter='best'),
iid='deprecated', n_jobs=-1,
param_grid={'max_depth': [1, 3, 5, 8, 10],
'min_samples_split': [2, 3, 5, 10, 20, 50]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [64]:
cart_cv_model.best_params_Out[64]:
{'max_depth': 5, 'min_samples_split': 20}In [65]:
cart = DecisionTreeClassifier(max_depth=5, min_samples_split=20).fit(X_train, y_train)In [66]:
y_pred = cart.predict(X_test)- Model değerlendirmesi
In [67]:
accuracy_score(y_test, y_pred)Out[67]:
0.7532467532467533In [68]:
cross_val_score(cart, X_test, y_test, cv=21).mean()Out[68]:
0.7142857142857142In [69]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.79 0.85 0.82 151
1 0.67 0.57 0.62 80 accuracy 0.75 231
macro avg 0.73 0.71 0.72 231
weighted avg 0.75 0.75 0.75 231
In [70]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [71]:
cart_roc_auc = roc_auc_score(y_test, cart.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, cart.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % cart_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Random Forests
Temeli birden çok karar ağacının ürettiği tahminlerin bir araya getirilerek değerlendirilmesine dayanır.
- Random Forests Bagging(Breiman, 1996) ile Random Subspace(Ho, 1998) yöntemlerinin birleşimi ile oluşmuştur.
Bagging(Bootstrap Aggregating): Temeli bootstrap yöntemi ile oluşan birden fazla karar ağacının ürettiği tahminleri bir araya getirilerek değerlendirilmesine dayanır. Baggiing yöntemi Random Forests algoritmasının özel bir halidir. Not: Bootstrap Yöntemi, istatistik alanında sıklıkla kullanılan yöntemlerin başında gelmektedir. Bootstrap yöntemleri ya da algoritmalarındaki asıl amaç veriden, büyük veri setleri oluşturmak (üretmek) ve yeniden örnekleme yapmaktır.
Random Subspace: Makine öğreniminde rasgele altuzay yöntemi, bir kümedeki tahmin ediciler arasındaki korelasyonu, özellik kümesi yerine rastgele özellik örnekleri üzerinde eğiterek azaltmaya çalışan bir topluluk öğrenme yöntemidir.
- Ağaçlar için gözlemler bootstrap rastgele örnek seçim yöntemi ile değişkenler random subspace yöntemi ile seçilir.
- Karar ağacının her bir düğümünde en iyi dallara ayırıcı değişiken tüm değişkenler arasından rastgele seçilen daha az sayıdaki değişken arasından seçilir.
- Ağaç oluşturmada veri setinin 2/3'ü kulllanılır. Dışarda kalan veri ağaçların performans değerlendirmesi ve değişken öneminin belirlenmesi için kullanılır.
- Her düğüm noktasında rastgele değişken seçimi yapılır.(sınıflandırma için √p)
- Nihai tahmin için ağaçlardan tahmin değeri talep edilirken her bir ağacın daha önceden hesaplanan hata oranları göz önüne alınarak ağırlık verilir.
- Model ve Tahmin
In [72]:
from sklearn.ensemble import RandomForestClassifierIn [73]:
rf = RandomForestClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [74]:
rf_params = {'n_estimators': [100,200,500,1000],
'max_features': [3,5,7,8],
'min_samples_split':[2,5,10,20]}In [75]:
rf_cv_model = GridSearchCV(rf, rf_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 10 folds for each of 64 candidates, totalling 640 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 33 tasks | elapsed: 7.7s
[Parallel(n_jobs=-1)]: Done 154 tasks | elapsed: 41.1s
[Parallel(n_jobs=-1)]: Done 357 tasks | elapsed: 1.9min
[Parallel(n_jobs=-1)]: Done 640 out of 640 | elapsed: 3.7min finished
In [76]:
rf_cv_modelOut[76]:
GridSearchCV(cv=10, error_score=nan,
estimator=RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,
class_weight=None,
criterion='gini', max_depth=None,
max_features='auto',
max_leaf_nodes=None,
max_samples=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
n_estimators=100, n_jobs=None,
oob_score=False,
random_state=None, verbose=0,
warm_start=False),
iid='deprecated', n_jobs=-1,
param_grid={'max_features': [3, 5, 7, 8],
'min_samples_split': [2, 5, 10, 20],
'n_estimators': [100, 200, 500, 1000]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [77]:
rf_cv_model.best_params_Out[77]:
{'max_features': 5, 'min_samples_split': 10, 'n_estimators': 200}In [78]:
rf = RandomForestClassifier(max_features=5, min_samples_split=10, n_estimators=200).fit(X_train, y_train)In [79]:
y_pred = rf.predict(X_test)- Model değerlendirmesi
In [80]:
accuracy_score(y_test, y_pred)Out[80]:
0.7489177489177489In [81]:
rf.feature_importances_Out[81]:
array([0.04903578, 0.3746075 , 0.06364284, 0.04734653, 0.04861266,
0.17647005, 0.09434074, 0.1459439 ])In [82]:
feature_imp = pd.Series(rf.feature_importances_,
index=X_train.columns).sort_values(ascending=False)sns.barplot(x=feature_imp, y=feature_imp.index)
plt.xlabel('Değisken Önem Skorları')
plt.ylabel('Değişkenler')
plt.title('Değişken Önem Düzeyleri')
plt.show()
In [83]:
cross_val_score(rf, X_test, y_test, cv=21).mean()Out[83]:
0.7489177489177488In [84]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.82 0.79 0.80 151
1 0.63 0.68 0.65 80 accuracy 0.75 231
macro avg 0.72 0.73 0.73 231
weighted avg 0.75 0.75 0.75 231
In [85]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [86]:
rf_roc_auc = roc_auc_score(y_test, rf.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, rf.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % rf_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Gradient Boosting Machine(GBM)
Gradient boosting: Regresyon ve sınıflandırma problemleri için, genellikle karar ağaçları olan zayıf tahmin modelleri topluluğu şeklinde bir tahmin modeli üreten bir makine öğrenme tekniğidir. Modeli, diğer arttırıcı yöntemlerin yaptığı gibi aşamalı bir şekilde inşa eder ve keyfi farklılaşabilir bir kayıp fonksiyonunun optimizasyonuna izin vererek onları genelleştirir.
- Gradint boosting tek bir tahminsel model formunda olan modeller serisi oluşturur.
- Seri içerisindeki bir model serideki bir önceki modelin tahmin artıklarının/hatalarının üzerine kurularak(fit) oluşturulur.
- GBM diferansiyellenebilen herhangi bir kayıp fonksiyonunu optimize edebilen Gradient Descent algoritmasını kullanır.
- GBM bir çok temel öğrenici tipi(base learner type) kullanabilir.(Trees, linear terms, splines,…)
- Cost fonksiyonları ve link fonksiyonlarını modifiye edebilir.
- GBM = Boosting + Gradient Descent
- Model ve Tahmin
In [87]:
from sklearn.ensemble import GradientBoostingClassifierIn [88]:
gbm = GradientBoostingClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [89]:
gbm_params = {'learning_rate': [0.1, 0.01, 0.001, 0.05],
'n_estimators': [100,200,500,1000],
'max_depth':[2,3,5,8]}In [90]:
gbm_cv_model = GridSearchCV(gbm, gbm_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 10 folds for each of 64 candidates, totalling 640 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 56 tasks | elapsed: 5.8s
[Parallel(n_jobs=-1)]: Done 178 tasks | elapsed: 31.9s
[Parallel(n_jobs=-1)]: Done 381 tasks | elapsed: 1.6min
[Parallel(n_jobs=-1)]: Done 640 out of 640 | elapsed: 3.1min finished
In [91]:
gbm_cv_modelOut[91]:
GridSearchCV(cv=10, error_score=nan,
estimator=GradientBoostingClassifier(ccp_alpha=0.0,
criterion='friedman_mse',
init=None, learning_rate=0.1,
loss='deviance', max_depth=3,
max_features=None,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
n_estimators=100,
n_iter_no_change=None,
presort='deprecated',
random_state=None,
subsample=1.0, tol=0.0001,
validation_fraction=0.1,
verbose=0, warm_start=False),
iid='deprecated', n_jobs=-1,
param_grid={'learning_rate': [0.1, 0.01, 0.001, 0.05],
'max_depth': [2, 3, 5, 8],
'n_estimators': [100, 200, 500, 1000]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [92]:
gbm_cv_model.best_params_Out[92]:
{'learning_rate': 0.01, 'max_depth': 3, 'n_estimators': 500}In [93]:
gbm = GradientBoostingClassifier(learning_rate=0.01, max_depth=3, n_estimators=500).fit(X_train, y_train)In [94]:
y_pred = gbm.predict(X_test)- Model değerlendirmesi
In [95]:
accuracy_score(y_test, y_pred)Out[95]:
0.7402597402597403In [96]:
gbm.feature_importances_Out[96]:
array([0.02998707, 0.48216892, 0.01540671, 0.0103302 , 0.03647966,
0.19003181, 0.0767484 , 0.15884723])In [97]:
feature_imp = pd.Series(gbm.feature_importances_,
index=X_train.columns).sort_values(ascending=False)sns.barplot(x=feature_imp, y=feature_imp.index)
plt.xlabel('Değisken Önem Skorları')
plt.ylabel('Değişkenler')
plt.title('Değişken Önem Düzeyleri')
plt.show()
In [98]:
cross_val_score(gbm, X_test, y_test, cv=21).mean()Out[98]:
0.7056277056277056In [99]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.81 0.79 0.80 151
1 0.62 0.65 0.63 80 accuracy 0.74 231
macro avg 0.71 0.72 0.72 231
weighted avg 0.74 0.74 0.74 231
In [100]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [101]:
gbm_roc_auc = roc_auc_score(y_test, gbm.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, gbm.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % gbm_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
eXtreme Gradient Boosting (XGBoost)
XGBoost, GBM’in hız ve tahmin performansını arttırmak üzere optimize edilmiş; ölçeklenebilir ve farklı platformlara entegre edilebilir halidir. 2014 yılında Tianqi Chen tarafından geliştirilmiştir.
- R, Python, Hodoop, Scala, Julia ile kullanılabilir.
- Ölçeklenebilir ve hızlıdır.
- Tahmin başarısı yüksektir.
xgboost’u kullanabilmek için xgboost kütühanesini yüklüyoruz.
!pip install xgboost
- Model ve Tahmin
In [102]:
from xgboost import XGBClassifierIn [103]:
xgboost = XGBClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [104]:
xgboost_params = {'learning_rate': [0.1, 0.01, 0.001],
'subsample':[0.6, 0.8, 1],
'n_estimators': [100,500,1000,2000],
'max_depth':[3,5,7]}In [105]:
xgboost_cv_model = GridSearchCV(xgboost, xgboost_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 10 folds for each of 108 candidates, totalling 1080 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 44 tasks | elapsed: 2.4s
[Parallel(n_jobs=-1)]: Done 246 tasks | elapsed: 26.4s
[Parallel(n_jobs=-1)]: Done 485 tasks | elapsed: 56.0s
[Parallel(n_jobs=-1)]: Done 784 tasks | elapsed: 1.7min
[Parallel(n_jobs=-1)]: Done 1080 out of 1080 | elapsed: 2.7min finished
In [106]:
xgboost_cv_modelOut[106]:
GridSearchCV(cv=10, error_score=nan,
estimator=XGBClassifier(base_score=None, booster=None,
colsample_bylevel=None,
colsample_bynode=None,
colsample_bytree=None, gamma=None,
gpu_id=None, importance_type='gain',
interaction_constraints=None,
learning_rate=None, max_delta_step=None,
max_depth=None, min_child_weight=None,
missing=nan, monotone_constraints=None,
n_esti...
random_state=None, reg_alpha=None,
reg_lambda=None, scale_pos_weight=None,
subsample=None, tree_method=None,
validate_parameters=False,
verbosity=None),
iid='deprecated', n_jobs=-1,
param_grid={'learning_rate': [0.1, 0.01, 0.001],
'max_depth': [3, 5, 7],
'n_estimators': [100, 500, 1000, 2000],
'subsample': [0.6, 0.8, 1]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [107]:
xgboost_cv_model.best_params_Out[107]:
{'learning_rate': 0.001, 'max_depth': 5, 'n_estimators': 2000, 'subsample': 1}In [108]:
xgboost = XGBClassifier(learning_rate=0.001, max_depth=5, n_estimators=2000, subsample=1).fit(X_train, y_train)In [109]:
y_pred = xgboost.predict(X_test)- Model değerlendirmesi
In [110]:
accuracy_score(y_test, y_pred)Out[110]:
0.7575757575757576In [111]:
xgboost.feature_importances_Out[111]:
array([0.10137416, 0.33625114, 0.08572464, 0.06300785, 0.09341244,
0.13455635, 0.05178372, 0.13388968], dtype=float32)In [112]:
feature_imp = pd.Series(xgboost.feature_importances_,
index=X_train.columns).sort_values(ascending=False)sns.barplot(x=feature_imp, y=feature_imp.index)
plt.xlabel('Değisken Önem Skorları')
plt.ylabel('Değişkenler')
plt.title('Değişken Önem Düzeyleri')
plt.show()
In [113]:
cross_val_score(xgboost, X_test, y_test, cv=21).mean()Out[113]:
0.7316017316017315In [114]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.82 0.80 0.81 151
1 0.64 0.68 0.66 80 accuracy 0.76 231
macro avg 0.73 0.74 0.74 231
weighted avg 0.76 0.76 0.76 231
In [115]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [116]:
xgboost_roc_auc = roc_auc_score(y_test, xgboost.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, xgboost.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % xgboost_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
LightGBM
LightGBM, XGBoost’un eğitim süresi performansını arttırmaya yönelik geliştirilen GBM türüdür. 2017 yılında Microsoft tarafından geliştirilmiştir.
- Performansı yüksektir.
- Level-wise büyüme stratejisi yerine Leaf-wise büyüme stratejisi kullanır.
- BFS yerine DFS kullanır
LightGBM’ i kullanabilmek için lightgbm kütühanesini yüklüyoruz.
!pip install lightgbm
- Model ve Tahmin
In [117]:
from lightgbm import LGBMClassifierIn [118]:
lightgbm = LGBMClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [119]:
lightgbm_params = {'learning_rate': [0.1, 0.01, 0.001],
'n_estimators': [200,500,100],
'max_depth':[1,2,35,8]}In [120]:
lightgbm_cv_model = GridSearchCV(lightgbm, lightgbm_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train)Fitting 10 folds for each of 36 candidates, totalling 360 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
[Parallel(n_jobs=-1)]: Done 128 tasks | elapsed: 2.9s
[Parallel(n_jobs=-1)]: Done 360 out of 360 | elapsed: 8.1s finished
In [121]:
lightgbm_cv_modelOut[121]:
GridSearchCV(cv=10, error_score=nan,
estimator=LGBMClassifier(boosting_type='gbdt', class_weight=None,
colsample_bytree=1.0,
importance_type='split',
learning_rate=0.1, max_depth=-1,
min_child_samples=20,
min_child_weight=0.001,
min_split_gain=0.0, n_estimators=100,
n_jobs=-1, num_leaves=31, objective=None,
random_state=None, reg_alpha=0.0,
reg_lambda=0.0, silent=True,
subsample=1.0, subsample_for_bin=200000,
subsample_freq=0),
iid='deprecated', n_jobs=-1,
param_grid={'learning_rate': [0.1, 0.01, 0.001],
'max_depth': [1, 2, 35, 8],
'n_estimators': [200, 500, 100]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [122]:
lightgbm_cv_model.best_params_Out[122]:
{'learning_rate': 0.01, 'max_depth': 1, 'n_estimators': 500}In [123]:
lightgbm = LGBMClassifier(learning_rate=0.01, max_depth=1, n_estimators=500).fit(X_train, y_train)In [124]:
y_pred = lightgbm.predict(X_test)- Model değerlendirmesi
In [125]:
accuracy_score(y_test, y_pred)Out[125]:
0.7575757575757576In [126]:
lightgbm.feature_importances_Out[126]:
array([ 0, 226, 0, 0, 0, 134, 24, 116], dtype=int32)In [127]:
feature_imp = pd.Series(lightgbm.feature_importances_,
index=X_train.columns).sort_values(ascending=False)sns.barplot(x=feature_imp, y=feature_imp.index)
plt.xlabel('Değisken Önem Skorları')
plt.ylabel('Değişkenler')
plt.title('Değişken Önem Düzeyleri')
plt.show()
In [128]:
cross_val_score(lightgbm, X_test, y_test, cv=21).mean()Out[128]:
0.7099567099567101In [129]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.78 0.87 0.83 151
1 0.69 0.54 0.61 80 accuracy 0.76 231
macro avg 0.74 0.71 0.72 231
weighted avg 0.75 0.76 0.75 231
In [130]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [131]:
lightgbm_roc_auc = roc_auc_score(y_test, lightgbm.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, lightgbm.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % lightgbm_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Category Boosting (CatBoost)
Kategorik değişkenler ile otomatik olarak mücadele edebilen, hızlı, başarılı GBM türüdür. 2017 yılında Yandex tarafınfan geliştirilmiştir.
- Kategorik değişken desteği.
- Hızlı ve ölçeklenebilir GPU desteği.
- Daha başarılı tahminler.
- Hızlı eğitim ve hızlı tahmin.
CatBoost’u kullanabilmek için xgboost kütühanesini yüklüyoruz.
!pip install catboost
- Model ve Tahmin
In [132]:
from catboost import CatBoostClassifierIn [133]:
catboost = CatBoostClassifier()Uygun parametre seçimi için modeli değişik parametrelerle çalıştırıyoruz.
In [134]:
catboost_params = {'learning_rate': [0.1, 0.01, 0.003],
'iterations': [200,500,1000],
'depth':[4,5,8]}In [135]:
catboost_cv_model = GridSearchCV(catboost, catboost_params, cv=10, n_jobs=-1, verbose=2).fit(X_train, y_train, verbose=False)Fitting 10 folds for each of 27 candidates, totalling 270 fits[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.
/home/kayademirs/anaconda3/lib/python3.7/site-packages/joblib/externals/loky/process_executor.py:706: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.
"timeout or by a memory leak.", UserWarning
[Parallel(n_jobs=-1)]: Done 33 tasks | elapsed: 5.4s
[Parallel(n_jobs=-1)]: Done 154 tasks | elapsed: 33.0s
[Parallel(n_jobs=-1)]: Done 270 out of 270 | elapsed: 2.2min finished
In [136]:
catboost_cv_modelOut[136]:
GridSearchCV(cv=10, error_score=nan,
estimator=<catboost.core.CatBoostClassifier object at 0x7f526e9546d0>,
iid='deprecated', n_jobs=-1,
param_grid={'depth': [4, 5, 8], 'iterations': [200, 500, 1000],
'learning_rate': [0.1, 0.01, 0.003]},
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring=None, verbose=2)In [137]:
catboost_cv_model.best_params_Out[137]:
{'depth': 8, 'iterations': 1000, 'learning_rate': 0.003}In [138]:
catboost = CatBoostClassifier(iterations=1000, learning_rate=0.003, depth=8).fit(X_train, y_train, verbose=False)In [139]:
y_pred = catboost.predict(X_test)- Model değerlendirmesi
In [140]:
accuracy_score(y_test, y_pred)Out[140]:
0.7402597402597403In [141]:
catboost.feature_importances_Out[141]:
array([ 8.5167054 , 25.06880489, 8.33025712, 8.40732395, 7.79092591,
16.03491441, 11.47468546, 14.37638285])In [142]:
feature_imp = pd.Series(catboost.feature_importances_,
index=X_train.columns).sort_values(ascending=False)sns.barplot(x=feature_imp, y=feature_imp.index)
plt.xlabel('Değisken Önem Skorları')
plt.ylabel('Değişkenler')
plt.title('Değişken Önem Düzeyleri')
plt.show()
In [143]:
print(classification_report(y_test, y_pred))precision recall f1-score support 0 0.79 0.81 0.80 151
1 0.63 0.60 0.62 80 accuracy 0.74 231
macro avg 0.71 0.71 0.71 231
weighted avg 0.74 0.74 0.74 231
In [144]:
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cbar=False)
plt.show()
In [145]:
catboost_roc_auc = roc_auc_score(y_test, catboost.predict(X_test))
fpr , tpr, thresholds = roc_curve(y_test, catboost.predict_proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='AUC (area = %0.2f)' % catboost_roc_auc)
plt.plot([0,1], [0,1], 'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.legend(loc='lower right')
plt.show()
Tüm Modellerin Karşılaştırılması
In [146]:
models = [log_model, knn, svm, mlpc, cart, rf, gbm, xgboost, lightgbm, catboost]
result = []
results = pd.DataFrame(columns=['Models', "Accuracy"])for model in models:
names = model.__class__.__name__
if names == 'MLPClassifier':
y_pred = model.predict(X_test_scaler)
else:
y_pred = model.predict(X_test)
acc = accuracy_score(y_test, y_pred)
result = pd.DataFrame([[names, acc*100]], columns=['Models', 'Accuracy'])
results = results.append(result)
In [147]:
sns.barplot(x='Accuracy', y='Models', data=results, color='r')
plt.xlabel('Accuracy %')
plt.title('Modellerin Doğruluk Oranları');
In [148]:
resultsOut[148]:
Kaynaklar
- https://developers.google.com/machine-learning/crash-course
- https://tr.wikipedia.org/wiki/Destek_vekt%C3%B6r_makinesi
- https://www.udemy.com/course/python-ile-makine-ogrenmesi/
- https://www.veribilimiokulu.com/bootstrap/
- https://en.wikipedia.org/wiki/Gradient_boosting
- http://bilgisayarkavramlari.sadievrenseker.com/2008/12/01/svm-support-vector-machine-destekci-vektor-makinesi/
