Karşılaşacağınız kayıp işlevini (kod) makine öğrenimi "çukurlarını" anlamak için "Hafta Sonu Yapay Zeka Sınıfı"
Önceki bölümde, esas olarak vekil kaybın kökenini ve doğasını açıkladık ve makine öğreniminde kayıp fonksiyonu tanımının özünü anladık. Öncelikle regresyon görevleri için yaygın olarak kullanılan kayıp fonksiyonlarını özetleyelim:
- Ortalama Kare Hatası (MSE):
numpy'yi np olarak içe aktar
def MSE (doğru, önceden):
dönüş (true-pred) ** 2
- Mutlak hata (MAE):
numpy'yi np olarak içe aktar
def MAE (doğru, önceden):
dönüş np.abs (true-pred)
- Huber Kaybı:
numpy'yi np olarak içe aktar
def Huber (doğru, ön, e):
a = np.abs (true-pred)
dönüş np.array ()
Bunlar arasında, MSE ve MAE nispeten tanıdık ve basit kayıp fonksiyonlarıdır. MSE, tahmin edilen değer ile gerçek değer arasındaki farkı kareler. Bir aykırı değer oluştuğunda, karşılık gelen Kayıp büyütülecek, MAE ise yalnızca tahmin edilen değeri alır ve Gerçek değerin mutlak değeri. Başka bir deyişle, aykırı değerler, makul olmayan MSE'nin daha büyük bir oranını oluşturacaktır. Basit bir resim çizebiliriz:
...
a = np.linspace (-100,100)
sns.set (style = 'darkgrid')
plt.plot (a, MSE (0, a), 'r-')
plt.title ('MSE')
plt.show ()
...
...
plt.plot (a, MAE (0, a), 'r-')
...
Şekilden görüldüğü gibi 100 değeri olan aynı nokta için MSE Kaybı daha büyük olacaktır Genel Kaybı elde etmek için bunların hepsini topladığımızda, değerin gerçek değerden sapması ne kadar büyük olursa oran o kadar büyük olur.
...
a = np.linspace (0,100)
sns.set (style = 'darkgrid')
plt.plot (a, MSE (0, a) /np.sum (MSE (0, a)), 'r-')
plt.plot (a, MAE (0, a) /np.sum (MAE (0, a)), 'b-')
plt.title ('MAE oranı VS MSEretio')
plt.show ()
...
Gerçek değerden sapma derecesi arttıkça, anormal noktalardan kaynaklanan kayıp oranının da artacağı sezgisel olarak görülebilir.
Bu bakış açısından, MAE daha iyi bir kayıp fonksiyonu gibi görünüyor, böylece nihai sonuç aykırı değerlere doğru önyargılı olmayacak, ancak MAE'nin türevi bir sabittir, böylece gradyan her güncellendiğinde, aynı uzunlukta düşecektir, bu da bizi garanti etmez Tatmin edici sonuçlar alın. Huber Kaybı karmaşık görünse de, aslında MSE ve MAE arasında bir uzlaşmadır, çünkü bir parametre tanımlar. Bu parametrenin ana işlevi, bir veri noktasının aykırı değer olup olmadığına karar vermektir. Öngörülen değerimiz gerçek değerden uzak olduğunda Uzakta MSE kullanıyoruz, yoksa MAE kullanıyoruz Hedefin gerildiği boşluktaki şeklini görmek için parametreleri ayarlamaya çalışıyoruz:
...
için ben içinde :
plt.plot (a, Huber (0, a, i))
plt.title ('Huber Kaybı')
plt.show ()
Şekilde gösterildiği gibi, huber kaybının giderek MSE'ye benzediğini görebiliriz, bunun nedeni parametre ne kadar büyükse, daha az ve daha az anormal nokta olduğu anlamına gelir.
Aynı zamanda, huber kaybının sapması ne kadar büyükse, oranın ikisi arasında olmasını bekleyebiliriz:
plt.plot (a, Huber (0, a, 30) /np.sum (Huber (0, a, 30)), 'g -', etiket = 'Huber')
Huber kaybı anormal noktalara uyum sağlayabildiğinden, anormal noktalar içeren bir veri oluşturuyoruz, model olarak basit doğrusal regresyon kullanıyoruz ve bulduğu doğrusal regresyon modellerindeki farklılıkları gözlemlemek için farklı kayıp fonksiyonları kullanıyoruz. İlk olarak, anormal noktalar içeren verileri oluşturuyoruz:
numpy'yi np olarak içe aktar
sklearn.datasets'den make_regression içe aktar
rng = np.random.RandomState (0)
X, y = make_regression (n_samples = 50, n_features = 1, random_state = 0, noise = 4.0,
önyargı = 100.0)
sns.set (style = 'darkgrid')
X_outliers = rng.normal (0, 0.5, boyut = (4, 1))
y_outliers = rng.normal (0, 2.0, boyut = 4)
X_outliers + = X.max () + X.ortalama () / 4.
X_outliers + = X.min () - X.ortalama () / 4.
y_outliers + = y.min () - y.ortalama () / 4.
y_outliers + = y.max () + y.ortalama () / 4.
X = np.vstack ((X, X_outliers))
y = np.concatenate ((y, y_outliers))
plt.plot (X, y, "k.")
plt.show ()
Şekilde gösterildiği gibi, ortadaki örnek noktasının neredeyse tamamen doğrusal olduğunu açıkça görebiliyoruz, ancak sol üst ve sağ altta bazı anormal noktalar var.
Örnek uzayındaki sonuçları gözlemlemek için sıradan en küçük karelerin (MSE) kaybını, sırt regresyonunun kaybını (MSE +) ve huber kaybını oluşturuyoruz:
sklearn.linear_model'den ithal HuberRegressor, Ridge
sklearn.linear_model'den içe aktarma LinearRegression
x = np.linspace (X.min (), X.max (), 100)
huber = HuberRegressor (fit_intercept = True, alpha = 0.0, max_iter = 100, epsilon = 1.5)
huber.fit (X, y)
coef_ = huber.coef_ * x + huber.intercept_
plt.plot (x, coef _, 'r -', label = "huber kaybı,% s"% 1.5)
ridge = Ridge (fit_intercept = True, alpha = 3, random_state = 0, normalize = True)
ridge.fit (X, y)
coef_ridge = ridge.coef_
coef_ = ridge.coef_ * x + ridge.intercept_
plt.plot (x, katsayı _, 'g-', etiket = "sırt gerilemesi")
ols = LinearRegression (fit_intercept = True, normalize = True)
ols.fit (X, y)
coef_ols = ols.coef_
coef_ = ols.coef_ * x + ols.intercept_
plt.plot (x, katsayı _, 'b-', etiket = "doğrusal regresyon")
plt.title ("HuberRegressor ile Ridge'in Karşılaştırması")
plt.xlabel ("X")
plt.ylabel ("y")
plt.legend ()
plt.show ()
Şekilde gösterildiği gibi, hem OLS hem de Ridge regresyonu, anormal noktalardan değişen derecelerde etkilenirken, huber kaybı hiçbir şekilde etkilenmez.
Bu resme bakarsak, huber kaybının ne kadar güçlü olduğunu hissetmeyeceğiz çünkü OLS ve Ridge regresyonu arasındaki sapma çok büyük değil. Bunun nedeninin büyük bir kısmı, anormal noktaların sapmasının çok büyük olmaması veya normal noktaların oranının hala nispeten büyük olmasıdır, daha sonra normal nokta sayısını azaltırız:
X, y = make_regression (n_samples = 15, n_features = 1, random_state = 0, noise = 4.0,
önyargı = 100.0)
Şekilde gösterildiği gibi, normal noktanın oranı ne kadar küçükse, sıradan Kayıp uyum sağlayamaz ve belirlediği regresyon denkleminin neredeyse hiç tahmin etme yeteneği yoktur.
Sınıflandırma problemleriyle karşılaştığımızda, etkiyi daha iyi hale getirmek için farklı kayıp fonksiyonları da seçebilir miyiz? Sınıflandırma görevlerinde genellikle şunları kullanırız:
- Negatif günlük kaybı:
def cross_entropy (tahminler, hedefler, epsilon = 1e-10):
tahminler = np.clip (tahminler, epsilon, 1. - epsilon)
N = tahminler.shape
ce_loss = -np.sum (np.sum (hedefler * np.log (tahminler + 1e-5))) / N
dönüş ce_loss
- menteşe:
def menteşe (y, f):
dönüş maks (1-y * f)
Doğrusal SVM ve lojistik regresyona karşılık gelen sırasıyla bu iki Kayıp türünü seçiyoruz ve ardından IRIS verilerindeki karar sınırının değişimini gözlemlemek için stokastik gradyan iniş algoritmasını kullanıyoruz:
numpy'yi np olarak içe aktar
matplotlib.pyplot dosyasını plt olarak içe aktar
sklearn ithal veri kümelerinden
sklearn.linear_model'den ithal SGDClassifier
iris = veri kümeleri.load_iris ()
X = iris.data
y = iris.target
renkler = "bry"
idx = np.arange (X.shape)
np.random.seed (13)
np.random.shuffle (idx)
X = X
y = y
ortalama = X.ortalama (eksen = 0)
std = X.std (eksen = 0)
X = (X-ortalama) / std
h = .02
clf = SGDC sınıflandırıcı (kayıp = 'log', alfa = 0.01, maks_iter = 100) .fit (X, y)
x_min, x_max = X.min () -1, X.max () +1
y_min, y_max = X.min () -1, X.max () +1
xx, yy = np.meshgrid (np.arange (x_min, x_max, h),
np.arange (y_min, y_max, h))
Z = clf.predict (np.c_)
Z = Z.reshape (xx.shape)
cs = plt.contourf (xx, yy, Z, cmap = plt.cm.RdBu, alpha = 0.6)
plt.axis ('sıkı')
için ben, renk içinde zip (clf.classes_, renkler):
idx = np.where (y == i)
plt.scatter (X, X, c = renk, etiket = iris.target_names ,
cmap = plt.cm.RdBu, edgecolor = 'siyah', s = 20, edgecolors = 'k')
plt.title ("Günlük Kaybının Karar yüzeyi")
plt.axis ('sıkı')
plt.show ()
Benzer şekilde menteşe kaybını da çizebiliriz:
clf = SGDC sınıflandırıcı (kayıp = 'menteşe', alfa = 0.01, maks_iter = 100) .fit (X, y)
Şekilden hangi kaybın daha iyi olduğunu söyleyemeyiz.Bir yandan bu kadar basit veriler için kayıp önemli bir rol oynamayabilirken, diğer yandan test setinin genelleme hatasını gözlemlememiz gerekiyor, sadece iki tane var. Her özelliğin oluşturduğu alan.
Buraya L2 regülasyonunu eklediğimize dikkat edin.Ayrıca, yapısal risk kalemimiz olarak L1 regülasyonunu ve elastik ağı (iki tip regülasyonu birleştirerek) serbestçe ekleyebiliriz. Kısacası, yenileme kayıp yapısında, kendi verilerimize ve görevlerimize göre daha esnek bir kayıp fonksiyonu tasarlayabilmemiz için makul olan süreklilik ve tutarlılığa (dışbükey fonksiyon gerekli değildir) sahip olmamız yeterlidir.
MSE, MAE ve huber kaybına ek olarak, regresyon görevlerinde, ikinci türevin varlığını sağlayabilen log-cosh kaybını da kullanacağız.Bazı optimizasyon algoritmaları ikinci türevi kullanır.Xgboost'ta, ikinci türevi de kullanmamız gerekir. Sipariş türevi; aynı zamanda belirsiz bir ölçü vermeyi umarak nicelik kaybı da kullanacağız.
Log ve menteşeye ek olarak, sınıflandırma görevlerinde genellikle sinir ağlarında kullanılan kontrast kaybı, softmax çapraz entropi kaybı ve merkez kaybı gibi kayıp fonksiyonlarına da sahibiz.
Kayıp fonksiyonunun çeşitliliğinin arkasında, aslında Stokastik Gradyan İniş (SGD) adı verilen bir optimizasyon algoritmaları sınıfı tarafından desteklenmektedir Stokastik Gradyan İnişinin üstünlüğü hiçbir şekilde zaman verimliliğini azaltmak değil, makine öğreniminin en büyük yeniliklerinden biridir. Sonraki bölümde SGD tarafından temsil edilen optimizasyon algoritmasını tanıtacağız.
Ortalama kare hatası (MSE): Regresyon problemlerinde en sık kullanılan kayıp fonksiyonudur.
