Bir Bakışta Yapay Sinir Ağları 4: Kayıp İşlevleri

Nöronal ağlar birçok AI ve Genai uygulamasının motorudur. Bu makale dizisi bireysel unsurlar hakkında bir fikir sunar. Serinin dördüncü kısmı en yaygın kayıp fonksiyonlarını tanıtır, gradyanlarını türetir ve bu nedenle temel gradyan inişinin ve en karmaşık varyantlarının kontrol kuralının nasıl geliştirileceğini gösterir.

Bir sinir ağı yararlı görevleri öğretmek için, tahminlerinin hedef değerlere ne kadar iyi karşılık geldiğini ölçmeliyiz. Kayıp fonksiyonu, ağ parametrelerini uyarlayarak eğitim sürecinin minimumda olması gereken hatanın skaler bir ölçüsüdür.

Regresyon için ortalama kare hatası

Ağın aktivitesi sürekli boyutları tahmin etmekse, orta boy kare hata bariz bir seçimdir. Diyelim ki N örnekleri içeren bir veri kaydımız var, her bir örnek Yᵢ hedef değerine sahip olduğum ve ağ bir tahmin sağlıyor. Ortalama kare hatası L tarafından tanımlanır

L (ŷ, y) = (1/n) σᵢ (ᵢ – yᵢ) ²

Bu ifade, tüm örneklerde tahmin ve hedef değer arasındaki kare farklılıkları ekler ve ortalamayı korumak için N için bunları ayırır. Hatayı gıcırdatın, büyük sapmalar küçüklerden daha fazla cezalandırılır ve ortalama, veri kaydının boyutuna bakılmaksızın kaybı yapar.

Bu kaybın parametrelerin güncellemelerini nasıl etkilediğini görmek için, türevini tek bir ⱼ tahminine göre hesaplıyoruz:

∂l/ⱼ = (2/n) (ⱼ – yⱼ)

Arka yayılma sırasında, bu gradyan ağdan iletilir ve kare hatayı azaltma yönünde herhangi bir ağırlık güncellemesini kontrol eder.

Pytorch yazın:

import torch
import torch.nn as nn

# Angenommen, `model` ordnet Eingaben den Vorhersagen ŷ der Form (batch_size, 1) zu
loss_fn = nn.MSELoss()  # erstellt ein Modul für den mittleren quadratischen Fehler
predictions = model(inputs)  # Vorwärtsdurchlauf erzeugt ŷ
loss = loss_fn(predictions, targets)

Kapaklar ve burada nn.MSELoss() Yukarıdaki formül. Daha sonra loss.backward() Çağrılarak, Pytorch, ∂L/∂ parametrelerini otomatik olarak hesaplar ve kısmi türevleri hesaplama tablosundan birleştirir.

Croce -neredeyse sınıflandırma

Etkinlik C sınıflarından birinde sınıflandırma ise, ağ genellikle her örnek için bir logit z ∈ ℝᶜ vektörünü harcar. Bu logitistleri bir PP dağılımına dönüştürmek için Softmax işlevini kullanıyoruz:

Softmax (z) ᵢ = exp (zᵢ) / σⱼ exp (zⱼ)

Örneğin, gerçek sınıfın adı, J ☎ i için yᵢ = 1 ve yⱼ = 0 ile bir vektör olarak kodlanırsa, enine centropy kaybı

L (z, y) = – σᵢ yᵢ · log (softmax (z) ᵢ)

Yalnızca bir y öğesi eşit derecede sıfır olmadığından, bu, doğru sınıfa atanan negatif mantıksal olasılığı basitleştirir. Pytorch kullanırken nn.CrossEntropyLoss Uygulama, Softmax'ın aşamalarını birleştirir ve sayısal olarak istikrarlı bir şekilde kaydolur ve ham logephit ve tüm sınıf endeksleri olması beklenir:

import torch.nn as nn

loss_fn = nn.CrossEntropyLoss() # erstellt einen kombinierten Log-Softmax + NLL-Verlust
logits = model(inputs) # Form (batch_size, num_classes)
loss = loss_fn(logits, class_indices)

Arka planda, her Zₖ logit ile ilişkili L degradi

∂l/∂zₖ = softmax (z) ₖ – yₖ,

Bu, beklenen olasılık ile her sınıf için gerçek harfler arasındaki farka tam olarak karşılık gelir.

Gradyanla temel iniş

Bir kayıp belirlenir belirlenmez, parametreler güncellemeleri için en kolay kural, gradyanın inişidir. Tek bir skaler parametreyi (tartım matrisinin veya polarizasyon taşıyıcısının bir öğesini) ve L (θ) ile θ'ye göre kayıp tanımlarsak. Degrade güncellemelerinin küme düşme kuralı θ dik inişe doğru:

θ ← θ – η · ∂l/∂θ

İşte η> 0, adımın boyutunu kontrol eden bir hiperparametre olan öğrenme oranı. Küçük bir değer η yavaş ama kararlı bir yakınsama yol açarken, büyük bir değer η dalgalanmaya veya sapmaya yol açabilir.

Uygulamada, üç varyant arasında bir ayrım yapılır: gradyan her güncellemeden önce tüm verilerin kaydında hesaplanırsa, parti gradyanının inişinden bahsediyoruz; Her güncelleme için sadece bir örnek kullanılırsa, stokastik gradyana inişten bahsediyoruz; Ve eğer küçük örnekler kullanılırsa (mini-badch), mini-bad gradyan inişinden bahsediyoruz. Mini-toplu güncellemeler, gürültülü ancak hızlı stokastik güncellemeler ile istikrarlı ancak pahalı toplu güncellemeler arasındaki bir uzlaşmayı temsil eder.

Pytorch paket üzerinden teklifler torch.optim Mini-badch ile gradyan iniş yapmanın kolay bir yolu. Örneğin, stokastik gradyanın momentumla basit inişini kullanmak için şunlar yazılır:

import torch.optim as optim

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# für Eingaben, Ziele in data_loader: data_loader liefert Mini-Batches
optimizer.zero_grad()  # alle akkumulierten Gradienten löschen
outputs = model(inputs)  # Vorwärtsdurchlauf
loss = loss_fn(outputs, targets)  # Verlust berechnen
loss.backward()  # Rückwärtspropagierung zur Berechnung der Gradienten
optimizer.step()  # Parameter an Ort und Stelle aktualisieren

Çağrı optimizer.zero_grad() Önceki yinelemelerin gradyanları birikmemesi için tüm parametrelerin gradyan arabelleğini ortadan kaldırır. Çağrı loss.backward() Özelliği doldurun .grad Hesaplanan ∂l/∂θ ee ile her bir parametre optimizer.step() Seçilen güncelleme kuralına göre parametreleri güncellemek için bu gradyanları kullanın.

Gelişmiş Optimize Ediciler: RMSProp ve Adam

Basit bir an, kayıp fonksiyonunun vadilerindeki yakınsamayı hızlandırabilirken, uyarlanabilir yöntemler, her bir parametrenin öğrenme oranını gradyanlarının geçmişine göre ayrı ayrı uyarlar. RMSPOP, geçmiş kare gradyanların toplam ağırlıklı ve akan ortalamasını korur:

Sₜ = γ · Sₜ₋₁ + (1 – γ) · Gₜ²

θ ← θ – (η / sqrt (sₜ + ε)) · gₜ

Burada gₜ = ∂l/∂θ şu anda t, γ genellikle 0.9'dur ve ε sayısal stabilite için küçük bir sabittir. Bu, Pytorch'ta aşağıdaki gibi inşa edilmiştir:

optimizer = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99, eps=1e-8)

Adam, hem mₜ gradyanının kayar ortalamasını hem de kare gradyanını vₜ olarak koruyarak momentumu ve rmsprop'u birleştirir: bir sapma düzeltmesi kullanır:

Mₜ = β₁ · mₜ₋₁ + (1 – β₁) · gₜ

Vₜ = βester · vₜ₋₁ + (1 – β) · gₜ²

M̂ₜ = mₜ / (1 – β₁ᵗ)

V̂ₜ = Vₜ / (1 – İlgilenen Yer)

θ ← θ – η · (m̂ₜ / (sqrt (v̂ₜ) + ε))

Β₁ = 0.9, βestro = 0.999 ve ε = 1e-8 değerleri ile.

Kodda:

optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-8)

Bu optimize edicilerin her biri, belirli bir sorun için en iyi performansı elde etmek için hiper parametrelerinin – öğrenme oranı, abonelik oranları ve epsilon – koordinasyonunu gerektirir.

Serinin bir sonraki kısmı, bu bileşenlerin tam bir eğitim döngüsünde nasıl bir araya getirildiğini göstermektedir. Ardından, genellemeyi iyileştirmek için terk ve kilo kaybı gibi açık minibatches ile ve açık minibatches ile eğitim arasındaki farkları inceleyin.

(RME)