Regresyon Analizi (Makine Öğrenmesi-1)
Bu yazıda regresyon analizine ve regresyon türlerine giriş yapacağız. Umarım faydalı olur. Keyifli okumalar :)
Bahsedeceğimiz regresyon türleri:
- Basit Lineer Regresyon
- Polinom Regresyonu
- Lojistik Regresyon
- Ridge Regresyonu
- Lasso Regresyon
- Elastic Net Regresyon
Regresyon analizi, bağımlı bir değişken ile bir veya daha fazla bağımsız değişken arasındaki ilişkilerin tahmin edilmesi için kullanılan bir dizi istatiksel yöntemdir. Örneğin, ne kadar yediğiniz ile kilonuz arasında bir bağlantı olduğunu tahmin edebilirsiniz; regresyon analizi bunu ölçmeye yardımcı olabilir.
Regresyon analizi, doğrusal, çoklu doğrusal ve doğrusal olmayan gibi çeşitli varyasyonları içerir. En yaygın modeller doğrusal ve çoklu doğrusaldır. Doğrusal olmayan regresyon analizi genellikle, bağımlı ve bağımsız değişkenlerin doğrusal olmayan bir ilişki gösterdiği daha karmaşık veri kümeleri için kullanılır. Aşağıda bir regresyon tablosu örneği verilmiştir. Burada maaşın, tecrübe edilen yıl aralığı verilmiştir. Görüldüğü üzere tecrübe arttığında maaş da buna orantılı olarak artmıştır. Bizim çizdiğimiz çizgi bu oranlara en yakın şekilde konumlandırılmalıdır ki tahmin yapıldığında hata oranı en düşük olsun.
Basit Lineer Regresyon (Doğrusal Regresyon)
Aslında yukarıda verilen regresyon örneği burada bahsedeceğimiz doğrusal regresyon örneğidir. İki veya daha fazla değişken arasındaki ilişkinin bir doğru ile gösterilmesine lineer regresyon denir. Tek bir bağımsız değişken olduğunda regresyon modeline Basit Doğrusal Regresyon, birden fazla bağımsız değişken olduğunda ise Çoklu Doğrusal Regresyon modeli denir. Aşağıdaki verilen tabloya bazı veriler işlenmiştir. Buradan bir tahmin yapılabilir ama veriler düzenli dağılmadığı için sağlıklı bir tahmin elde etmek daha zordur.
Ama lineer regresyon bize daha doğru tahminde bulunabilmemiz için aşağıdaki gibi bir doğru çiziyor. Çizilen doğru sayesinde tahmin yapılabilmesi kolaylaşmıştır.
Peki lineer regresyonun nasıl ifade edilir? Basit lineer regresyon, aşağıdaki denklem kurularak ifade edilebilir.
Y: Bağımlı (sonuç) değişken olup belli bir hataya sahip olduğu varsayılır. Tahmin edilen değerdir. Gerçek y değeri ile arasındaki fark ne kadar az ise tahmin o kadar gerçeğe yakındır.
X: Bağımsız (sebep) değişken olup hatasız ölçüldüğü varsayılır.
a: Sabit olup X=0 olduğunda Y’nin aldığı değerdir.
b: Çizilen doğrunun eğimidir. Regresyon katsayısı olup, X’in kendi birimi cinsinden 1 birim değişmesine karşılık Y’de kendi birimi cinsinden meydana gelecek değişme miktarını ifade eder.
ε: Tesadüfi hata terimi olup ortalaması sıfır varyansı σ2 olan normal dağılış gösterdiği varsayılır. Bu varsayım parametre tahminleri için değil katsayıların önem kontrolleri için gereklidir.
En Küçük Kareler Yöntemi (Least Square Method): Bu yöntem lineer regresyonun temel kavramıdır denilebilir. Yukarıdaki modellerde tahmin edilen değer ile gerçek değer arasındaki uzaklığa (residual) bakacak olursak bunun aslında modelin tahmininin hata payı olduğunu görebiliriz. Her tahmin değerinin bir residual değeri varsa ve bu 0'dan sonsuza kadar ilerliyorsa bizim tüm tahminlerin residual değerlerinin karelerini (eğer gerçek değer tahmin edilenden küçükse residual negatif değer alır bu yüzden karelerini alıyoruz) toplamamız bize hata paylarının toplamına denk gelen bir sayı verecektir. Öyle bir çizgi (linear regresyon çizgisi) oluşturacak lineer regresyon modeli yapmalıyız ki, bu çizgi residualları minimize etsin, yani bize en küçük hata payı toplamını versin [1]. Kısaca bu yöntem hataları minimum yapmak üzerine kuruludur.
Şimdi Python’da bir basit lineer regresyon kodları yazalım.
İhtiyacımız olan kütüphaneleri ekleyerek başlıyoruz. Burada Pandas kütüphanesi .csv uzantılı veriyi (kullandığımız veriye buradan ulaşabilirsiniz) okumak için, Numpy kütüphanesi oluşturacağımız dizilerde daha hızlı sonuç alabilmek için, Matplolib kütüphanesi ise bu verileri grafiğe dökmemizi sağlamak için kullanıldı. Sklearn kütüphanesi ise lineer regresyon çizgisi çizmek için ve hata paylarını hesaplamak için eklendi.
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_errorVeri dosyasını okuduktan sonra veri setimizin kaç satır ve sütundan oluştuğunu çıktı olarak aldık. Ardından veride bulunan ilk 5 satırı çıktı olarak aldık. ‘.isnull().sum()’ komutu veri setinde eksik kısımları gösterir. Görüldüğü üzere YearsExperience sütununda hiç boşluk bulunmazken Salary sütununda bir tane boşluk bulunuyor.
df = pd.read_csv(“Salary_Data.csv”)
print(df.shape)
print(df.head())
print(df.isnull().sum())>>YearsExperience 0
>>Salary 1
>>dtype: int64
‘.fillna()’ ile ortalama değerlerden boşluğu doldurduk.
df.Salary.fillna(value=df.Salary.mean(), inplace = True)Tüm bunların ardından verileri normalize ediyoruz. Burada MinMaxScaler kullanılarak bu işlem gerçekleştirildi.
df.YearsExperience = (df.YearsExperience — df.YearsExperience.min()) / (df.YearsExperience.max() — df.YearsExperience.min())df.Salary = (df.Salary — df.Salary.min()) / (df.Salary.max() — df.Salary.min())
Verileri X ve Y değişkenine atadık.
X = df.YearsExperience
Y = df.SalaryMatplotlib kütüphanesini kullanarak verilerimizi grafik üzerinde işaretliyoruz.
plt.scatter(X.values,Y.values,color=’blue’)
plt.xlabel(‘X’)
plt.ylabel(‘Y’)
plt.title(‘X-Y arasındaki ilişki’)Buraya kadar olan kodumuzun çıktısı aşağıdaki şekilde verilmiştir.
Henüz lineer regresyon kodları uygulanmadan bu şekilde görünmektedir. Şimdi kodlarımıza eklemeler yaparak işlemleri tamamlayalım. Önce ‘Linear.Regression()’ ile fonksiyonumuzu çağırdık. Daha önceki yazımda bahsettiğim gibi ‘.fit’ ile modelimizi oluşturduk. ‘.intercept’ ve ‘.coef’ ile katsayılarımızı çıktı olarak aldık.
linear_regression = LinearRegression()
linear_regression.fit(X.values.reshape(-1,1),Y.values.reshape(-1,1))print(linear_regression.intercept_)
print(linear_regression.coef_)>>[0.01068662]
>>[[0.99645044]]
Regresyonun performansını kontrol etmek için ‘.predict’ komutu çağırıldı. R² elimizdeki bağımsız değişkenleri kullandığımızda bağımlı değişkendeki değişimin yüzde kaçını açıklayabiliyoruz bilgisini bize verir. Burada da bunu ‘r2_score’ ile bulduk. Yani bu model %89 oranında verilere uyum sağladı.
Y_predicted = linear_regression.predict(X.values.reshape(-1,1))
print(Y_predicted)
print(r2_score(Y, Y_predicted))print(“Ortalama Mutlak Hata: {} \nOrtalama Karesel Hata: {}”.format(mean_absolute_error(Y, Y_predicted), mean_squared_error(Y,Y_predicted)))>>0.8925664860893009
>>Ortalama Mutlak Hata: 0.07129002535015808
>>Ortalama Karesel Hata: 0.010529850298708456
Şimdi sıra tüm yaptıklarımızı regresyon grafiği üzerinde göstermeye geldi.
random_x = np.array([0, 0.5, 0.99])
plt.scatter(X.values, Y.values)
plt.plot(random_x, linear_regression.intercept_[0] + linear_regression.coef_[0][0] * random_x, color=’blue’, label=’regresyon grafiği’)
plt.xlabel(‘X’)
plt.ylabel(‘Y’)
plt.title(‘Maaş-Deneyim Regresyon Analizi’)Çıktımızın son hali aşağıdaki şekilde verilmiştir.
Polinom Regresyonu (Polynomial Regression)
Polinomsal regresyon basit lineer regresyona benzerdir. Fakat burada regresyon doğrusal bir şekilde ilerlemez. Bir doğru yerine eğriden (curve) oluşan bir regresyon söz konusudur. Kısacası değişkenler arasındaki ilişki doğrusal olmadığı durumlarda başvurulan bir yöntemdir.
Bu denklemde ‘h’ polinom derecesini ifade eder. Aşağıdaki şekilde farklı derecelere ait polinom regresyonu verilmiştir. Hata payını azaltmak için bu yönteme başvurulabilir.
Polinom regresyon için de Python kodu yazalım. İhtiyacımız olan kütüphaneleri ekledik.
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegressionVeri dosyasını okuduktan sonra bağımlı ve bağımsız değişkenlerimizi belirliyoruz.
df = pd.read_csv(“polinom.csv”)
X = df.iloc[:, 1:2].values
Y = df.iloc[:, 2].valuesKarşılaştırma yapmak için önce lineer regresyon kodumuzu yazdık.
lineer_reg = LinearRegression()
lineer_reg.fit(X.reshape(-1,1),Y.reshape(-1,1))Şimdi polinom regresyon fonksiyonunu çağırabiliriz. ‘.fit()’ ile değişkenlerimizi modelimize tanıttık. Polinomumuzun derecesini 2 olarak belirledik. Bu nesnenin işi orijinal tek sütunlu X nitelikler matrisini alıp nesnenin fit_transform() metoduyla yeniden biçimlendirmek. Biçimlendirilmiş yeni nitelikler matrisini X_poly adlı değişkene atıyoruz.
poly_reg = PolynomialFeatures(degree = 2)
X_poly = poly_reg.fit_transform(X)poly_reg.fit(X_poly, Y)
lineer_reg_2 = LinearRegression()
lineer_reg_2.fit(X_poly, Y)
Yaptıklarımızı grafik haline dökmek için gerekli kodlarımızı yazalım. Burada basit lineer regresyonu çizdik.
plt.scatter(X, Y, color = ‘blue’)
plt.plot(X, lineer_reg.predict(X), color = ‘blue’)
plt.title(‘Pozisyon-Maaş Lineer Regresyon’)
plt.xlabel(‘Pozisyon’)
plt.ylabel(‘Maaş’)
plt.show()Aşağıdaki şekilde basit lineer regresyonumuz bulunmaktadır. Görüldüğü gibi hata payı yüksek görünmektedir. Lineer regresyon yetersiz kalmaktadır.
Polinom regresyon ile çizmek için ise aşağıdaki kodları uyguladık.
plt.scatter(X, Y, color = ‘blue’)
plt.plot(X, lineer_reg_2.predict(poly_reg.fit_transform(X)), color = ‘blue’)
plt.title(‘Pozisyon Maaş Polinom Regresyon’)
plt.xlabel(‘Pozisyon’)
plt.ylabel(‘Maaş’)
plt.show()Derecesi iki olan polinom regresyonunun çıktısı aşağıdaki şekilde verilmiştir.
Lineer regresyona göre daha iyi sonuç alındığı söylenebilir. Bir de derecesi 4 olan polinom regresyonuna bakalım.
Bu regresyonun bu durum için daha uygun olduğu görülmektedir. Regresyonumuzun tahmin çıktılarını almak istersek ‘.predict’ komutunu çağırabiliriz. Burada 5.3'üncü seviyede birinin maaş tahiminini yapmasını istedik. İlk tahmini lineer regresyon ile ikinci tahmini polinom regresyon ile yaptık. Aldığımız çıktılar da verilmiştir. Veri incelenirse polinom regresyonun bu duruma daha yakın olduğu görülür.
lineertahmin = lineer_reg.predict([[5.3]])
polinomtahmin= lineer_reg_2.predict(poly_reg.fit_transform([[6.7]]))>>[[346554.54545455]]
>>[167442.36756993]
Lojistik Regresyon (Logistic Regression)
Lojistik Regresyon her ne kadar bir regresyon çeşidi de olsa, sınıflandırma işlemi için kullanılır. Kategorik ya da sayısal veriler bu regresyonla sınıflandırılabilir. Burada bağımlı değişken (sonuç) sadece iki farklı değer alabilir (Doğru/Yanlış, Evet/Hayır…). Örneğin; bir e-mail’in spam (1) veya spam olmadığını (0) tahmin etmek için kullanılabilir. Aşağıdaki şekilde hem basit lineer regresyon hem de lojistik regresyon verilmiştir. Lojistik regresyonda benzer olarak düzlem üzerinde verileri yakalamaya çalışır ama farklı olarak görüldüğü üzere doğrusal değildir. Kendi formülü gereği logaritmik bir eğri üzerinde verileri yakalar. Bu da inişli çıkışlı verilerde daha yüksek tahmin başarısı sağlamaktadır.
Lojistik regresyonun Python kodlarına geçersek, önce kütüphanelerimizi ekledik.
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
from matplotlib.colors import ListedColormapVeri dosyamızı okuduktan sonra bağımlı ve bağımsız değişkenlerimizi belirledik.
df = pd.read_csv(‘logistic.csv’)
X = df.iloc[:, [2,3]].values
Y = df.iloc[:, 4].valuesVeri setinde 400 kayıt var bunun 300’ünü eğitim, 100’ünü test için ayırdık.
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.25, random_state = 0)Bağımsız değişkenlerden yaş ile tahmini gelir aynı birimde olmadığı için feature scaling uyguladık.
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)Şimdi lojistik regresyon fonksiyonumuzu çağırabiliriz.
log = LogisticRegression(random_state = 0)
log.fit(X_train, Y_train)Hata matrisi (confusion matrix) oluşturduk. Hata matrisinde aldığımız çıktılar bize 65 ve 24 doğru olduğunu; 3 ve 8 yanlış sınıflandırma olduğunu gösterdi. Yani 89 doğru 11 yanlışımız var. 100 tanesini bu kısım için ayırmıştık.
Y_pred = log.predict(X_test)
cm = confusion_matrix(Y_test, Y_pred)
print(cm)>>[[65 3]
[ 8 24]]
Eğitim için ayırdığımız kısım için grafiğimizi çizmek istersek bu kısmı kullanırız. ‘np.meshfrid()’ ile grafiğin sınırlarını ve çözünürlüğünü ayarladık. ‘plt.contourf()’ ile 0 değeri alanlar sarı, 1 değeri alanları yeşil nokta ile gösterdik. Döngü ile tüm y değerlerini dolaşıp nereye konumlanacağını (plt.scatter()) saçılma diyagramı ile çizdik. ‘plt.legend()’ ile sağ üst köşedeki bilgi kutucuğunu yazdırdık.
X_set, Y_set = X_train, Y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() — 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() — 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, log.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap((‘blue’, ‘green’)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_set)):
plt.scatter(X_set[Y_set == j, 0], X_set[Y_set == j, 1],
c = ListedColormap((‘yellow’, ‘green’))(i), label = j)
plt.title(‘Lojistik Regresyon (Eğitim seti)’)
plt.xlabel(‘Yaş’)
plt.ylabel(‘Maaş’)
plt.legend()
plt.show()Buraya kadar olan kısmın çıktısına bakacak olursak; sarı noktalar satın almayan müşterileri (0), yeşil noktalar ise satın alan müşterileri (1) temsil ediyor. Yaşı büyük ve geliri yüksek insanlar satın alma işlemini yapmış görünüyor. Lojistik regresyon çizgisi bunu güzel bir şekilde ayırıyor.
Şimdi bir de test setimiz için grafiğimizi çizelim.
X_set, Y_set = X_test, Y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() — 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() — 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, log.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap((‘blue’, ‘green’)))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_set)):
plt.scatter(X_set[Y_set == j, 0], X_set[Y_set == j, 1],
c = ListedColormap((‘yellow’, ‘green’))(i), label = j)
plt.title(‘Lojistik Regresyon (Test seti)’)
plt.xlabel(‘Yaş’)
plt.ylabel(‘Maaş’)
plt.legend()
plt.show()Hata matrisinde 11 yanlışın olduğunu görmüştük. Aşağıdaki grafikte de eğer noktaları sayarsak 11 yanlışın olduğunu görebiliriz.
Ridge Regresyonu (Ridge Regression)
Ridge regresyonu çok değişkenli verileri analiz etmede kullanılır. Amaç hata kareler toplamını minimize eden katsayıları, bu katsayılara bir ceza uygulayarak bulmaktır. Over-fittinge karşı dirençlidir. Çok boyutluluğa çözüm sunar. Tüm değişkenler ile model kurar, ilgisiz değişkenleri çıkarmaz sadece katsayılarını sıfıra yaklaştırır. Modeli kurarken alpha (ceza) için iyi bir değer bulmak gerekir [1]. Yani modeli tekrar tekrar çalıştırdığımızda farklı katsayılar elde edeceğiz. Gerçek değere en yakın bulma işlemini ridge regresyonu ile sağlıyoruz.
Python ile ridge regresyonunu yazalım. Gerekli olan kütüphanelerimizi ekledikten sonra başlayabiliriz.
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge, RidgeCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_errorVeri dosyamızı okuttuktan sonra verimizde bir eksik var mı kontrol ediyoruz. Salary kısmında 59 tane boşluk olduğunu tespit ettik. Bunun üzerine ‘.fillna()’ kullanarak ortalamasını alarak boşlukları dolduruyoruz. ‘inplace=True’ komutu bu değişikliğin kalıcı olmasını sağlıyor.
df = pd.read_csv(“Hitters.csv”)
print(df.head())
print(df.isnull().sum())
df.fillna(df[“Salary”].mean(), inplace=True)Kategorik değişkenleri numerik değişkenlere çevirmemiz gerekiyor. ‘.get_dummies()’ bunu bize sağlıyor.
dms = pd.get_dummies(df[[“NewLeague”,”League”,”Division”]], prefix_sep=”_”)
X_ = df.drop([“NewLeague”,”League”,”Division”,”Salary”], axis=1).astype(“float64”)
print(dms.head())
print(X_.head())
X = pd.concat([X_, dms[["NewLeague_A", "League_A", "Division_E"]]], axis=1)
y = df["Salary"]
X.head()Artık veriyi test ve eğitim kısmı olarak ayırabiliriz. Test_size verilerin yüzde kaçını test için kullanılacağını belirtir. Verileri normalize etmek için StandartScaler kullandık. Verilerin ortalaması 0, standart sapması 1 olacak şekilde dönüştürdü.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Şimdi sıra ridge fonksiyonunu çağırmaya geldi. Direkt olarak X_train ve y_train ile modelimizi eğittik. Bunun sonucunda aldığımız hata değeri (alpha) 331.527 oldu. Ardından RidgeCV ile cross validation işlemi uyguladık. Bu işlem veri seti için en uygun parametreleri elde etmemizi sağlıyor. Bunları tamamladıktan sonra yeni bir model kurarak modeli tekrar eğitiyoruz. Buradan aldığımız hata değeri (alpha) 331.299 oldu.
ridge = Ridge().fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, ridge.predict(X_test))))
alphas = 10**np.linspace(10,-2,100)*0.5
ridge_cv = RidgeCV(alphas=alphas, cv = 5, scoring=”neg_mean_absolute_error”,normalize=True).fit(X_train, y_train)
ridge_tuned = Ridge(alpha=ridge_cv.alpha_).fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, ridge_tuned.predict(X_test))))Lasso Regresyon (Lasso Regression)
Lasso (Least Absolute Shrinkage and Selection Operator) Ridge regresyonuna benzer. En temek fark Ridge L2 penalty kullanırken, Lasso L1 penalty kullanmaktadır. Yani ridge katsayıların karesini alırken lasso katsayıların mutlak değerini alır. Lasso regresyonu sadece aşırı öğrenmeyi azaltmak için değil aynı zamanda öznitelik seçimi (feature selection) konusunda da önemli bir rol oynar.
Python koduna geçecek olursak Ridge regresyonunda yaptığımız işlemlerin aynısını uyguluyoruz. Sadece ek olarak birkaç kütüphane eklememiz gerekiyor.
from sklearn.linear_model import Lasso, LassoCVBu kütüphaneyi ekleyip devamındaki işlemleri uyguluyoruz. Ardından lasso regresyonumuzu çağırıyoruz. İlk elde ettiğimiz hata değeri (alpha) 331.238 oldu. En iyi parametreyi elde etmek için ise LassoCV uyguladık. Bunun sonucundaki hata değeri ise 331.135 oldu.
lasso = Lasso().fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, lasso.predict(X_test))))
lasso_cv = LassoCV(alphas=None, cv=10, max_iter=10000, normalize=True).fit(X_train, y_train)
lasso_tuned = Lasso(alpha=lasso_cv.alpha_).fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, lasso_tuned.predict(X_test))))Elastic Net Regresyon (Elastic Net Regression)
Burada da amaç Lasso ve Ridge ile aynıdır. Farkı bu iki regresyonu birleştirmesidir. Ridge’den cezalandırma, Lasso’dan değişken seçimi yapar.
Kodlamasında ise yine bir kütüphane eklenerek yukarıdaki işlemler uygulanır.
from sklearn.linear_model import ElasticNet, ElasticNetCVArdından elastic net regresyonunu çağırabiliriz. İlk elde edilen hata değeri (alpha) 356.537 oldu. ElasticNetCV uygulandığında hata değeri (alpha) 353.737 oldu.
enet = ElasticNet().fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, enet.predict(X_test))))
enet_cv = ElasticNetCV(cv = 10, random_state=1).fit(X_train, y_train)
enet_tuned = ElasticNet(alpha=enet_cv.alpha_).fit(X_train, y_train)
print(np.sqrt(mean_squared_error(y_test, enet_tuned.predict(X_test))))Şimdilik yazımız burada bitti. Sonraki yazılarda görüşmek üzere :).
