Gradyan İnişini Anlama (2) (Kod Yazısı) Makine öğreniminde karşılaşacağınız "çukurlar"
Bugün Milli Bayram tatilinden önceki son gün. Bu dersi ciddiye alın ve ardından güzel bir tatili kucaklayın ~~
Öğrenme hızının optimizasyon algoritması üzerindeki etkisini önceki bölümde "Gradyan İniş (1) Kodunu Anlamak" bölümünde görmüştük.Aynı zamanda, Newton yönteminin sınırlamalarını da kısaca tartıştık ve düzenli hale getirilmiş Newton yöntemini tanıttık. Yanlış yönde güncelleme, ancak kayıp fonksiyonumuz yalnızca tek boyutludur ve optimize edilmiş yön yalnızca sabit bir yönde olabilir, ancak yüksek boyutlu bir uzayda, gradyan inişi, kötü koşullu Hessian ve mantıksız başlangıç değeri nedeniyle yinelenecektir. Güncellemeler, sıradan gradyan inişinde yaygın bir sorun olan kontur etrafında gezinirken boşa gider.
Stokastik gradyan inişini burada göstermeyeceğiz. Stokastik gradyan inişi önemli olsa da, Loss fonksiyonumuza girmek için ek verilere ihtiyacı var. Esas olarak burada program örnekleri yapacağız.Önceki bölüme devam edeceğiz ve Loss fonksiyonunu doğrudan bir parametre olarak kullanacağız. işlevi. Önce basit bir Kayıp oluşturalım:
Şu anda kayıp, çanak şeklindeki tipik bir yapıdır ve işlevin ilgili kodu aşağıdaki gibi kolayca yazılabilir:
def f (x, y):
dönüş x ** 2 + y ** 2
def kısmi_x (x):
dönüş 2 kere
def kısmi_y (y):
dönüş 2 * y
Aynı zamanda, parametre uzayının gradyanı iki boyutlu bir uzayda bir vektör haline gelecektir ve gradyan güncelleme kodu şu şekilde yazılmalıdır:
def GD (lr, başlangıç):
x, y = başlangıç, başlangıç
GD_x, GD_y, GD_z = ,,
için o içinde aralığı (100):
GD_x.append (x)
GD_y.append (y)
GD_z.append (f (x, y))
dx = kısmi_x (x)
dy = kısmi_y (y)
x = x-lr * dx
y = y-lr * dy
dönüş GD_x, GD_y, GD_z
Burada, kaybın değerini kaydediyorum.Bu kayıt, parametre uzayının görselleştirilmesi için gerekli değildir, ancak yakınsama oranına ilişkin sonraki çalışmamız için gereklidir.Daha da önemlisi, pratikte çoğu zaman kesin değeri bilemeyiz. En iyi parametre noktası, eğitim sürecinin tamamlanıp tamamlanmadığını belirlemek için kaybın değiştirilmesini gerektirir.
Halen önceki bölümün temel çerçevesine devam ediyoruz Ulusal Günü kutlamak için renk haritasını daha coşkulu, kısıtlamasız ve tutkulu olan sıcak olarak seçtik:
numpy'yi np olarak içe aktar
matplotlib.pyplot dosyasını plt olarak içe aktar
matplotlib'den içe aktarma animasyonu
matplotlib.cm'yi cm olarak içe aktar
matplotlib.animation'dan import FuncAnimation
seaborn'u sns olarak ithal etmek
sns.set (stil = 'beyaz')
FFwriter = animation.FFMpegWriter ()
incir, balta = plt.subplots ()
fig.set_tight_layout (Doğru)
def f (x, y):
dönüş x ** 2 + y ** 2
def kısmi_x (x):
dönüş 2 kere
def kısmi_y (y):
dönüş 2 * y
a = np.linspace (-20,20,100)
b = np.linspace (-20,20,100)
A, B = np. Izgara (a, b)
ax.contourf (A, B, f (A, B), 50, alpha = 0.8, cmap = cm.hot) # Son parametre colormap
def GD (lr, başlangıç):
x, y = başlangıç, başlangıç
GD_x, GD_y, GD_z = ,,
için o içinde aralığı (100):
GD_x.append (x)
GD_y.append (y)
GD_z.append (f (x, y))
dx = kısmi_x (x)
dy = kısmi_y (y)
x = x-lr * dx
y = y-lr * dy
dönüş (GD_x, GD_y, GD_z)
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, başlangıç =)
print ('incir boyutu: {0} DPI, inç cinsinden boyut {1}'. biçimi (
fig.get_dpi (), fig.get_size_inches ()))
point_line, = ax.plot (GD_x, GD_y, 'veya')
def güncelleme (i):
label = 'timestep {0}'. format (i)
baskı etiketi)
point_line.set_xdata (GD_x )
point_line.set_ydata (GD_y )
ax.set_xlabel (etiket)
dönüş point_line, axe
Eğer __name__ == '__ main__':
anim = FuncAnimation (şekil, güncelleme, çerçeveler = np.arange (0, 15), aralık = 200)
plt.show ()
Şekilde gösterildiği gibi, iki boyutlu bir parametre uzayında bir gradyan iniş optimizasyon algoritması uyguladık.Renk ne kadar koyu olursa, Kayıp değeri o kadar düşük.Öğrenme oranı ayarı önceki bölümdeki deneyimimizi kullanır.
Teoriye dayalı basit bir momentum algoritması uygulayabiliriz:
def Momentum (lr, a, başlangıç):
xy = başlangıç
v = np.array ()
M_xy, M_z =,
için o içinde aralığı (100):
M_xy.append (xy)
M_z.append (f (xy, xy))
v = a * v-
xy = xy + v
dönüş (M_xy, M_z)
Bu kodu yazdığımda, değişkenleri bölmediğimi, ancak onları doğrudan diziler olarak ele aldığımı unutmayın.Genel olarak, parametreleri yüksek boyutlu parametre uzayında vektörler olarak ele almanız ve parametreleri güncellerken diziyi doğrudan ekleyip çıkarmanız önerilir. , Animasyonun ilgili parametrelerinde ince ayar yapıyoruz, kare sayısını 50'ye ayarlıyoruz ve şunları elde edebilirsiniz:
Şekilde gösterildiği gibi, momentum algoritması altındaki parametrelerin yinelemeli güncellemesi daha çok Newton mekaniği altındaki parçacıklara benzer, kase şeklindeki bir alanda mutlu bir şekilde sürüklenir, ancak momentum algoritmasının momentumunun gradyan inişi, gradyan inişi ile aynı olmayacağına dikkat edilmelidir. Simetrik salınımlar üretilecek, momentum algoritması ise salınımları sönümleyecek ve genlik gitgide küçülecektir.
Daha küçük hale getirmek için hiperparametresini a ayarlayabiliriz, çünkü teorik analize göre adım boyutu şöyle olacaktır:
A ne kadar küçükse, ivme o kadar küçük ve uç değerde kararlı olma olasılığı o kadar yüksektir. A'yı 0,9'dan 0,4'e değiştiriyoruz:
M_xy, M_z = Momentum (lr = us (2, -7) * 16, a = 0.4, başlangıç =)
Şekilde görüldüğü gibi, momentum algoritması saf gradyan inişinden çok daha hızlıdır.Tabii ki daha da önemlisi adım boyutu büyük olsa bile saf gradyan inişi gibi simetrik salınımlar üretmeyecektir.
Ardından, alan sınırlamaları nedeniyle AdaGrad algoritmasını atlıyor ve doğrudan RMSProp algoritmasını oluşturuyoruz:
def RMSProp (lr, d, ro, start):
xy = başlangıç
r = np.array ()
RMS_xy, RMS_z =,
için o içinde aralığı (100):
RMS_xy.append (xy)
RMS_z.append (f (xy, xy))
g = np.array ()
r = ro * r + (1-ro) * g * g
xy = xy-lr / (d + np.sqrt (r)) * g
dönüş (RMS_xy, RMS_z)
Başlangıç noktamızın yüksek bir eğime sahip olduğunu ve RMSProp'un öğrenme hızına uyum sağlayabileceğini unutmayın.RMSProp'un ilk başta yavaş olması beklenebilir, ancak öğrenme oranı hakkında çok fazla endişelenmeden ilk öğrenme oranını artırabiliriz. Gao'nun gradyan inişi sırasında zayıf performansının sonuçları:
GD_xy, GD_z = RMSProp (lr = pow (2, -2) * 16, d = 1e-6, ro = 0.9, start =)
Şekilde gösterildiği gibi, RMSProp hedef noktaya daha hızlı ulaşır, ancak çok büyük öğrenme hızının yine de salınımlara neden olacağı ve küçük gradyanların yakınında bir artış ve büyük gradyanların yakınında bir azalma olacağı vurgulanmalıdır. Her durumda, hala ilk öğrenme oranını belirleme problemiyle karşı karşıyayız, ancak uyarlanabilir öğrenme hızı algoritması, saf gradyan inişinden çok daha akıllı.
Öğrenme oranının başlangıç değerine ek olarak, parametrenin başlangıç değeri de çok önemlidir. Biraz daha karmaşık bir duruma bakalım. Kayıp işlevi şu şekilde tanımlanır:
(0, 0) noktasının tam olarak bir eyer noktası olduğunu bulabiliriz. Benzer şekilde, kodumuz şu şekilde değiştirilir:
def f (x, y):
dönüş x ** 2-y ** 2
def kısmi_x (x, y):
dönüş 2 kere
def kısmi_y (y, x):
dönüş -2 * y
Yukarıdaki adımları tekrarlamak için gradyan iniş algoritmasını kullanarak, parametrenin başlangıç değerinin büyük bir etkisi olacağını bulacağız:
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, başlangıç =)
Şekilde gösterildiği gibi, parametrenin başlangıç değerini olarak belirledik ve bunun eyer noktasına yakın kaldığını bulduk, bu açıkçası iyi bir optimizasyon değil.
Parametrenin başlangıç değerini sadece biraz hareket ettiriyoruz:
GD_x, GD_y, GD_z = GD (lr = pow (2, -7) * 16, başlangıç =)
Şekilde gösterildiği gibi, eyer noktasından kaçmak ve optimize etmeye devam etmek için parametrelerin başlangıç değerlerini sadece biraz hareket ettiriyoruz.Bu nedenle, gradyan inişi için eyer noktası mühendislikte zor bir problem değil, Newton'un yöntemi gibi ikinci dereceden bir optimizasyon algoritması için , Eğimin sıfır olduğu sıfır sınır değerini aradığınızı, eyer noktasının ölümcül olduğunu varsayalım.
Adam algoritması ve AdaGrad algoritması burada gösterilmemiştir.Okuyucunun kendi tasarlaması için bırakılmıştır.Bu optimizasyon algoritmalarında gerçekten ustalaşıyorsanız, kod sadece birkaç parametre eklemekten ibarettir.
Bu makalede kullanılan Kayıp işlevi, momentum algoritmasının ve RMSProp algoritmasının tam gücünü tam olarak yansıtmak için çok basittir.Aslında, Hessian kötü koşullu bir durum numarasına ve stokastik gradyan inişine sahip olduğunda, bunların avantajı, tahmini gradyan varyansının büyük olmasıdır. Bu optimizasyon algoritmalarının derin öğrenmede yaygın olarak kullanılacağı son derece açıktır ve güçlerini sonraki derslerde göreceğiz (esas olarak derin öğrenmenin Kayıp işlevi yeterince karmaşık ve bu algoritmaların avantajları yeterince açık olduğu için).
