Adagrad Optimize Edici Açıklaması: Nasıl Çalışır, Uygulama ve Karşılaştırmalar

Bir yokuştan aşağı yürüdüğünüzü hayal edin; zeminin bazı kısımları dik, bazıları düzdür. Her seferinde aynı boyutta adım atarsanız zorlanabilir ya da en alta ulaşmanız çok uzun sürebilir. Makine öğreniminde de benzer bir durum gradyan inişi ile yaşanır; tüm parametreler için aynı öğrenme hızını kullanmak öğrenmeyi yavaşlatabilir.

İşte burada Adagrad devreye girer. Eğitim boyunca her parametrenin ne kadar değiştiğine bağlı olarak adım boyutunu ayarlar; özellikle farklı özelliklerin farklı ölçeklere sahip olduğu durumlarda modelin daha hızlı ve etkili öğrenmesine yardımcı olur. Bu yazıda Adagrad’ın nasıl çalıştığını inceleyecek ve arkasındaki matematiği özetleyeceğiz. Ayrıca PyTorch kullanarak nasıl uygulayacağınızı gösterecek ve diğer optimize edicilerle karşılaştıracağız; böylece projeleriniz için en iyisini seçebileceksiniz.

Adagrad nedir?

Adagrad (Adaptive Gradient), makine öğreniminde, özellikle derin sinir ağlarını eğitmek için kullanılan bir optimizasyon algoritmasıdır. Her bir parametre için öğrenme hızını geçmiş gradyanlarına göre uyarlayacak şekilde tasarlanmıştır. Bu yaklaşım, özellikle seyrek verilerin söz konusu olduğu ya da farklı parametrelerin yakınsama hızlarının değiştiği senaryolarda makine öğrenimi modellerinin verimliliğini artırır.

Adagrad, seyrek görülen özellikler için daha yüksek, sık görülenler için daha düşük öğrenme hızları sağlar; bu da onu seyrek verilerle çalışmak için çok uygun kılar. Ayrıca, öğrenme hızını elle ayarlama ihtiyacını azaltır!

Adagrad Algoritmasının Açıklaması

Adagrad algoritmasını adım adım inceleyelim:

Adım 1: Parametreleri Başlatın

Önce şunlarla başlayın:

• Optimize etmek istediğiniz parametrelerin başlangıç değerleri0.
• Sıfıra bölmeyi önlemek için küçük bir sabit ϵ (genellikle 10^-8 gibi çok küçük bir sayı).
• Başlangıçtaki parametre güncellemelerinin ne kadar büyük olacağını belirleyen başlangıç öğrenme hızı η.

Adım 2: Gradyanı Hesaplayın

Her bir parametre için 0_t​ zaman adımında, kayıp fonksiyonunun o parametreye göre gradyanını hesaplarsınız. Bu gradyan, kaybı azaltmak için parametreyi ne kadar ve hangi yönde güncellemeniz gerektiğini söyler. Bu gradyana g_t diyelim; burada _t mevcut zaman adımıdır.

Adım 3: Karesel Gradyanları Biriktirin

Parametreleri doğrudan güncellemek yerine Adagrad, her parametre için gradyanların karelerinin toplamını takip eder. Her parametre i için her zaman adımında karesel gradyanı hesaplayıp biriktirirsiniz. Bu birikimli gradyan G_t olarak gösterilir.

G_t =G_t-1 + g_t²

Burada:

• G_t-1 önceki zaman adımına kadar olan karesel gradyanların toplamıdır.
• g_t² ilgili parametre için mevcut gradyanın karesidir.

Bu birikimli gradyan, Adagrad’ın her parametre için ne kadar güncellendiğine bağlı olarak öğrenme hızını farklı şekilde ayarlamasına yardımcı olur.

Adım 4: Parametreleri Güncelleyin

Artık birikimli karesel gradyana G_t​ sahip olduğunuza göre, her bir parametreyi 0_t​ güncelleyebiliriz. Adagrad’ın güncelleme kuralı şöyledir:

Burada olan şu:

• η başlangıç öğrenme hızıdır
• G_t , t zaman adımına kadar birikmiş karesel gradyanlardır.
• ϵ sıfıra bölmeyi önlemek için küçük bir değerdir.
• g_t​ mevcut zaman adımındaki gradyandır.

Şu terim:

​

toplam gradyanı büyük olan parametreler için öğrenme hızını etkin biçimde düşürür. Buna karşın, birikimli gradyanı küçük olan parametrelerde öğrenme hızı daha büyük olur.

Adagrad’ın formülü öğrenme hızını otomatik olarak uyarlar; şöyle:

• Sık güncellemeler (büyük birikimli gradyan): Sık güncellenen parametrelerde G_t büyür, öğrenme hızını küçültür. Bu, parametrenin aşırı değişmesini engeller ve öğrenmeyi dengeler.
• Seyrek güncellemeler (küçük birikimli gradyan): Daha seyrek güncellenen parametrelerde G_t küçük kalır, öğrenme hızı daha büyük olur. Bu da gerektiğinde daha anlamlı güncellemeler yapılmasını sağlar.

PyTorch ile Adagrad Uygulaması

PyTorch, torch.optim modülü üzerinden erişilebilen yerleşik bir Adagrad uygulaması sağlar. Önce pip ile PyTorch kurun:

pip install torch torchvisionAltyapı:

İlk sinir ağınızı nasıl kuracağınızı ücretsiz kursumuzla öğrenin: Introduction to Deep Learning with PyTorch.

İşte PyTorch’ta Adagrad optimize edicisini uygulamak için adım adım bir rehber:

Adım 1: Gerekli Kütüphaneleri İçe Aktarın

import torchimport torch.nn as nnimport torch.optim as optimAltyapı:

Adım 2: Basit Bir Sinir Ağı Tanımlayın

class SimpleNN(nn.Module):    def __init__(self):        super(SimpleNN, self).__init__()        self.fc1 = nn.Linear(10, 5)        self.fc2 = nn.Linear(5, 2)        def forward(self, x):        x = torch.relu(self.fc1(x))        x = self.fc2(x)        return xAltyapı:

Adım 3: Modeli ve Optimize Ediciyi Başlatın

model = SimpleNN()criterion = nn.CrossEntropyLoss()optimizer = optim.Adagrad(model.parameters(), lr=0.01)Altyapı:

Adım 4: Eğitim Döngüsü

for epoch in range(10):  # loop over the dataset multiple times    inputs = torch.randn(1, 10)  # random input tensor    labels = torch.tensor([1])   # target labels    # Zero the parameter gradients    optimizer.zero_grad()    # Forward pass    outputs = model(inputs)    loss = criterion(outputs, labels)    # Backward pass and optimize    loss.backward()    optimizer.step()    print(f'Epoch {epoch+1}, Loss: {loss.item()}')Altyapı:

Bu kodda, basit bir doğrusal model AdaGrad optimize edicisi ile eğitilir. Öğrenme hızı 0,01 olarak ayarlanmıştır; ancak AdaGrad, birikimli karesel gradyanlara bağlı olarak her parametre için bunu ayarlayacaktır.

Kodu çalıştırdığınızda buna benzer bir çıktı göreceksiniz:

Çıktı, her epoch sonrasında kaybı gösterir; bu da modelin ne kadar iyi öğrendiğini belirtir. Başlangıçta kayıp daha yüksektir; ancak eğitim ilerledikçe genellikle azalır; bu, modelin iyileştiği anlamına gelir. Özellikle rastgele girdilerle bazı dalgalanmalar normaldir; ancak genel olarak model giderek daha iyi tahminler yapmayı öğrenir.

Derin öğrenimi keşfetmek ve bu alanın dünyayı nasıl değiştirdiğini görmek isterseniz, Deep Learning in Python kursumuza göz atın.

Adagrad vs. Diğer Optimize Ediciler

Adagrad&rsquoı Adam, SGD ve RMSProp gibi diğer optimize edicilerle karşılaştıralım.

Adagard vs. Adam

Öğrenme Hızı Uyarlaması

Hem Adagrad hem de Adam her parametre için öğrenme hızını uyarlar; ancak bunu farklı şekillerde yapar. Adagrad, öğrenme hızını karesel gradyanların toplamına göre ölçekler; bu da zamanla öğrenme hızlarının azalmasına yol açabilir. Öte yandan Adam, gradyanların birinci ve ikinci momentlerini kullanır; bu da eğitim boyunca daha istikrarlı bir öğrenme hızını korumasını sağlar.

Seyrek Veriyi Ele Alma: 

Adagrad, seyrek özelliklere daha büyük öğrenme hızları atayabilmesi sayesinde seyrek veriyi ele almakta özellikle başarılıdır. Bu da onu seyrek gradyanların yaygın olduğu doğal dil işleme gibi uygulamalar için iyi bir seçim yapar. Adam da seyrek veriyi işleyebilir; ancak genel sağlamlığı ve geniş bir uygulama yelpazesinde verimliliği nedeniyle sıklıkla tercih edilir.

Yakınsama ve Performans

Adam, özellikle derin öğrenme modellerinde ve büyük veri kümelerinde daha hızlı yakınsaması ve pratikte üstün performansı ile sıkça tercih edilir. Momentum ve yanlılık düzeltmesi kullanımı, yerel minimumlara ve eyer noktalarına takılmaktan kaçınmasına yardımcı olur; bu, Adagrad için bir sınırlama olabilir.

Görüntü ve sıralı verileri modellemek için CNN, RNN, LSTM ve GRU gibi temel derin öğrenme mimarilerini öğrenin. Şu kursa göz atın: Intermediate Deep Learning with PyTorch.

Adagrad vs. diğer gradyan inişi algoritmaları

Adagrad&rsquoı SGD ve RMSProp ile karşılaştıralım

AdaGrad vs. Stokastik Gradyan İnişi (SGD)

Stokastik Gradyan İnişi, model parametrelerini kayıp fonksiyonunun bu parametrelere göre gradyanını kullanarak güncelleyen temel bir optimizasyon algoritmasıdır. Basitliği ve kolay uygulanabilirliği ile bilinir. Ancak SGD’nin sabit bir öğrenme hızı vardır; bu da seyrek verilerle veya değişken özellik ölçekleriyle çalışırken bir sınırlama olabilir.

AdaGrad vs. RMSProp

RMSProp, bir bozunma (decay) faktörü ekleyerek Adagrad’ın azalan öğrenme hızı sorununu ele alan bir uzantıdır. Bu faktör, RMSProp’un eğitim süreci boyunca daha istikrarlı bir öğrenme hızı korumasını sağlar.

Adagrad, SGD ve RMSProp’un artı ve eksilerini özetleyelim:

Yaygın Kullanım Alanları ve Sınırlamalar

AdaGrad’ın farklı bağlamlardaki kullanım alanlarını ve sınırlamalarını inceleyelim.

Adagrad’ın kullanım alanları

Adagrad’ın her parametre için öğrenme hızlarını uyarlayabilme özelliği onu çeşitli senaryolar için ideal kılar:

1. Doğal Dil İşleme (NLP): Adagrad’ın en önemli uygulamalarından biri doğal dil işlemedir. NLP’de sözcük gömme (word embedding) bileşenleri kritik öneme sahiptir ve Adagrad, bu gömmeleri her parametrenin öğrenme hızını uyarlayarak optimize etmekte kullanılır.
2. Tavsiye sistemleri: Tavsiye sistemlerinde Adagrad, tavsiye modelinin ağırlıklarını optimize etmek için kullanılır. Bu, bir kullanıcının belirli bir ürünü beğenme olasılığını tahmin etmek için önemlidir.
3. Görüntü tanıma: görüntü tanıma alanında Adagrad, derin sinir ağlarının ağırlıklarını optimize etmek için kullanılır. Her parametrenin öğrenme hızını uyarlayarak ağırlıkların eldeki göreve uygun şekilde güncellenmesini sağlar ve görüntü tanıma modelinin doğruluğunu artırır

Adagrad’ın sınırlamaları

Adagrad belirli durumlarda güçlü olsa da bazı sınırlamalara sahiptir:

1. Azalan öğrenme hızı: Adagrad’ın başlıca sınırlamalarından biri, zamanla öğrenme hızını çok agresif biçimde düşürme eğilimidir. Algoritma, eğitimin başından itibaren karesel gradyanları biriktirdiği için etkin öğrenme hızı çok küçük hale gelebilir; bu da yavaş yakınsamaya veya modelin tamamen öğrenmeyi durdurmasına yol açabilir.
2. Bellek gereksinimleri: Adagrad, her parametre için geçmiş gradyanları saklamak üzere daha fazla belleğe ihtiyaç duyar; bu da daha büyük veri kümeleri için daha az verimli olmasına neden olur. Büyük ölçekli makine öğrenimi modellerinde bellek verimliliğinin kritik olduğu durumlarda bu önemli bir dezavantaj olabilir.

Sınırlamaları hafifletme stratejileri

Adagrad’ın sınırlamalarını gidermek için kullanabileceğiniz çeşitli stratejiler vardır:

1. AdaDelta ve RMSProp kullanımı: Azalan öğrenme hızı sorununu ele almak için AdaGrad’ın AdaDelta ve RMSProp gibi uzantıları geliştirilmiştir.
2. Momentum ile birleştirme: AdaGrad’ın sınırlamalarını hafifletmenin bir diğer yolu, onu momentuma dayalı yöntemlerle birleştirmektir. Örneğin Adam optimize edici, AdaGrad’ın uyarlanabilir öğrenme hızını momentum kavramıyla birleştirir; bu da yakınsamayı hızlandırmaya ve pratikte performansı artırmaya yardımcı olur.
3. Hiperparametre ayarı: Başlangıç öğrenme hızı ve sıfıra bölmeyi önlemek için kullanılan epsilon değeri gibi hiperparametrelerin dikkatli ayarlanması da Adagrad’ın bazı sınırlamalarını azaltmaya yardımcı olabilir.

Uygulamalı Alıştırma: Bir Modeli Adagrad ile Optimize Etme

Basit bir sinir ağı kuralım, Adagrad optimize edicisi ile eğitelim ve performansını diğer popüler optimize edicilerle karşılaştıralım.

PyTorch hakkında daha fazla öğrenmek isterseniz, şu rehberimize göz atın: PyTorch Tutorial: Building a Simple Neural Network From Scratch.

Önce PyTorch’ta temel bir sinir ağı modeli oluşturalım. Adagrad’ın parladığı, seyrek veriler üzerinde ikili sınıflandırmaya uygun bir ağ tasarlayacağız.

import torchimport torch.nn as nnclass SparseNN(nn.Module):    def __init__(self, input_size):        super(SparseNN, self).__init__()        self.fc1 = nn.Linear(input_size, 50)        self.fc2 = nn.Linear(50, 1)        self.activation = nn.ReLU()        self.output_activation = nn.Sigmoid()    def forward(self, x):        x = self.activation(self.fc1(x))        x = self.output_activation(self.fc2(x))        return xAltyapı:

Bu sinir ağının bir giriş katmanı, 50 nöronlu bir gizli katmanı ve tek nöronlu bir çıkış katmanı vardır. Gizli katman için ReLU, çıkış katmanı için Sigmoid aktivasyon kullanıyoruz; bu da onu ikili sınıflandırma için uygun kılar.

Şimdi eğitim sürecimizi Adagrad optimize edicisini kullanarak kuralım. Eğitimi yönetecek bir fonksiyon oluşturacağız:

import torch.optim as optimfrom torch.utils.data import DataLoader, TensorDataset# Function to train the modeldef train_model(model, optimizer, criterion, train_loader, num_epochs=100):    losses = []    for epoch in range(num_epochs):  # loop for each training epoch        for inputs, targets in train_loader:            # Clear gradients before each batch to avoid accumulation            optimizer.zero_grad() # Reset gradients to zero            # Forward pass - get model predictions            outputs = model(inputs)            # Calculate loss based on predictions and targets            loss = criterion(outputs, targets)            # Backward pass - calculate gradients for parameter updates based on the loss            loss.backward()            # Update model parameters based on calculated gradients            optimizer.step()        # Track loss for monitoring training progress        losses.append(loss.item())    return losses# Setup for trainingX, y = generate_sparse_data()  # This function generates our sparse datasetinput_size = X.shape[1]train_size = int(0.8 * len(X))X_train, X_test = X[:train_size], X[train_size:]y_train, y_test = y[:train_size], y[train_size:]train_dataset = TensorDataset(X_train, y_train)train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)model = SparseNN(input_size)criterion = nn.BCELoss()  # Assuming binary classification with BCE lossoptimizer = optim.Adagrad(model.parameters(), lr=0.01)# Train the modellosses = train_model(model, optimizer, criterion, train_loader)Altyapı:

Bu düzende:

1. SparseNN modelimizi oluşturuyoruz.
2. Kayıp fonksiyonunu tanımlıyoruz (Binary Cross Entropy).
3. Öğrenme hızı 0,01 olan Adagrad optimize edicisini başlatıyoruz.
4. Modeli 100 epoch boyunca eğitiyor ve her epoch’taki kaybı kaydediyoruz.

Şimdi modelimizin performansını değerlendirmek için bir değerlendirme fonksiyonu oluşturalım:

def evaluate_model(model, test_loader):    model.eval()    correct = 0    total = 0    with torch.no_grad():        for inputs, targets in test_loader:            outputs = model(inputs)            predicted = (outputs > 0.5).float()            total += targets.size(0)            correct += (predicted == targets).sum().item()    accuracy = correct / total    return accuracy# Evaluate the modeltest_dataset = TensorDataset(X_test, y_test)test_loader = DataLoader(test_dataset, batch_size=32)accuracy = evaluate_model(model, test_loader)print(f"Adagrad Accuracy: {accuracy:.4f}")Altyapı:

Bu fonksiyon, modelimizin test kümesi üzerindeki doğruluğunu hesaplar.

Sonrasında, onu diğer popüler optimize edicilerle karşılaştıralım: SGD, Adam ve RMSprop. Her optimize edici için deneyi çalıştıracak bir fonksiyon oluşturalım:

def run_experiment(optimizer_class, lr=0.01):    model = SparseNN(input_size)    criterion = nn.BCELoss()        if optimizer_class == optim.SGD:        optimizer = optimizer_class(model.parameters(), lr=lr, momentum=0.9)    elif optimizer_class == optim.RMSprop:        optimizer = optimizer_class(model.parameters(), lr=lr, alpha=0.99)    else:        optimizer = optimizer_class(model.parameters(), lr=lr)    losses = train_model(model, optimizer, criterion, train_loader)    accuracy = evaluate_model(model, test_loader)    return losses, accuracy# Compare optimizersoptimizers = {    'Adagrad': optim.Adagrad,    'SGD': optim.SGD,    'Adam': optim.Adam,    'RMSprop': optim.RMSprop}results = {}for name, opt_class in optimizers.items():    losses, accuracy = run_experiment(opt_class)    results[name] = {'losses': losses, 'accuracy': accuracy}print("Final accuracies:")for name, data in results.items():    print(f"{name}: {data['accuracy']:.4f}")Altyapı:

Bu kodu çalıştırdıktan sonra şu sonuçları elde ederiz:

Final accuracies:Adagrad: 0.9350SGD: 0.8950Adam: 0.9300RMSprop: 0.8600Altyapı:

Bu sonuçlar, Adagrad’ın seyrek veri problemimizde en iyi performansı gösterdiğini ve %95,00 ile en yüksek doğruluğa ulaştığını ortaya koyuyor. Bu, Adagrad’ın seyrek veri senaryolarına iyi uyduğunu gösterir. Adam çok yakın bir ikinci sırada yer alırken, bu özel durumda SGD ve RMSprop daha düşük performans sergiledi.

Eğitim sürecini görselleştirmek için kayıp eğrilerini çizebiliriz:

import matplotlib.pyplot as pltplt.figure(figsize=(12, 6))for name, data in results.items():    plt.plot(data['losses'], label=f"{name} (Accuracy: {data['accuracy']:.4f})")plt.xlabel('Epochs')plt.ylabel('Loss')plt.title('Training Loss Comparison (Sparse Data)')plt.legend()plt.show()Altyapı:

Tüm kod parçalarını birleştirelim; işte tam kod.

import torchimport torch.nn as nnimport torch.optim as optimfrom torch.utils.data import DataLoader, TensorDatasetimport matplotlib.pyplot as plt# Step 1: Generate sparse synthetic datadef generate_sparse_data(n_samples=1000, n_features=100, sparsity=0.95):    X = torch.randn(n_samples, n_features)    mask = torch.rand(n_samples, n_features) < sparsity    X[mask] = 0    weights = torch.randn(n_features)    y = (torch.matmul(X, weights) > 0).float().view(-1, 1)    return X, y# Step 2: Define the neural networkclass SparseNN(nn.Module):    def __init__(self, input_size):        super(SparseNN, self).__init__()        self.fc1 = nn.Linear(input_size, 50)        self.fc2 = nn.Linear(50, 1)        self.activation = nn.ReLU()        self.output_activation = nn.Sigmoid()    def forward(self, x):        x = self.activation(self.fc1(x))        x = self.output_activation(self.fc2(x))        return x# Step 3: Train the modeldef train_model(model, optimizer, criterion, train_loader, num_epochs=100):    losses = []    for epoch in range(num_epochs):        for inputs, targets in train_loader:            optimizer.zero_grad()            outputs = model(inputs)            loss = criterion(outputs, targets)            loss.backward()            optimizer.step()        losses.append(loss.item())    return losses# Step 4: Evaluate the modeldef evaluate_model(model, test_loader):    model.eval()    correct = 0    total = 0    with torch.no_grad():        for inputs, targets in test_loader:            outputs = model(inputs)            predicted = (outputs > 0.5).float()            total += targets.size(0)            correct += (predicted == targets).sum().item()    accuracy = correct / total    return accuracy# Step 5: Main function to run the experimentdef run_experiment(optimizer_class, lr=0.01):    # Generate sparse data    X, y = generate_sparse_data()    input_size = X.shape[1]    train_size = int(0.8 * len(X))    X_train, X_test = X[:train_size], X[train_size:]    y_train, y_test = y[:train_size], y[train_size:]    # Create data loaders    train_dataset = TensorDataset(X_train, y_train)    test_dataset = TensorDataset(X_test, y_test)    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)    test_loader = DataLoader(test_dataset, batch_size=32)    # Initialize model and training components    model = SparseNN(input_size)    criterion = nn.BCELoss()        # Use default hyperparameters for each optimizer    if optimizer_class == optim.SGD:        optimizer = optimizer_class(model.parameters(), lr=lr, momentum=0.9)    elif optimizer_class == optim.RMSprop:        optimizer = optimizer_class(model.parameters(), lr=lr, alpha=0.99)    else:        optimizer = optimizer_class(model.parameters(), lr=lr)    # Train the model    losses = train_model(model, optimizer, criterion, train_loader)    # Evaluate the model    accuracy = evaluate_model(model, test_loader)    return losses, accuracy# Step 6: Compare Adagrad with other optimizersoptimizers = {    'Adagrad': optim.Adagrad,    'SGD': optim.SGD,    'Adam': optim.Adam,    'RMSprop': optim.RMSprop}results = {}for name, opt_class in optimizers.items():    losses, accuracy = run_experiment(opt_class)    results[name] = {'losses': losses, 'accuracy': accuracy}# Step 7: Plot resultsplt.figure(figsize=(12, 6))for name, data in results.items():    plt.plot(data['losses'], label=f"{name} (Accuracy: {data['accuracy']:.4f})")plt.xlabel('Epochs')plt.ylabel('Loss')plt.title('Training Loss Comparison (Sparse Data)')plt.legend()plt.show()print("Final accuracies:")for name, data in results.items():    print(f"{name}: {data['accuracy']:.4f}")Altyapı:

Sonuç şöyle:

Sonuç

Adagrad, uyarlanabilir öğrenme hızı sayesinde seyrek verilerle çalışırken faydalıdır. Basit bir sinir ağı kurup Adagrad ile eğittik ve performansını diğer bilinen optimizasyon algoritmalarıyla karşılaştırdık. Sonuçlar, Adagrad’ın seyrek veriyi daha iyi ele aldığını güçlü şekilde gösterdi.

PyTorch, derin öğrenme ve diğer optimizasyon algoritmalarıyla ilgili en iyi kaynaklardan bazılarını da özenle seçtik. Daha derinlemesine öğrenmek için mutlaka göz atın:

• PyTorch Tutorial: Building a Simple Neural Network From Scratch
• Adam Optimizer Tutorial: Intuition and Implementation in Python
• Stochastic Gradient Descent in Python: A Complete Guide for ML Optimization
• Introduction to Deep Learning with PyTorch
• Intermediate Deep Learning with PyTorch
• Deep Learning for Images with PyTorch