Python’da Softmax Aktivasyon Fonksiyonu: Kapsamlı Rehber

Aktivasyon fonksiyonları, sinir ağlarının bel kemiğidir. Doğrusal olmayanlık kazandırarak bu ağların karmaşık örüntüleri öğrenmesini sağlayan önemli bileşenlerdir. Softmax aktivasyon fonksiyonu özellikle çok sınıflı sınıflandırma problemleriyle çalışırken önem taşır.

Sigmoid ve ReLU gibi alternatiflerin belirli kullanım alanları olsa da, softmax, çıktılar karşılıklı dışlayıcı sınıflar arasında olasılık olarak yorumlanmak zorunda olduğunda daha iyi sonuç verir.

Softmax aktivasyon fonksiyonu, bir sayı vektörünü bir olasılık dağılımına dönüştürür. Bu benzersiz özellik, girdileri birden fazla olası kategoriden birine sınıflandırmamız gereken görevlerde onu vazgeçilmez kılar.

Binlerce nesne kategorisini tanımlayan görüntü tanıma sistemlerinden, bir cümledeki bir sonraki kelimeyi tahmin eden doğal dil işleme modellerine kadar, softmax, birden çok olasılık arasından karar vermek için matematiksel temeli sağlar.

Bu yazıda softmax aktivasyon fonksiyonunun ne olduğunu, matematiksel olarak nasıl çalıştığını ve sinir ağı mimarilerinizde ne zaman kullanmanız gerektiğini ele alacağız. Ayrıca Python’daki pratik uygulamalara da bakacağız.

Softmax Aktivasyon Fonksiyonu Nedir?

Softmax aktivasyon fonksiyonu, logit olarak bilinen ham model çıktılarından oluşan bir vektörü bir olasılık dağılımına dönüştüren matematiksel bir fonksiyondur. Daha basit bir ifadeyle, bir dizi sayıyı alır ve toplamı 1 olan olasılıklara çevirir.

Bireysel değerlere bağımsız olarak etki eden bazı aktivasyon fonksiyonlarının aksine, softmax tüm değerlerden oluşan bir vektör üzerinde çalışır ve bunları topluca toplamı tam olarak 1 olan bir olasılık dağılımına dönüştürür.

Sinir ağları bağlamında, softmax genellikle çok sınıflı sınıflandırma için tasarlanmış bir ağın son katmanına uygulanır. Birden fazla olası kategori olduğunda ve modelimizin her kategori için olasılık belirtmesi gerektiğinde softmax aktivasyon fonksiyonu standart tercihtir.

Softmax fonksiyonu nasıl çalışır?

Bir sinir ağının son katmanından çıkan ham değerlere genellikle "logit" denir. Bu değerler eksi sonsuzdan artı sonsuza kadar uzanabilir ve doğrudan olasılıksal bir yorumu yoktur. Softmax aktivasyon fonksiyonu bu logitleri aşağıdaki şekilde daha yorumlanabilir bir forma dönüştürür:

1. Her bir giriş değerinin üstelini almak (tüm değerlerin pozitif olmasını sağlar).
2. Her bir üstel değeri tüm üstellerin toplamına bölmek (çıktıların toplamının 1 olmasını sağlar).

Bu dönüşüm kritiktir çünkü ağın çıktısını bir olasılık dağılımı olarak yorumlamamıza olanak tanır. Örneğin, bir sinir ağı görüntüleri üç kategoriye (kedi, köpek, kuş) sınıflandırıyorsa, softmax çıktısı [0.7, 0.2, 0.1] olabilir; bu da sırasıyla kedi için %70, köpek için %20 ve kuş için %10 olasılık anlamına gelir.

Softmax aktivasyon fonksiyonu geçerli olasılık dağılımları oluşturmada hayati bir rol oynar çünkü:

• Tüm çıktı değerlerinin 0 ile 1 arasında olmasını sağlar.
• Tüm çıktıların toplamının tam olarak 1 olmasını garanti eder.
• Girdi değerlerinin sıralamasını korur (daha büyük girdiler daha büyük olasılıklara karşılık gelir).
• Büyük değerler arasındaki farkları belirginleştirirken küçük değerler arasındaki farkları bastırır.

Softmax Aktivasyon Fonksiyonu

Yukarıdaki görselleştirme, softmax aktivasyon fonksiyonunun ham logitleri (giriş değerleri 2.0, 1.0 ve 0.5) bir olasılık dağılımına (0.7, 0.2 ve 0.1) nasıl dönüştürdüğünü gösteriyor. Softmax kutusunun içindeki formül, her bir çıktı olasılığının bir giriş değerinin üstelinin alınması ve tüm üstellerin toplamına bölünmesiyle nasıl hesaplandığını temsil eder. 

Sağda vurgulanan temel özellikler, softmax’in çok sınıflı sınıflandırma problemleri için neden faydalı olduğunu gösterir. Bir sonraki bölümde matematiksel formüle ve nasıl çalıştığına bakacağız.

Softmax Aktivasyon Fonksiyonu Formülü ve Nasıl Çalışır

Artık softmax aktivasyon fonksiyonunun ne olduğunu bildiğimize göre, matematiksel formülasyona ve girdileri olasılık dağılımlarına nasıl dönüştürdüğüne bakalım.

Softmax aktivasyon fonksiyonunun formülü matematiksel olarak şu şekilde ifade edilebilir:

Burada:

• ​z_i sınıf i için giriş değeridir (logit)
• e^z_i , z_i değerine uygulanan üstel fonksiyondur (exp(z_i ) olarak da yazılır)
• K toplam sınıf sayısıdır
• Payda, tüm giriş değerlerinin üstellerinin toplamını alır ve çıktıların toplamının 1 olmasını sağlar

Softmax aktivasyon fonksiyonu, bir girdi vektörünü bir olasılık dağılımına dönüştürmek için şu adımları izler:

1. Üstelleri hesaplayın: İlk olarak her giriş değerinin üstelini (e^x) hesaplarız. Bu adım, e^x > 0 olduğundan tüm değerlerin pozitif olmasını sağlar.
2. Üstelleri toplayın: 1. adımdaki tüm üstel değerlerin toplamını hesaplarız.
3. Normalize edin: Her üstel değeri 2. adımda hesaplanan toplama böleriz. Bu normalizasyon, tüm çıktıların 0 ile 1 arasında olmasını ve toplamlarının tam olarak 1 olmasını sağlar.

Nasıl çalıştığını pratikte görmek için softmax aktivasyon fonksiyonu formülünü basit bir örneğe uygulayalım.

Üç sınıflı bir sınıflandırma problemi için (ör. bir görüntünün kedi, köpek veya kuş içerip içermediğini belirleme) üç çıkış nöronuna sahip bir sinir ağımız olduğunu varsayalım. Son hesaplamadan sonra ağ şu logitleri üretir: z = [2.0, 1.0, 0.5].

Bu logitleri softmax fonksiyonu kullanarak olasılıklara dönüştürmek için:

1. Üstelleri hesaplayın:
• e^2.0 = 7.389
• e^1.0 = 2.718
• e^0.5 = 1.648
2. Üstelleri toplayın:
• 7.389 + 2.718 + 1.648 = 11.755
3. Normalize edin:
• P(sınıf 1) = 7.389 / 11.755 ≈ 0.628 ya da %62.8
• P(sınıf 2) = 2.718 / 11.755 ≈ 0.231 ya da %23.1
• P(sınıf 3) = 1.648 / 11.755 ≈ 0.140 ya da %14.0

Ortaya çıkan olasılık dağılımı [0.628, 0.231, 0.140] toplamı 1 eder ve en yüksek olasılık, en yüksek logit değerine karşılık gelen sınıfa atanır. Bu örnek, softmax aktivasyon fonksiyonunun girdi değerlerinin sıralamasını korurken onları geçerli bir olasılık dağılımına nasıl dönüştürdüğünü gösterir.

Orijinal giriş değerlerinin (2.0, 1.0, 0.5) çıktı olasılıklarında göreli sıralamasını koruduğuna, ancak aralarındaki farkların belirginleştirildiğine dikkat edin. Bu özellik, en olası sınıfı güvenle belirlemek istediğimiz sınıflandırma görevlerinde softmax’i özellikle yararlı kılar.

Bir sonraki bölümde, Python kullanarak softmax aktivasyon fonksiyonunu uygulamanın farklı yollarına bakacağız.

Python’da Softmax Aktivasyon Fonksiyonunun Uygulanması

Artık softmax aktivasyon fonksiyonunun teorisini anladığımıza göre, bunu Python’da nasıl uygulayacağımıza bakalım. NumPy kullanarak sıfırdan bir softmax fonksiyonu yazarak başlayacak, ardından TensorFlow/Keras ve PyTorch gibi popüler derin öğrenme çerçeveleriyle nasıl kullanılacağını göreceğiz.

NumPy kullanarak softmax’i sıfırdan yazma

Çerçevelere dalmadan önce, softmax aktivasyon fonksiyonunu sıfırdan nasıl uygulayacağımızı anlamak önemlidir. Bu, kaputun altında neler olduğuna dair sezgi kazandırır.

import numpy as np

def softmax(x):
    """
    Compute softmax values for each set of scores in x.
    
    Args:
        x: Input array of shape (batch_size, num_classes) or (num_classes,)
        
    Returns:
        Softmax probabilities of same shape as input
    """
    # For numerical stability, subtract the maximum value from each input vector
    # This prevents overflow when calculating exp(x)
    shifted_x = x - np.max(x, axis=-1, keepdims=True)
    
    # Calculate exp(x) for each element
    exp_x = np.exp(shifted_x)
    
    # Calculate the sum of exp(x) for normalization
    sum_exp_x = np.sum(exp_x, axis=-1, keepdims=True)
    
    # Normalize to get probabilities
    probabilities = exp_x / sum_exp_x
    
    return probabilitiesAltyapı:

Bu uygulama, önemli bir eklemeyle softmax aktivasyon fonksiyonu formülünü birebir takip eder: üstel almadan önce her giriş vektöründen maksimum değeri çıkarırız. 

Bu "kaydırma" işlemi matematiksel sonucu değiştirmez, ancak büyük sayıların üstelinin alınması sırasında oluşabilecek sayısal taşmayı engellemeye yardımcı olur.

Uygulamamızı basit bir örnekle test edelim:

# Sample logits from a neural network (batch of 2 examples, 3 classes each)
logits = np.array([
    [2.0, 1.0, 0.5],  # First example
    [3.0, 2.0, 1.0]   # Second example
])

probabilities = softmax(logits)
print("Logits:\n", logits)
print("\nSoftmax probabilities:\n", probabilities)
print("\nSum of probabilities (should be 1 for each example):", np.sum(probabilities, axis=1))Altyapı:

Çıktı:

Yukarıdaki kodu çalıştırdığımızda, her örnek için olasılıkların toplamının 1’e eşit olduğunu görürüz; bu da softmax uygulamamızın geçerli olasılık dağılımları ürettiğini doğrular. İlk örnekte en büyük olasılık en büyük logit’e (2.0) karşılık gelir; ikinci örnek için de benzer şekilde.

TensorFlow/Keras’ta softmax kullanma

TensorFlow ve Keras, sinir ağlarınızda softmax aktivasyon fonksiyonunu kullanmayı kolaylaştırır. MNIST veri kümesi için adım adım basit bir sınıflandırıcı oluşturalım.

Önce gerekli kütüphaneleri içe aktaralım ve veri kümesini yükleyelim:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Softmax
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
import numpy as np

# Load and preprocess the MNIST dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Normalize pixel values to be between 0 and 1
x_train, x_test = x_train / 255.0, x_test / 255.0

# One-hot encode the labels
y_train_one_hot = tf.keras.utils.to_categorical(y_train, 10)
y_test_one_hot = tf.keras.utils.to_categorical(y_test, 10)Altyapı:

MNIST veri kümesi, el yazısı rakamların (0-9) 28x28 piksellik gri tonlamalı görüntülerini içerir. Eğitim dinamiklerini iyileştirmek için piksel değerlerini 0 ile 1 arasına normalize ediyor ve sınıf etiketlerini softmax çıktıları için tercih edilen format olan one-hot kodlamaya dönüştürüyoruz.

Şimdi softmax çıkış katmanına sahip bir sinir ağı modeli oluşturalım:

# Method 1: Using softmax as the activation function in the final layer
model1 = Sequential([
    Flatten(input_shape=(28, 28)),  # Convert 28x28 images to 784-length vectors
    Dense(128, activation='relu'),   # Hidden layer with ReLU activation
    Dense(10, activation='softmax')  # Output layer with softmax activation
])

# Method 2: Using a separate Softmax layer
model2 = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10),  # Linear output (logits)
    Softmax()   # Separate softmax layer
])Altyapı:

Burada, softmax aktivasyon fonksiyonunu bir sinir ağına dahil etmenin eşdeğer iki yolunu gösteriyoruz:

• Yöntem 1: Son Dense katmanda aktivasyon fonksiyonu olarak doğrudan 'softmax' belirtmek
• Yöntem 2: Ham logit üreten Dense katmandan sonra ayrı bir Softmax katmanı eklemek

Her iki yaklaşım da aynı sonucu üretir, ancak ikinci yöntem, logitler ile olasılıklar arasındaki ayrımı daha net hale getirir; bu da bazı senaryolarda faydalı olabilir.

Sırada modeli derleyip eğitmek var:

# Compile the model
model1.compile(
    optimizer='adam',
    loss='categorical_crossentropy',  # This loss works well with softmax
    metrics=['accuracy']
)

# Print model summary
print("Model with softmax activation:")
model1.summary()

# Train the model
print("\nTraining the model...")
history = model1.fit(
    x_train, y_train_one_hot,
    epochs=5,
    batch_size=128,
    validation_split=0.1,
    verbose=1
)Altyapı:

Çıktı:

Modeli, softmax çıktılarıyla çalışmak üzere tasarlanmış kategorik çapraz entropi kaybı ile derliyoruz. Bu kayıp fonksiyonu, tahmin edilen olasılık dağılımı ile gerçek one-hot kodlu etiketler arasındaki farkı ölçer. Öğrenme oranını eğitim sırasında uyarlamalı olarak ayarlayan Adam optimizasyon algoritmasını kullanıyoruz.

Eğitimden sonra, modelle tahmin yapabilir ve sonuçları görselleştirebiliriz:

# Let's check predictions on a sample
sample_idx = 42
sample_image = x_test[sample_idx]
true_label = y_test[sample_idx]

# Get model predictions (probabilities across all classes)
predictions = model1.predict(sample_image[np.newaxis, ...])

# Visualize the results
plt.figure(figsize=(10, 4))

# Plot the image
plt.subplot(1, 2, 1)
plt.imshow(sample_image, cmap='gray')
plt.title(f"True label: {true_label}")
plt.axis('off')

# Plot the probability distribution
plt.subplot(1, 2, 2)
plt.bar(range(10), predictions[0])
plt.xticks(range(10))
plt.xlabel('Digit')
plt.ylabel('Probability')
plt.title('Softmax Probabilities')Altyapı:

Bu kod bir test görüntüsü seçer, onu eğitilmiş modelden geçirir ve hem görüntüyü hem de softmax çıkışından elde edilen olasılık dağılımını görselleştirir. Olasılık grafiğindeki en yüksek çubuk, modelin tahminini temsil eder.

Çıktı:

TensorFlow ayrıca softmax’i doğrudan uygulamak için yerleşik bir fonksiyon sağlar:

# Demonstrate using a custom softmax function in TensorFlow
def custom_softmax(logits):
    """Custom implementation of softmax in TensorFlow"""
    exp_logits = tf.exp(logits - tf.reduce_max(logits, axis=-1, keepdims=True))
    return exp_logits / tf.reduce_sum(exp_logits, axis=-1, keepdims=True)

# Example usage of custom softmax
logits = tf.constant([[2.0, 1.0, 0.5], [3.0, 2.0, 1.0]])
custom_probs = custom_softmax(logits)
tf_probs = tf.nn.softmax(logits)

print("\nCustom softmax:", custom_probs.numpy())
print("TensorFlow softmax:", tf_probs.numpy())Altyapı:

Çıktı:

Bu örnek, özel bir softmax uygulamasını TensorFlow’un yerleşik tf.nn.softmax() fonksiyonu ile karşılaştırır. Her ikisinin de aynı sonuçları üretmesi gerekir. Özel uygulama, üstel almadan önce maksimum değeri çıkarma şeklindeki sayısal kararlılık püf noktasını da içerir.

PyTorch’ta Softmax Kullanma

Şimdi benzer bir modeli PyTorch ve CIFAR-10 veri kümesini kullanarak uygulayalım. Aşağıda gösterildiği gibi kütüphaneleri içe aktararak ve veriyi hazırlayarak başlayacağız:

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# Set the device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# Load and preprocess the CIFAR-10 dataset
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # Normalize RGB channels
])

# Load a small subset of the CIFAR-10 dataset for demonstration
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False, num_workers=2)

# Define the class names for CIFAR-10
classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')Altyapı:

Yukarıdaki kod, varsa GPU hızlandırmayı kullanmak üzere PyTorch’u yapılandırır, CIFAR-10 veri kümesini (10 sınıfa dağılan 32x32 renkli görüntüler içerir) yükler ve eğitim ile test için veri yükleyicilerini hazırlar.

Sırada basit bir evrişimsel sinir ağı tanımlamak var:

# Define a simple convolutional neural network
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # Convolutional layers
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        
        # Fully connected layers
        self.fc1 = nn.Linear(32 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, 10)  # 10 classes in CIFAR-10
        
        # Activation functions
        self.relu = nn.ReLU()
        
        # Note: We don't define softmax here as it will be applied with the loss function
    
    def forward(self, x):
        # Convolutional layers with ReLU and pooling
        x = self.pool(self.relu(self.conv1(x)))  # -> 16x16x16
        x = self.pool(self.relu(self.conv2(x)))  # -> 8x8x32
        
        # Flatten the output
        x = x.view(-1, 32 * 8 * 8)
        
        # Fully connected layers
        x = self.relu(self.fc1(x))
        x = self.fc2(x)  # Raw logits output
        
        # Note: No softmax here, as PyTorch's CrossEntropyLoss applies it internally
        return xAltyapı:

Bu CNN, 32x32 RGB görüntüleri evrişim katmanlarından geçirir, ReLU aktivasyonu ve havuzlama uygular ve tam bağlantılı katmanlarla sonlanır. Dikkat edilirse, model ileri geçişinde softmax katmanı içermez; bunun yerine ham logitleri çıktı verir.

Bu, PyTorch’ta yaygın bir kalıptır çünkü eğitim sırasında kullanılan CrossEntropyLoss fonksiyonu, kaybı hesaplamadan önce dahili olarak softmax uygular; bu da sayısal olarak daha kararlıdır. 

Gerekirse softmax’i açıkça nasıl dahil edeceğimize de bakalım:

# Applying softmax within the model
class ModelWithSoftmax(nn.Module):
    def __init__(self):
        super(ModelWithSoftmax, self).__init__()
        self.features = SimpleCNN()
        self.softmax = nn.Softmax(dim=1)
    
    def forward(self, x):
        logits = self.features(x)
        probabilities = self.softmax(logits)
        return probabilitiesAltyapı:

İki model varyantı tanımlıyoruz: SimpleCNN ham logitler üretirken, ModelWithSoftmax olasılıkları elde etmek için açıkça softmax uygular. Eğitim için, PyTorch’ta standart yaklaşım olan CrossEntropyLoss ile birlikte SimpleCNN kullanırız.

Bir eğitim fonksiyonu tanımlayalım:

# Create the model and move it to the device 
model = SimpleCNN().to(device) 
# Define loss function and optimizer 
criterion = nn.CrossEntropyLoss()  # Combines LogSoftmax and NLLLoss 
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# Train the model (only a few epochs for demonstration)
def train_model(epochs=2):
    for epoch in range(epochs):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data[0].to(device), data[1].to(device)
            
            # Zero the parameter gradients
            optimizer.zero_grad()
            
            # Forward + backward + optimize
            outputs = model(inputs)  # These are logits (pre-softmax)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item()
            if i % 100 == 99:
                print(f'[{epoch + 1}, {i + 1}] loss: {running_loss / 100:.3f}')
                running_loss = 0.0
    
    print('Finished Training')Altyapı:

Son olarak model tahminlerini görselleştirmek için bir fonksiyon oluşturalım:

# Function to display predictions with softmax probabilities
def show_prediction_example():
    # Get a batch of test images
    dataiter = iter(testloader)
    images, labels = next(dataiter)
    
    # Select a single image
    img = images[0].to(device)
    label = labels[0]
    
    # Get the model's prediction (logits)
    with torch.no_grad():
        logits = model(img.unsqueeze(0))
    
    # Apply softmax to get probabilities
    probabilities = torch.nn.functional.softmax(logits, dim=1)
    
    # Plot the image and probabilities
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
    
    # Show the image
    img_np = img.cpu().numpy()
    img_np = np.transpose(img_np, (1, 2, 0))
    # Denormalize the image for display
    img_np = img_np * 0.5 + 0.5
    ax1.imshow(img_np)
    ax1.set_title(f"True label: {classes[label]}")
    ax1.axis('off')
    
    # Show the probabilities
    probs = probabilities[0].cpu().numpy()
    ax2.bar(range(10), probs)
    ax2.set_xticks(range(10))
    ax2.set_xticklabels(classes, rotation=45)
    ax2.set_xlabel('Class')
    ax2.set_ylabel('Probability')
    ax2.set_title('Softmax Probabilities')
    
    plt.tight_layout()Altyapı:

Bu fonksiyon, çıkarım sırasında eğitilmiş bir modelden softmax olasılıklarının nasıl elde edileceğini gösterir. Bir görüntüyü modelden geçirerek logitleri alır, torch.nn.functional.softmax() ile manuel olarak softmax uygular ve ardından hem görüntüyü hem de ortaya çıkan olasılık dağılımını görselleştirir.

Şimdi modeli eğitelim:

train_model()Altyapı:

Çıktı:

Bir test görüntüsü için olasılıkların nasıl göründüğüne bakalım:

show_prediction_example()Altyapı:

Çıktı:

Bir sonraki bölümde, softmax’in en uygun tercih olduğu belirli senaryolara bakacak, softmax aktivasyon fonksiyonunun ne zaman kullanılacağını inceleyecek ve çeşitli derin öğrenme modellerindeki gerçek dünya uygulamalarını tartışacağız.

Softmax Aktivasyon Fonksiyonu Ne Zaman Kullanılır?

Softmax aktivasyon fonksiyonunun ne zaman kullanılacağını anlamak, etkili sinir ağları tasarlamak için önemlidir. Softmax aktivasyon fonksiyonu, sınıflandırma görevleri için tasarlanmış sinir ağlarının çıkış katmanında birincil uygulama alanını bulur.

Çok sınıflı sınıflandırma için softmax

Modelimizin girdileri birden çok, karşılıklı dışlayıcı kategoriden birine sınıflandırması gerektiğinde softmax standart tercihtir. Yaygın örnekler şunlardır:

• Görüntü sınıflandırma (fotoğraflardaki nesneleri tanımlama)
• Belge kategorilendirme (metne konu atama)
• Adlandırılmış varlık tanıma (kişi adları, konumlar vb. belirleme)
• Konuşma tanıma (sesi metne dönüştürme)

Olasılıksal yorum ve güven skorları

Modelimizin yalnızca sınıf tahminleri yerine olasılıklar üretmesini istediğimizde, softmax mümkün olan tüm sınıflar arasında modelin güvenini olasılıksal olarak yorumlama olanağı sağlar.

Pekiştirmeli öğrenme ve dikkat mekanizmalarında softmax

Pekiştirmeli öğrenme ve sıralı karar problemlerinde softmax, eylem değerlerini eylem seçimi için bir olasılık dağılımına dönüştürmek amacıyla kullanılabilir.

Modern dönüştürücü (transformer) tabanlı mimariler, girdinin farklı bölümleri arasında dikkati dağıtmak için softmax kullanır.

Güçlü matematiksel temeli ve sezgisel olasılıksal yorumu sayesinde softmax aktivasyon fonksiyonu, sınıfların karşılıklı dışlayıcı olduğu sınıflandırma problemleri için özellikle uygundur.

Derin öğrenme modelleri

Birçok derin öğrenme mimarisi softmax aktivasyon fonksiyonunu kullanır. 

ResNet, VGG ve Inception gibi görüntü sınıflandırma ağları, görüntüleri binlerce kategoriye sınıflandırmak için son katmanlarında softmax kullanır. Örneğin, ImageNet üzerinde eğitilen modeller genellikle 1000 nesne kategorisine karşılık gelen 1000 birimli bir softmax katmanına sahiptir.

Dil modellemede, RNN tabanlı modeller, on binlerce kelime içerebilen bir sözlükten sıradaki kelimeyi tahmin etmek için softmax kullanır.

BERT, GPT ve T5 gibi modern NLP mimarileri softmax’i birden fazla bileşende kullanır:

• Girdinin farklı kısımlarına ne kadar odaklanılması gerektiğini belirleyen dikkat mekanizmalarında
• Duygu analizi veya belge sınıflandırma gibi görevler için son sınıflandırma katmanında

Varyasyonel Otomatik Kodlayıcılar (VAE) ve bazı Üretici Çekişmeli Ağlar (GAN), ayrıştırıcı bileşenlerinde veya kategorik gizil değişken modellemede softmax kullanır.

Bir sonraki bölümde softmax aktivasyon fonksiyonu ile sigmoid aktivasyon fonksiyonu arasındaki farklara bakacağız.

Softmax vs Sigmoid Aktivasyon Fonksiyonu

σ(x) = 1/(1+e^(-x)) olarak tanımlanan sigmoid fonksiyonu, tek bir gerçek sayıyı 0 ile 1 arasında bir değere dönüştürür. Buna karşın softmax aktivasyon fonksiyonu, sayıların bir vektörü üzerinde çalışır ve onları bir olasılık dağılımına çevirir.

Bu iki aktivasyon fonksiyonu arasındaki temel farklar şunlardır:

Girdi ve çıktı boyutları

• Sigmoid: Tek bir skaler girdi alır ve 0 ile 1 arasında tek bir skaler çıktı üretir.
• Softmax: n girdiden oluşan bir vektör alır ve toplamı 1 olan n çıktılı bir vektör üretir.

Olasılık yorumu

• Sigmoid: Çıktı, tek bir ikili olayın olasılığını temsil eder (ör. "Bu e-posta spam mi?").
• Softmax: Çıktılar, birden fazla karşılıklı dışlayıcı sınıf arasında toplamı 1 olan olasılıkları temsil eder (ör. "Bu 0-9 arasındaki hangi rakam?").

Çıktıların bağımsızlığı

• Sigmoid: Birden fazla nöronda kullanıldığında her çıktı diğerlerinden bağımsızdır. Birden fazla çıktı aynı anda yüksek veya düşük olabilir.
• Softmax: Çıktılar karşılıklı bağımlıdır—bir olasılık artarsa, toplamın 1 kalması için diğerlerinin azalması gerekir.

Matematiksel ilişki

İlginçtir ki, iki sınıf olduğu durumda sigmoid fonksiyonu aslında softmax aktivasyon fonksiyonunun özel bir hâlidir. Bu nedenle sigmoid bazen "ikili softmax" olarak anılır.

Ne zaman softmax, ne zaman sigmoid kullanılır

Doğru aktivasyon fonksiyonunu seçmek, bir sinir ağının anlamlı tahminler üretmesini sağlamak için kritiktir; softmax ile sigmoid arasındaki seçim, sınıflandırma görevinin doğasına bağlıdır.

Şunlarda sigmoid kullanın:

• İkili sınıflandırma problemleri (iki sınıf)
• Her bir çıktının bağımsız olarak yorumlanması gerektiği durumlar
• Bir örneğin aynı anda birden fazla sınıfa ait olabildiği çok etiketli (multi-label) sınıflandırma
• Tekrarlayan sinir ağlarında dikkat mekanizmaları veya kapılar oluşturma

Şunlarda softmax kullanın:

• Çok sınıflı sınıflandırma problemleri (ikiden fazla sınıf)
• Sınıflar karşılıklı dışlayıcı olduğunda (girdi tam olarak bir sınıfa ait olduğunda)
• Tüm olası sonuçlar arasında düzgün bir olasılık dağılımına ihtiyacınız olduğunda
• Çoğu görüntü sınıflandırma ağının son katmanını uygularken

Örneğin, el yazısı rakamları (0-9) sınıflandıran bir sinir ağında, her görüntü tam olarak bir rakamı temsil ettiğinden, çıkış katmanı için softmax aktivasyon fonksiyonu uygundur. Öte yandan, bir görüntüde birden fazla nesneyi algılayan bir ağda (ör. "kişi var", "araba var", "ağaç var"), aynı anda birden çok nesne bulunabildiği için sigmoid aktivasyonları daha uygun olacaktır.

Softmax ile sigmoid aktivasyon fonksiyonunu karşılaştıran hızlı bir başvuru tablosu:

Bu aktivasyon fonksiyonları arasındaki ayrımı anlamak, etkili sinir ağları tasarlamak için kritiktir. Softmax aktivasyon fonksiyonu çok sınıflı sınıflandırma problemleri için başvurulan seçenek olurken, sigmoid ikili sınıflandırma ve bağımsız olasılık gerektiren problemler için değerini korur.

Bir sonraki bölümde, softmax aktivasyon fonksiyonuyla çalışırken ortaya çıkan yaygın sorunlara ve dikkat edilmesi gereken hususlara bakacağız.

Yaygın Sorunlar ve Dikkat Edilmesi Gerekenler

Derin öğrenme modellerinizde softmax aktivasyon fonksiyonuyla çalışırken, model performansını ve güvenilirliğini etkileyebilecek çeşitli zorluklar vardır. Bu sorunları anlamak ve nasıl ele alınacağını bilmek, daha sağlam modeller oluşturmanıza yardımcı olur.

Sayısal kararlılık zorlukları

Sayısal kararlılık, softmax aktivasyon fonksiyonunu kullanırken kritik bir konudur. Softmax aktivasyon fonksiyonu formülündeki üstel işlem, doğru şekilde ele alınmazsa sayısal taşma veya taşma eksikliğine (underflow) yol açabilir.

Örneğin, çok büyük giriş değerleriyle (1000 veya daha yüksek) çalışırken üstel fonksiyon, sisteminizde temsil edilebilen azami kayan nokta değerini aşabilecek kadar büyük sayılar üretir. Bu, "sonsuz" değerlerin ortaya çıktığı taşma hatalarına ve nihai bölme işleminin tanımsız sonuçlar (NaN - Not a Number) vermesine neden olur.

Standart çözüm, uygulama bölümünde de belirtildiği gibi, üstel fonksiyonu uygulamadan önce tüm girdilerden maksimum değeri çıkarmaktır. Bu kaydırma, normalizasyondan sonra göreli oranları değiştirmez ancak değerleri yönetilebilir bir aralıkta tutar. 

Modern derin öğrenme çerçeveleri bu sorunu dahili olarak ele alır, ancak özel işlemler uygular veya beklenmedik davranışları hata ayıklar iken problemi anlamak önemlidir.

Softmax ve tahminlerde aşırı özgüven

Softmax aktivasyon fonksiyonuyla ilgili bir diğer yaygın sorun, sinir ağlarının yanlış olduklarında bile tahminlerinde aşırı özgüvenli hâle gelme eğilimidir. Bu aşırı özgüven şu nedenlerle ortaya çıkar:

1. Softmax’in üstel doğası, logitlerdeki küçük farkları büyütür.
2. Modern derin sinir ağları eğitim verilerini mükemmel şekilde ezberleyecek kadar güçlüdür.
3. Model iyi bir doğruluğa ulaştıktan sonra bile çapraz entropi kaybı, doğru sınıflar için olasılıkları 1’e doğru itmeye devam eder.

Pratikte bu, modelin aslında yanlış olan bir tahmine %99 olasılık atayabileceği anlamına gelir. Bu, güvenilir belirsizlik tahmininin kritik olduğu uygulamalarda sorun yaratabilir. Örneğin, yanlış tahminlerinde aşırı özgüvenli bir tıbbi tanı sistemi uygunsuz tedavi kararlarına yol açabilir.

Bir modelin güveni (softmax olasılıkları) ile gerçek doğruluğu arasındaki farka kalibrasyon hatası denir. İyi kalibre edilmiş modeller, güven skorlarının doğruluk oranlarıyla eşleşmesini sağlar—bir model olayları %80 güvenle tahmin ediyorsa, bu olaylar yaklaşık %80 oranında gerçekleşmelidir.

Performansı Artırmak için Düzenlileştirme Teknikleri

Neyse ki, softmax aktivasyon fonksiyonuyla ilgili bu sorunlara yardımcı olabilecek çeşitli teknikler vardır:

Sıcaklık ölçekleme

Sıcaklık ölçekleme, olasılık dağılımının "yumuşaklığını" kontrol eden T parametresini tanıtır. Softmax’i uygulamadan önce logitleri bu sıcaklık parametresine bölerek, ortaya çıkan dağılımın ne kadar sivri ya da uniform olacağını ayarlayabilirsiniz.

Daha yüksek sıcaklıklar (T > 1), daha az aşırı değerlere sahip daha yumuşak olasılık dağılımları üretir ve aşırı özgüveni azaltmaya yardımcı olabilir. Daha düşük sıcaklıklar (T < 1) dağılımı en yüksek değere doğru daha sivri hâle getirir. Sıcaklık ölçekleme, eğitimin ardından modelin sınıfları sıralama yeteneğini etkilemeden güvenini kalibre etmek için yaygın bir son işlem tekniği olarak kullanılır.

Etiket yumuşatma

Etiket yumuşatma, sert one-hot hedef vektörlerini hafifçe yumuşatılmış dağılımlarla değiştirir. Modeli tam sıfırlar ve birler üretmeye zorlamak yerine, doğru sınıf için 0.9 ve yanlış sınıflar için (4 sınıflı bir problemde) 0.025 gibi değerler hedeflenerek modelin biraz daha az özgüvenli olması teşvik edilir.

Bu yumuşatılmış etiketlerle eğitim yapmak, modelin tahminlerinde daha az özgüvenli olmasını sağlar; bu da genelleştirmeyi iyileştirir ve modeli etiket gürültüsüne daha dayanıklı kılar. Bu teknik, birçok güncel görüntü sınıflandırma modelinde standart uygulama hâline gelmiştir.

Dropout ve ansambl yöntemleri

Eğitim sırasında dropout kullanmak ve çıkarım sırasında da etkin bırakmak (Monte Carlo dropout adı verilen bir teknik) aynı girdi için birden çok tahmin örneklemenize ve belirsizliği tahmin etmenize olanak tanır. Model, farklı dropout desenleriyle yapılan birden çok ileri geçişte tutarlı tahminler üretiyorsa, tahmini konusunda muhtemelen daha emindir.

Benzer şekilde, ansambl yöntemleri birden fazla modelin tahminlerini birleştirerek performansı artırır ve daha iyi belirsizlik tahminleri sağlar. Bir ansambl içindeki modeller arasındaki fikir ayrılığı, belirsizliğin bir ölçütü olarak hizmet edebilir.

Kalibrasyon teknikleri

Platt ölçekleme ve diğer kalibrasyon yöntemleri, softmax’ten elde edilen güven skorlarının gerçek olasılıklara karşılık gelmesini sağlamak için eğitim sonrası uygulanabilir. Bu yöntemler genellikle, orijinal model çıktılarının iyi kalibre edilmiş olasılıklara eşlenmesi için parametreleri öğrenmek üzere bir doğrulama seti kullanır.

Örneğin, daha önce bahsedilen basit bir sıcaklık ölçekleme yaklaşımı, kalibrasyon hatasını en aza indirmek için doğrulama verileri üzerinde optimize edilebilir. Daha karmaşık yaklaşımlar arasında izotonik regresyon ve Bayesian bölme bulunur.

Softmax darboğazı

Son araştırmalar, "softmax darboğazı" olarak bilinen softmax fonksiyonunun temel bir sınırlamasını ortaya koymuştur. Bu, softmax tabanlı dil modellerinin ifadelerinin, son katmandaki ağırlık matrisinin rütbesiyle sınırlı olduğu gerçeğine işaret eder. Doğal dil bağlamlarında karmaşık bağımlılıklarla, bu durum modellerin altta yatan koşullu dağılımları tam olarak yakalamasını engelleyebilir.

Bu sınırlamayı ele almak için, birden fazla softmax dağılımının ağırlıklı kombinasyonunu kullanan Softmax Karışımı (Mixture of Softmaxes, MoS) gibi gelişmiş mimariler önerilmiştir.

Bu yaygın sorunların farkında olarak ve uygun çözümleri uygulayarak, sınıflandırma görevlerinde softmax aktivasyon fonksiyonunu kullanan modellerin güvenilirliğini ve performansını artırabilirsiniz.

Sonuç

Softmax aktivasyon fonksiyonu, çok sınıflı sınıflandırma problemleri için sinir ağlarının vazgeçilmez bir bileşenidir; ham logitleri yorumlanabilir olasılık dağılımlarına dönüştürür. Matematiksel temelini, Python’daki uygulamasını, sigmoid ile karşılaştırmasını, pratik kullanım alanlarını ve sayısal kararsızlık ile aşırı özgüven gibi yaygın zorluklara yönelik teknikleri inceledik.

Sinir ağları hakkındaki bilginizi derinleştirmeye hazır mısınız? 

• Şu Aktivasyon Fonksiyonlarına Giriş eğitimimize göz atın veya çerçeveye özel kurslara dalın: Keras ile Derin Öğrenmeye Giriş ve PyTorch.
• Diğer önemli aktivasyon fonksiyonları hakkında bilgi edinmek için ReLU hakkındaki makalemize göz atın ve bugün daha etkili sinir ağları oluşturmaya başlayın!