Bir Bakışta Yapay Sinir Ağları 5: Eğitim Döngüsü ve Toplama

Nöronal ağlar birçok AI ve Genai uygulamasının motorudur. Bu makale dizisi bireysel unsurlar hakkında bir fikir sunar. İlk bölüm yapay nöronu sunar. Serinin beşinci kısmı eksiksiz bir eğitim döngüsü yaratır, açık mini parti ile ve mini parti ile eğitim arasındaki farkları gösterir ve son olarak genellemeyi iyileştirmek için terk ve kilo kaybı gibi teknikler sunar.

Bir ağı öğretmek, kaybını en aza indirmek için verileri tekrar tekrar tekrarlamak, tahminleri hesaplamak, hataları ölçmek, gradyanları yaymak ve tazeleme parametrelerini vermek gerekir. Bu hesaplama döngüsü eğitim döngüsünü oluşturur. İşleme kaynaklarına ve sorunların boyutuna bağlı olarak, tüm veri kaydını aynı anda işlemeyi seçmek mümkündür, mini partide gruplandırılan diğer veya daha fazla örnekten sonra bir örnek.

Temel bir pytorch eğitim döngüsü, parti çiftleri (girdi hedefi), optimize edici istek ve bir kayıp fonksiyonu ve daha sonra dönemlerde yineleme sağlayan bir veri şarj cihazı tanımı ile başlar. Aşağıda mini parti kullanan tam bir örnek bulacaksınız. Kodun her bir kısmı ayrıntılı olarak açıklanmaktadır.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Angenommen, wir haben einen Merkmals-Tensor X der Form (1000, 20) und einen Ziel-Tensor y der Form (1000,)
dataset = TensorDataset(X, y)
# Erstellen Sie einen DataLoader, der Batches der Größe 32 ausgibt und jede Epoche mischt
data_loader = DataLoader(dataset, batch_size=32, shuffle=True)

model = SimpleMLP(input_dim=20, hidden_dim=50, output_dim=1)
loss_fn = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

num_epochs = 20
for epoch in range(num_epochs):
    epoch_loss = 0.0
    # Iterieren Sie über den Datensatz in Mini-Batches
    for batch_inputs, batch_targets in data_loader:
        # Setzen Sie die aus dem vorherigen Schritt akkumulierten Gradienten auf Null
        optimizer.zero_grad()
        # Berechnen Sie die Modellvorhersagen für den aktuellen Batch
        batch_predictions = model(batch_inputs)
        # Berechne den Verlust zwischen Vorhersagen und tatsächlichen Zielen
        loss = loss_fn(batch_predictions, batch_targets)
        # Backpropagation durch das Netzwerk, um Gradienten zu berechnen
        loss.backward()
        # Aktualisiere die Modellparameter basierend auf den Gradienten
        optimizer.step()

        # Akkumuliere den Verlustwert für die Berichterstellung
        epoch_loss += loss.item() * batch_inputs.size(0)
    # Teile durch die Gesamtzahl der Samples, um den durchschnittlichen Verlust zu erhalten
    epoch_loss /= len(dataset)
    print(f"Epoch {epoch+1}/{num_epochs}, Verlust: {epoch_loss:.4f}")

Kod ilk olarak, her bir girişi karşılık gelen harfle bağlayan bir TenorDataset'teki karakteristik ve hedef sensörleri özetler. Daha sonra, her dönemde 32 boyutta verileri rastgele bir sırayla yayınlayan bir veri şarj cihazı oluşturur. Modelin uygulanması, kayıp fonksiyonu ve optimize edici daha önce tarif edilen modelleri takip eder.

Harici halka verileri işler num_epochs Tam yamaçlar. Bu döngü içinde, dönemin kaybı için sürekli bir toplamı başlatıyoruz. Veri şarj cihazı bir giriş ve nesnel yığın her harcadığında, uygulama önceki tüm gradyan bilgilerini şuradan siler optimizer.zero_grad() çağrılar. Hesaplanması model(batch_inputs) Ağın ileri yöntemini ve dağıtım dağıtımını arayın. Kod, skaler bir tensör oluşturan kayıp işlevini çağırarak bu tahminleri gerçek hedeflerle karşılaştırır.

Çağrı loss.backward() Modeldeki herhangi bir öğrenme parametresine göre kaybın gradyanlarını hesaplamak için pytorch'un otomatik farklılaşmasını tetikler. Bu gradyanlar öznitelikte .grad Her kaydedilen parametre. Çağrı optimizer.step() Ardından, seçilen güncelleme kuralına dayanarak noktadaki parametrelerin değerlerini değiştirin (bu durumda stokastik gradyanın momentumla inişi). Çarpıyoruz loss.item() Örnek kayıplarının toplamını belirlemek için partinin boyutu ile, onları biriktirir ve sonunda ERA için ortalama kaybı belirtmek için veri kümesinin boyutuna bölünürler.

Açık mini parti olmadan oluşum, toplu (yığın) gibi verilerin tüm kaydı işlenerek mümkündür. Bu durumda, verit döşeme şarj cihazını atlayabilir ve yazabilirsiniz:

# Alle Daten als einen einzigen Batch behandeln
optimizer.zero_grad()
predictions = model(X)
loss = loss_fn(predictions, y)
loss.backward()
optimizer.step()

Bu tam ritim yaklaşımı her adımda gerçek gradyanı sağlar, ancak büyük veri kayıtlarında verimsiz olabilir ve mevcut olduğundan daha fazla depolama alanı gerektirir. Aksine, bireysel örnek güncellemelerin kullanılması olabilir (stokastik olarak) batch_size=1 Veri şarj cihazında, gradyanın saygısında yüksek bir değişime yol açar, bu da gürültülü bir yakınsama yol açar, ancak bu da minimum yemeklere daha kolay kaçabilir. Mini-toplu, varyansı azaltarak ve aynı zamanda bellek kısıtlamalarına uyarak pragmatik bir uzlaşmayı temsil eder.

Bu eğitim sürecini takip etsek bile, büyük sinir ağları yeni örneklere genelleştirilebilen modeller yerine eğitim verilerini aşabilir ve öğrenebilir. Aşırı adaptasyonu azaltmak için teknikleri düzenleme için kullanmak mümkündür.

L2'nin düzenli hale getirilmesine matematiksel olarak eşdeğer kilo kaybı, kare ağırlık standardına zarar vermeye bir ceza ekler. Uygulamada, optimize edici kilo kaybını bildirir. Örneğin, önyargılar dışında her parametreye 1E-4 katsayısı eklemek için şunu yazın:

optimizer = optim.SGD(
    [
        {'params': model.fc1.weight, 'weight_decay': 1e-4},
        {'params': model.fc2.weight, 'weight_decay': 1e-4},
        {'params': model.fc1.bias, 'weight_decay': 0},
        {'params': model.fc2.bias, 'weight_decay': 0}
    ],
    lr=0.01,
    momentum=0.9
)

Belirtmek weight_decay Optimize edici, her parametre grubu için ekler weight_decay * θ Her ağırlığın gradyanına ekleyin ve ardından güncelleme kuralını etkili bir şekilde yönlendirin

θ ← θ – η (∂l/∂θ + λ · θ)

Her ağırlık θ için, burada λ kilo kaybı katsayısıdır.

Bir başka güçlü düzenleme teknolojisi de terk edilmesidir. Eğitim sırasında, terk edilme yanlışlıkla her bir katmanın aktivasyonlarının bir kısmını her ileri yarışla sıfıra belirler ve bu da nöronların karşılıklı düzenlemesini önler. Test sırasında, terk edilmenin devre dışı bırakılması ve aktivasyonların küçülmesi, beklenen boyuta uyarlamak için (1 – p) 'dır. Pytorch'ta modeli tanımlamada terk etme seviyeleri ekleyin. Örneğin, ilk gizli seviyeden sonra terk etme eklemek için:

import torch.nn as nn

class MLPWithDropout(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, p=0.5):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.dropout = nn.Dropout(p=p)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        # Randomly zero a fraction p of elements during training
        x = self.dropout(x)
        x = self.fc2(x)
        return x

Model eğitim modundayken – ne çağırıyor model.train() Sigortalanabilir: her vuruş ileride, ekrandaki elemanların bir kısmını sıfır olarak gizleyen yeni bir rastgele mineral maskesi seçimi seçilir. Çağrı model.eval() Doğrulama verilerini değerlendirmeden önce, uzuv devre dışı bırakılabilir ve tüm aktivasyon kümesini kullanabilirsiniz.

Kilo kaybı ve terk edilmeye ek olarak, erken tutuklama, hizmetlerin bir bakım doğrulama oranına göre izlenerek önlemeye karşı korunabilir ve doğrulama kaybı artık iyileşmezse oluşum iptal edilir. Kural olarak, model parametreleri, doğrulama kaybı azaldığında kaydedilir ve belirli sayıda dönemde herhangi bir iyileştirme gerçekleşmezse oluşumu sona erdirir.

Bu düzenleme stratejileri ile daha derin ve daha geniş ağları eğitebilir ve aynı zamanda sağlam bir genellemeyi sürdürebilirsiniz. Bir sonraki bölümde, bu tabana dayanacağız ve meclis üyesinin sinir ağlarını, yinelenen ağları ve farklı seviye türlerini birleştiren hibrit mimarileri inceleyeceğiz.

(RME)