Python ile öznitelik seçimi ve parametre optimizasyonu

GitHub üzerinden tam haline bakabilirsiniz: https://github.com/berkanaslan/FeatureSelection-ParamOptimizationTutorial

Bu yazıda 3 adet regresyon modeli kullanarak, sırasıyla öznitelik seçimi ve parametre optimizasyonu örneği yapacağım.

Kullanacağım veri setini buraya tıklayarak indirebilirsiniz.

VERİ ÖN ANALİZİ (VERİ KEŞFİ)

import pandas as pd
fileName = 'data.xlsx'
colNames=['id','cycle','setting1','setting2','setting3','s1','s2','s3','s4','s5','s6','s7','s8','s9','s10','s11','s12','s13','s14','s15','s16','s17','s18','s19','s20','s21','ttf']
data = pd.read_excel(fileName, name=colNames)
peek = data.head(5)
print(peek)

Çıktı:

   id  cycle  setting1  setting2  setting3  ...   s18  s19    s20      s21  ttf
0   1      1   -0.0007   -0.0004       100  ...  2388  100  39.06  23.4190  191
1   1      2    0.0019   -0.0003       100  ...  2388  100  39.00  23.4236  190
2   1      3   -0.0043    0.0003       100  ...  2388  100  38.95  23.3442  189
3   1      4    0.0007    0.0000       100  ...  2388  100  38.88  23.3739  188
4   1      5   -0.0019   -0.0002       100  ...  2388  100  38.90  23.4044  187

Veri setini gömme işleminin ardından, veri seti özniteliklerinin değişken türlerini inceledim.

types = data.dtypes
print(types)

Çıktı:

[5 rows x 27 columns]
id            int64 - cycle         int64 - setting1    float64 - setting2    float64
setting3      int64 - s1          float64 - s2          float64 - s3          float64
s4          float64 - s5          float64 - s6          float64 - s7          float64
s8          float64 - s9          float64 - s10         float64 - s11         float64
s12         float64 - s13         float64 - s14         float64 - s15         float64
s16         float64 - s17           int64 - s18           int64 - s19           int64
s20         float64 - s21         float64 - ttf           int64
dtype: object

Bu işlemin ardından özniteliklerimin, toplam değişken sayısı, ortalaması, medyanı, standart sapması gibi istatistiklerini görüntüleyebileceğim kodlarımı yazdım.

from pandas import set_option
set_option('display.width', 125)
set_option('precision',3)
description = data.describe()
print(description)

Çıktı:

             id     cycle   setting1  ...       s20       s21       ttf
count  3635.000  3635.000  3.635e+03  ...  3635.000  3635.000  3635.000
mean      9.080   108.486  1.851e-05  ...    38.841    23.303   109.580
std       5.092    67.751  2.182e-03  ...     0.187     0.112    67.393
min       1.000     1.000 -7.400e-03  ...    38.220    22.940     0.000
25%       5.000    51.000 -1.400e-03  ...    38.720    23.231    53.000
50%       9.000   104.000  1.000e-04  ...    38.860    23.314   106.000
75%      14.000   158.000  1.500e-03  ...    38.980    23.388   159.000
max      18.000   287.000  7.600e-03  ...    39.430    23.601   286.000

[8 rows x 27 columns]

İstatistiklerin ardından özniteliklerimin içerisinde eksik veri olup olmadığını kontrol ettim.

data.isnull().sum()

Bu kod bana çıktı olarak veri setimden eksik veri olmadığını döndürdü.

VERİ DAĞILIMLARI

Veri keşfi ve ön analiz işlemlerine özniteliklerimin histogram grafiklerini inceleyerek devam ettim.

import matplotlib.pyplot as plt
data.hist(figsize=(30,30))
plt.show()

VERİ DAĞILIMLARI MATRİSİ

Histogram grafiklerini elde ettikten sonra özniteliklerin matris grafiklerini inceledim.

from pandas.plotting import scatter_matrix
scatter_matrix(data,figsize=(30,40))
plt.show()

KORELASYON

Histogramın ardından belki de en önemli analiz aşaması olan korelasyonu inceleyebilmek adına gerekli kodlarımı yazdım. Bu bilgiler ışığında veri setimden düşük varyans gösteren öznitelikleri verimden çıkartabilirim.

import seaborn as sn
correlation = data.corr()
sn.heatmap(correlation, linewidths = .5)

VERİ SETİ DÜZENLEME

Yukarıda elde ettiğim korelasyon çıktısı sayesinde düşük varyans gösteren özniteliklerimi öğrenmiş oldum. Bu özniteliklerin isimlerini bir liste değişkenine atayıp veri setimden çıkardım. Ardından geriye kalan özniteliklerimin detaylarını info() metodu ile ekrana yazdırdım.

Bu metot, yukarıda kullanmış olduğum dtypes() metodundan farklı bir şey yapmayacak. Sadece silmek istediğimiz özniteliklerin silinip silinmeme durumunu kontrol etmiş oldum.

dropList = ['setting3', 's5', 's10', 's16', 's18', 's19']
data = data.drop(dropList, axis=1)
print(data.info())

Gerekli öznitelikler ile DataFrame oluşturmak için gerekli kodu yazdım.

newColNames=['id','cycle','setting1','setting2','s1','s2','s3','s4','s6','s7','s8','s9','s11','s12','s13','s14','s15','s17','s20','s21','ttf']
veri = pd.DataFrame(data)
veri.columns = newColNames
print(veri.head())

Çıktı:

   id  cycle   setting1   setting2      s1  ...     s15  s17    s20     s21  ttf
0   1      1 -7.000e-04 -4.000e-04  518.67  ...  84.195  392  39.06  23.419  191
1   1      2  1.900e-03 -3.000e-04  518.67  ...  84.318  392  39.00  23.424  190
2   1      3 -4.300e-03  3.000e-04  518.67  ...  84.178  390  38.95  23.344  189
3   1      4  7.000e-04  0.000e+00  518.67  ...  83.682  392  38.88  23.374  188
4   1      5 -1.900e-03 -2.000e-04  518.67  ...  84.294  393  38.90  23.404  187

Bu işlemin ardından çıktı değişkenim olan ttf sütunu ile diğer özniteliklerimi farklı değişkenlere (X ve Y) atamamı sağlayacak olan kodları yazdım. Ardından işlemin gerçekleşip gerçekleşmediğini teyit etmek için konsola yazdırdım.

veri = data.values
X = veri[:,0:20]
Y = veri[:,20]
print(X.shape)
print(Y.shape)

Bu işlemin ardından veri setimi eğitim – test olarak parçaladım. Parçalama işleminde verilerimin %70’ini eğitim için kullanacağımı belirttim.

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X,Y,test_size=0.3, random_state = 0)

Veri seti düzenleme işleminin son adımı olarak veri setimin normalizasyon işlemine tabii tuttum. Normalizasyon işlemini 0 ila 1’e indirgeme yöntemi olan MinMaxScaler ile yaptım. Normalizasyona giren verileri x_train_norm ve x_test_norm değişkenlerinin içerisinde sakladım.

#Normalizasyon işlemi
from sklearn.preprocessing import MinMaxScaler
minMaxScaler = MinMaxScaler()
minMaxScaler.fit(x_train)
x_train_norm = minMaxScaler.transform(x_train)
x_test_norm = minMaxScaler.transform(x_test)

MODELLEME İŞLEMLERİ

Modelleme işlemlerine girmeden, ilk olarak gerekli olan kütüphaneleri uygulamama dahil ettim.

import numpy
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import r2_score, mean_squared_error
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor

1.1. K-NEAREST NEIGHBORHOOD MODELLEMESİ

İlk olarak K Nearest Neighborhood modellemesini kullanacağım. K Nearest Beighborhood modellemesi, Türkçe en yakın komşu anlamına gelir. Seçili gözlem(ler)e en yakın gözlemlerin uzaklık mesafeleri baz alınarak modelleme işlemi yapılır.

İlk olarak, hiçbir parameter girmeden modelimi çalıştırdım.

knn_model_ham =  KNeighborsRegressor()
knn_model_ham_fit = knn_model_ham.fit(x_train_norm, y_train)

Modelimi çalıştırdıktan sonra fit() methodu ile eğitim işlemini knn_model_ham_fit içerisinde sakladım. Şimdi, bu eğitim sonucunu test etmek için yeni tahminler üreteceğim.

tahmin_train = knn_model_ham_fit.predict(x_train_norm)
tahmin_test = knn_model_ham_fit.predict(x_test_norm)

Eğitim ve test tahminlerimiz predict() metodu ile gerçekleştirdim. Artık sonucumun skorlarına göz atabilirim.

print("KNeighborsRegressor: Test Sonucu:")
print('KNN R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('KNN MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('KNN R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('KNN MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

KNeighborsRegressor: Test Sonucu:
KNN R² (Eğitim): 0.9298
KNN MSE (Eğitim): 316.5318
KNN R² (Test): 0.8825
KNN MSE (Test): 540.5024

Eğitim veri seti ile yaptığım test sonucunda değeri 0.9298, test verisi ile yaptığım skorlamada değerini 0.8825 sonuçlarını elde ettim.

Öte yandan elde edilen sonuçlarda bulunan MSE (Ortalama Kare Hata) değerleri sıfıra yakın değerler olması gerekirken, veri setininde bulunan 0 ve eksili değerler yüzünden yüksel çıktıları vermekte.

1.2. GRADIENT BOOSTING REGRESSOR MODELLEMESİ

İkinci öğrenme algoritması olarak Gradient Boosting Regressor algoritmasını kullanacağım. Bu modelleme algoritması, zayıf öğrenicileri, güçlü öğreniciyedönüştürme yöntemidir. Bu işlemi iterasyon sayısı ile yapar.

İlk olarak, modellemeyi kullanabilmek adına gerekli olan sınıfımı çağırdım.

gbr_model_ham =  GradientBoostingRegressor()
gbr_model_ham_fit = gbr_model_ham.fit(x_train_norm, y_train)

Ardından modelimi kullanarak tahmin işlemlerine gerçekleştirdim.

tahmin_train_gbr = gbr_model_ham_fit.predict(x_train_norm)
tahmin_test_gbr = gbr_model_ham_fit.predict(x_test_norm)

Tahminlerimin skorunu inceleyebilmek adına gerekli kodları uygulamama dahil ettim.

print('GradientBoosting R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train_gbr))
print('GradientBoosting MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train_gbr))
print('GradientBoosting R² (Test): %.4f' % r2_score(y_test, tahmin_test_gbr))
print('GradientBoosting MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test_gbr))

Çıktı:

GradientBoosting R² (Eğitim): 0.9819
GradientBoosting MSE (Eğitim): 81.5374
GradientBoosting R² (Test): 0.9721
GradientBoosting MSE (Test): 128.3062

1.3. RANDOM FOREST REGRESSOR MODELLEMESİ

Son olarak Random Forest (Rastgele Karar Ormanları) algoritmasını kullanacağım. İlk olarak sınıfımı uygulamama dahil ettim.

rfg_model_ham =  RandomForestRegressor()
rfg_model_ham_fit = rfg_model_ham.fit(x_train_norm, y_train)

Ardından oluşturduğum değişkeni kullanarak yeni tahminler elde etmek için gerekli kodları uygulamama dahil ettim.

tahmin_train_rfg = rfg_model_ham_fit.predict(x_train_norm)
tahmin_test_rfg = rfg_model_ham_fit.predict(x_test_norm)

Skorlarımı elde edip ekrana yazdırmak için gerekli kodları uygulamama dahil ettim.

print('RandomForestRegressor R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train_rfg))
print('RandomForestRegressor MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train_rfg))
print('RandomForestRegressor R² (Test): %.4f' % r2_score(y_test, tahmin_test_rfg))
print('RandomForestRegressor MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test_rfg))

Çıktı:

RandomForestRegressor R² (Eğitim): 0.9945
RandomForestRegressor MSE (Eğitim): 25.0243
RandomForestRegressor R² (Test): 0.9584
RandomForestRegressor MSE (Test): 191.3424

Sırasıyla

  1. KNeighborsRegressor
  2. GradientBoosting
  3. RandomForestRegressor

öğreme algoritmalarını kullandım ve değerlerini elde ettim. Şimdi bu skorları geliştirmek için öznitelik seçme işlemlerini uygulamama dahil etmem gerekiyor.

ÖZNİTELİK SEÇME İŞLEMLERİ (SELECT KBEST)

Veri setinde bulunan öznitelikleri, modelleme işlemlerinde gerekli olmayan öznitelikleri uygulamadan dışlamak adına Select KBest methodunu uygulaya dahil edeceğim. Bu işlem ile modelleme skorlarında ve test – eğitim skorlarının arasındaki farkın azalmasında iyileşme bekliyorum. Bu amaçla k değerini 15 verdim.

#SelectKBest: Öznitelik seçimi:
select_feature = SelectKBest(chi2, k=15).fit(x_train_norm, y_train)

# SelectKBest ile gelen değerleri değişkenlere atadım.
x_train_k = select_feature.transform(x_train_norm)
x_test_k = select_feature.transform(x_test_norm)

Gerekli kodları uygulamama dahil ettim ve artık öncesinde x_train_norm olarak kullandığım eğitim veri setini artık x_train_k olarak; test için kullandığım veri setini de x_test_k olarak kullanacağım.

2.1. K-NEAREST NEIGHBORHOOD MODELLEMESİ

En iyi özniteliklerin seçimi işlemi tamamlandı. Şimdi tekrardan K-Nearest Beighborhood modelimi yeni değişkenler ile kullanarak yeni skorlarımı elde edebilirim.

knn_model =  KNeighborsRegressor()
knn_model_fit = knn_model.fit(x_train_k, y_train)

Yeni tahminler elde etmek için gerekli olan kodlar:

tahmin_train = knn_model.predict(x_train_k)
tahmin_test = knn_model.predict(x_test_k)

Skorları ekrana yazdırmak için gerekli olan kodlar:

print('KNN R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('KNN MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('KNN R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('KNN MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

KNN R² (Eğitim): 0.9149
KNN MSE (Eğitim): 383.7701
KNN R² (Test): 0.8617
KNN MSE (Test): 636.5264

Eğitim ve Test skorlarını sırasıyla; 0.9149 ve 0.8617 olarak elde ettim.

2.2. GRADIENT BOOSTING REGRESSOR MODELLEMESİ

İkinci öğrenme algoritması olarak kullandığım Gradient Boosting Regressor modelini, seçilen en iyi öznitelikler ile tekrardan çalışacağım.

gbr_model =  GradientBoostingRegressor()
gbr_model_fit = gbr_model.fit(x_train_k, y_train)

Yeni tahminler elde etmek için gerekli olan kodlar:

tahmin_train = gbr_model.predict(x_train_k)
tahmin_test = gbr_model.predict(x_test_k)

Skorları ekrana yazdırmak için gerekli olan kodlar:

print('Gradient Boosting R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('Gradient Boosting MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('Gradient Boosting R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('Gradient Boosting MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

Gradient Boosting R² (Eğitim): 0.9302
Gradient Boosting MSE (Eğitim): 314.8260
Gradient Boosting R² (Test): 0.8796
Gradient Boosting MSE (Test): 553.7993

Eğitim ve Test skorlarını sırasıyla; 0.9302 ve 0.8796 olarak elde ettim.

2.3. RANDOM FOREST REGRESSOR MODELLEMESİ

Üçüncü  öğrenme algoritması olarak kullandığım Random Forest Regressor modelini, seçilen en iyi öznitelikler ile tekrardan çalışacağım.

rfg_model =  RandomForestRegressor()
rfg_model_fit = rfg_model.fit(x_train_k, y_train)

Yeni tahminler elde etmek için gerekli olan kodlar:

tahmin_train_rfg = rfg_model.predict(x_train_k)
tahmin_test_rfg = rfg_model.predict(x_test_k)

Skorları ekrana yazdırmak için gerekli olan kodlar:

print('RandomForestRegressor R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train_rfg))
print('RandomForestRegressor MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train_rfg))
print('RandomForestRegressor R² (Test): %.4f' % r2_score(y_test, tahmin_test_rfg))
print('RandomForestRegressor MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test_rfg))

Çıktı:

RandomForestRegressor R² (Eğitim): 0.9860
RandomForestRegressor MSE (Eğitim): 63.1946
RandomForestRegressor R² (Test): 0.8903
RandomForestRegressor MSE (Test): 504.8358

PARAMETRE OPTİMİZASYONU

Kullanmayı tercih ettiğim öğrenme algoritmaları ile sırasıyla ham ve öznitelik seçme işlemlerinin skorlarını elde ettim. Son iyileştirme işlemi olarak tüm öğrenme algoritmalarını parameter optimizasyonuna tabii tutacağım.

3.1. K-NEAREST BEIGHBORHOOD MODELLEMESİ

Parametre optimizasyonunu ilk olarak kNN modellemesi için gerçekleştireceğim.

model = KNeighborsRegressor()

kNN modellemesi parametre olarak yalnızca K değeri alır. Bu sebepke K değerlerini içeren bir dizi oluşturdum.

k_values = numpy.array([1,3,5,7,9,11,13,15,17,19,21])

Her K değeri için modelin çalışmasını sağlayacak kodları uygulamama dahil ettim.

param_grid = dict(n_neighbors=k_values)
grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=None)
grid_result = grid.fit(x_train_k, y_train)

Bu işlem her parametre değeri için modeli çalıştıracak. İşlem sonunda elde edilen en iyi parametre değerini bir değişken içerisinde saklayarak, bu değişkeni kullanıp parametre optimizasyonu sonucunda elde edilen eğitim – test skorumu görüntüleyeceğim.

parameter = grid_result.best_params_
print("En iyi KNN %f ile %s" % (grid_result.best_score_, grid_result.best_params_))

Çıktı:

En iyi KNN 0.880979 ile {‘n_neighbors’: 21}

En iyi parametre değerimiz 21 ile modelimizi çalıştırdığımızda sonucunu 0.880979 elde ettim. Şimdi tüm parametre denemeleri sonucu elde edilen skorları görüntüleyeceğim.

means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) : %r" % (mean, stdev, param))

Çıktı:

0.776193 (0.015633) : {'n_neighbors': 1}
0.856460 (0.010748) : {'n_neighbors': 3}
0.869698 (0.007955) : {'n_neighbors': 5}
0.873395 (0.006285) : {'n_neighbors': 7}
0.876393 (0.004045) : {'n_neighbors': 9}
0.878516 (0.004130) : {'n_neighbors': 11}
0.879304 (0.004197) : {'n_neighbors': 13}
0.879061 (0.004479) : {'n_neighbors': 15}
0.879493 (0.004729) : {'n_neighbors': 17}
0.880180 (0.004300) : {'n_neighbors': 19}
0.880979 (0.004763) : {'n_neighbors': 21}

3.1. K-NEAREST NEIGHBORHOOD MODELLEMESİ

Son olarak, en iyi parametre değerimiz olan 21 ile yeni tahminler oluşturup skorlarına göz atacağım.

model = KNeighborsRegressor(**parameter)
model.fit(x_train_k, y_train)

tahmin_train = model.predict(x_train_k)
tahmin_test = model.predict(x_test_k)

Modelimi kurdum ve **parameter ile elde ettiğim en iyi parametre değerini modelime atadım. Tahmin değişkenlerini oluşturdum; artık skorlama yapabilirim.

print('KNN R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('KNN MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('KNN R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('KNN MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

KNN R² (Eğitim): 0.8924
KNN MSE (Eğitim): 485.5508
KNN R² (Test): 0.8681
KNN MSE (Test): 606.9657

3.2. GRADIENT BOOSTING REGRESSOR MODELLEMESİ

kNN modellemesi için işlemler tamamlandı. Bu kez, aynı işlemleri Gradient Boosting için uygulayacağım.

model = GradientBoostingRegressor()

Gradient Boosting için yapacağım parametre optimizasyonunda 3 farklı parametre yer olacak. Bunlar;

  1. learning_rate:    Öğrenme katsayısı
  2. n_esimators:      Ağaç sayısı
  3. max_depth:        Maksimum derinlik
param_grid = {'learning_rate': [0.01,0.02,0.03],
                  'n_estimators' : [100,500,1000],
                  'max_depth'    : [4,6,8] 
                 }

Ardından bu parametreler ile tek deneme yapması için gerekli olan kodları uygulamama dahil ettim.

grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=None)
grid_result = grid.fit(x_train_k, y_train)

En iyi parametre değerlerini değişken içerisinde atadım ve ekrana yazdırdım.

parameter = grid_result.best_params_ 
print("En iyi GradientBoosting %f ile %s" % (grid_result.best_score_, grid_result.best_params_))

Çıktı:

En iyi GradientBoosting 0.896024 ile {'learning_rate': 0.01, 'max_depth': 6, 'n_estimators': 1000}

3.2. GRADIENT BOOSTING REGRESSOR MODELLEMESİ

En iyi parametre sonucumu elde ettim. Diğer parametreler ile elde edilen skorları görüntülemek için gerekli kodları uygulamama dahil ettim.

eans = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) : %r" % (mean, stdev, param))

Çıktı:

0.746375 (0.008246) : {'learning_rate': 0.01, 'max_depth': 4, 'n_estimators': 100}
0.893181 (0.005478) : {'learning_rate': 0.01, 'max_depth': 4, 'n_estimators': 500}
0.894468 (0.005979) : {'learning_rate': 0.01, 'max_depth': 4, 'n_estimators': 1000}
0.763377 (0.009317) : {'learning_rate': 0.01, 'max_depth': 6, 'n_estimators': 100}
0.894708 (0.007509) : {'learning_rate': 0.01, 'max_depth': 6, 'n_estimators': 500}
0.896024 (0.006824) : {'learning_rate': 0.01, 'max_depth': 6, 'n_estimators': 1000}
0.766962 (0.010311) : {'learning_rate': 0.01, 'max_depth': 8, 'n_estimators': 100}
0.892055 (0.006572) : {'learning_rate': 0.01, 'max_depth': 8, 'n_estimators': 500}
0.891872 (0.007298) : {'learning_rate': 0.01, 'max_depth': 8, 'n_estimators': 1000}
0.865966 (0.006261) : {'learning_rate': 0.02, 'max_depth': 4, 'n_estimators': 100}
0.895264 (0.005830) : {'learning_rate': 0.02, 'max_depth': 4, 'n_estimators': 500}
0.894342 (0.005479) : {'learning_rate': 0.02, 'max_depth': 4, 'n_estimators': 1000}
0.874068 (0.008295) : {'learning_rate': 0.02, 'max_depth': 6, 'n_estimators': 100}
0.895356 (0.008382) : {'learning_rate': 0.02, 'max_depth': 6, 'n_estimators': 500}
0.894645 (0.008648) : {'learning_rate': 0.02, 'max_depth': 6, 'n_estimators': 1000}
0.874453 (0.007271) : {'learning_rate': 0.02, 'max_depth': 8, 'n_estimators': 100}
0.891052 (0.007488) : {'learning_rate': 0.02, 'max_depth': 8, 'n_estimators': 500}
0.891294 (0.006860) : {'learning_rate': 0.02, 'max_depth': 8, 'n_estimators': 1000}
0.887539 (0.004514) : {'learning_rate': 0.03, 'max_depth': 4, 'n_estimators': 100}
0.895332 (0.005561) : {'learning_rate': 0.03, 'max_depth': 4, 'n_estimators': 500}

Son olarak en iyi parametre sonucumu kullanarak modelimin yeni tahminleme skorunu ölçeceğim.

model = GradientBoostingRegressor(**parameter)
model.fit(x_train_k, y_train)
tahmin_train = model.predict(x_train_k)
tahmin_test = model.predict(x_test_k)

print("GradientBoostingRegressor: Parametre Optimizasyonu: Test Sonucu:")
print('Gradient Boosting R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('Gradient Boosting MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('Gradient Boosting R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('Gradient Boosting MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

Gradient Boosting R² (Eğitim): 0.9844
Gradient Boosting MSE (Eğitim): 70.5342
Gradient Boosting R² (Test): 0.8877
Gradient Boosting MSE (Test): 516.7419

3.3. RANDOM FOREST REGRESSOR MODELLEMESİ

Parametre optimizasyonu işlemini bu kez de Random Forest Regressor için kullanacağım.

model = RandomForestRegressor()

Random Forest için kullanacağım parametre alternatiflerim:

param_grid = {'n_estimators': [100,200,300,400],
              'max_depth': [5,10,15,20]
                 }

Parametre optimizasyonu işlemlerini gerçekleştirecek olan kodları uygulamaya dahil ettim:

grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=None)
grid_result = grid.fit(x_train_k, y_train)

En iyi parametre değerlerini değişken içerisinde atadım.

parameter = grid_result.best_params_
print("En iyi RandomForestRegressor %f ile %s" % (grid_result.best_score_, grid_result.best_params_))

Çıktı:

En iyi RandomForestRegressor 0.896765 ile {'max_depth': 15, 'n_estimators': 400}

En iyi parametre değerlerini elde ettim. Diğer parametre değerleri ile elde ettiğim skorlara göz attım.

means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']

for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) : %r" % (mean, stdev, param))

Çıktı:

0.881170 (0.007204) : {'max_depth': 5, 'n_estimators': 100}
0.881755 (0.007216) : {'max_depth': 5, 'n_estimators': 200}
0.881739 (0.007661) : {'max_depth': 5, 'n_estimators': 300}
0.881476 (0.007668) : {'max_depth': 5, 'n_estimators': 400}
0.896121 (0.004987) : {'max_depth': 10, 'n_estimators': 100}
0.895640 (0.005138) : {'max_depth': 10, 'n_estimators': 200}
0.895850 (0.005978) : {'max_depth': 10, 'n_estimators': 300}
0.896075 (0.005359) : {'max_depth': 10, 'n_estimators': 400}
0.896266 (0.005592) : {'max_depth': 15, 'n_estimators': 100}
0.896354 (0.004997) : {'max_depth': 15, 'n_estimators': 200}
0.896345 (0.005385) : {'max_depth': 15, 'n_estimators': 300}
0.896765 (0.006037) : {'max_depth': 15, 'n_estimators': 400}
0.895089 (0.005261) : {'max_depth': 20, 'n_estimators': 100}
0.895957 (0.005848) : {'max_depth': 20, 'n_estimators': 200}
0.896405 (0.005552) : {'max_depth': 20, 'n_estimators': 300}
0.896261 (0.005450) : {'max_depth': 20, 'n_estimators': 400}

3.3. RANDOM FOREST REGRESSOR MODELLEMESİ

Son olarak parameter isimli değişken içerisinde sakladığım, Random Forest modelim için en iyi parametre değerleri için modelimi tekrardan kuracağım. İşlem sonrasında yeni tahminleme işlemi yapıp skorları görüntüleyeceğim.

model = RandomForestRegressor(**parameter)
model.fit(x_train_k, y_train)

tahmin_train = model.predict(x_train_k)
tahmin_test = model.predict(x_test_k)

Skorlama ve ekrana yazdırma:

print('RandomForestRegressor: Parametre Optimizasyonu: Test Sonucu:')
print('RandomForestRegressor R² (Eğitim): %.4f' % r2_score(y_train, tahmin_train))
print('RandomForestRegressor MSE (Eğitim): %.4f' % mean_squared_error(y_train, tahmin_train))
print('RandomForestRegressor R² (Test): %.4f' % r2_score(y_test, tahmin_test))
print('RandomForestRegressor MSE (Test): %.4f' % mean_squared_error(y_test, tahmin_test))

Çıktı:

RandomForestRegressor R² (Eğitim): 0.9858
RandomForestRegressor MSE (Eğitim): 64.2212
RandomForestRegressor R² (Test): 0.8923
RandomForestRegressor MSE (Test): 495.6972

Elde edilen bu skor ile birlikte, uygulamada elde etmem gereken tüm sonuçları elde ettim. Bu sonuçları kıyaslamak için bir tablo oluşturdum.

SONUÇ TABLOSU

1. HAM R² VE MSE SONUÇLARI

 MSE
K-Neighbor Eğitim0.9298316.5318
K-Neighbor Test0.8825540.5024
Gradient Boost Eğitim0.981981.5374
Gradient Boost Test0.9721128.3062
Random Forest Eğitim0.994525.0243
Random Forest Test0.9584191.3424

2. ÖZNİTELİK SEÇİMİ SONRASI R² VE MSE SONUÇLARI

 MSE
K-Neighbor Eğitim0.9149383.7701
K-Neighbor Test0.8617636.5264
Gradient Boost Eğitim0.9302314.8260
Gradient Boost Test0.8796553.7993
Random Forest Eğitim0.986063.1946
Random Forest Test0.8903504.8358

3. PARAMETRE OPTİMİZASYONU SONRASI R² VE MSE SONUÇLARI

 MSE
K-Neighbor Eğitim0.8924485.5508
K-Neighbor Test0.8681606.9657
Gradient Boost Eğitim0.984470.5342
Gradient Boost Test0.8877516.7419
Random Forest Eğitim0.985864.2212
Random Forest Test0.8923495.6972

SONUÇ

K-Neighbor, Gradient Boosting ve Random Forest modellenmesi ve kullanımı, öznitelik seçimi ve parametre optimizasyonu gibi işlemler başarıyla tamamlanmıştır.

Parametre optimizasyonu kullanımı sonucunda elde edilen skorlara bakıldığında, Gradient Boosting ve Random Forest modellerinin değerleri kıyaslandığında birbirine yakın sonuçlar vermis; K-Neighbor modeli ise diğer algoritmalara göre daha düşük bir skor döndürmüştür. Ancak, yüksek eğitim test skoru döndüren Gradient Boosting ve Random Forest modellerinin eğitim performansı ile yeni tahminler ile elde edilen R² puanı kıyaslandığında bir tutarsızlık söz konusudur.

K-Neighbor ise, birbirine yakın sonuç veren eğitim ve yeni tahmin başarısı ile daha güvenilir bir modellemedir. Bu nedenle, projede model olarak K-Neighbor algoritmasının kullanılması, verisetine eklenecek her yeni gözlemin daha başarılı tahmin edilmesi, dahabaşarılı skorlanması anlamına gelmektedir.

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir