Softmax-activatiefunctie in Python: een complete gids

Activatiefuncties vormen de ruggengraat van neurale netwerken. Het zijn belangrijke bouwstenen die non-lineariteit introduceren en deze netwerken in staat stellen complexe patronen te leren. De softmax-activatiefunctie is daarbij vooral van belang wanneer je te maken hebt met classificatieproblemen met meerdere klassen.

Hoewel alternatieven zoals Sigmoid en ReLU hun specifieke toepassingen hebben, is softmax beter in situaties waarin uitgangen geïnterpreteerd moeten worden als kansen over wederzijds uitsluitende klassen.

De softmax-activatiefunctie zet een hele vector met getallen om in een kansverdeling. Deze unieke eigenschap maakt haar onmisbaar voor taken waarbij we invoer moeten indelen in één van meerdere mogelijke categorieën.

Van beeldherkenningssystemen die duizenden objectcategorieën identificeren tot NLP-modellen die het volgende woord in een zin voorspellen: softmax levert de wiskundige basis om beslissingen te nemen over meerdere mogelijkheden.

In dit artikel bekijken we wat de softmax-activatiefunctie is, hoe ze wiskundig werkt en wanneer je haar zou moeten gebruiken in je neurale netwerk-architecturen. We bekijken ook praktische implementaties in Python.

Wat is de softmax-activatiefunctie?

De softmax-activatiefunctie is een wiskundige functie die een vector met ruwe modeluitgangen, zogenaamde logits, omzet in een kansverdeling. Simpel gezegd: ze neemt een set getallen en zet die om naar kansen die optellen tot 1.

In tegenstelling tot sommige activatiefuncties die onafhankelijk op individuele waarden werken, werkt softmax op een hele vector waarden en transformeert die gezamenlijk tot een kansverdeling waarbij alle elementen exact tot 1 optellen.

In de context van neurale netwerken wordt softmax doorgaans toegepast op de laatste laag van een netwerk dat is ontworpen voor multi-class classificatie. Wanneer we meerdere mogelijke categorieën hebben en ons model de kans van elke categorie moet aangeven, is de softmax-activatiefunctie de standaardkeuze.

Hoe werkt de softmax-functie?

De ruwe uitgangen van de laatste laag van een neuraal netwerk worden vaak "logits" genoemd. Deze waarden kunnen variëren van min oneindig tot plus oneindig en hebben geen directe probabilistische interpretatie. De softmax-activatiefunctie zet deze logits om naar een beter interpreteerbare vorm door:

1. De exponent van elke invoerwaarde te nemen (waardoor alle waarden positief worden).
2. Elke exponent te delen door de som van alle exponenten (waardoor de uitgangen tot 1 optellen).

Deze transformatie is cruciaal omdat we hierdoor de uitgang van het netwerk kunnen interpreteren als een kansverdeling. Als een neuraal netwerk bijvoorbeeld afbeeldingen classificeert in drie categorieën (kat, hond, vogel), dan kan de softmax-uitgang [0,7, 0,2, 0,1] zijn, wat een kans van 70% voor kat, 20% voor hond en 10% voor vogel aangeeft.

De softmax-activatiefunctie speelt een vitale rol bij het creëren van geldige kansverdelingen omdat:

• Ze ervoor zorgt dat alle uitgangswaarden tussen 0 en 1 liggen.
• Ze garandeert dat alle uitgangen exact tot 1 optellen.
• Ze de rangorde van invoerwaarden behoudt (grotere invoer levert grotere kansen op).
• Ze verschillen tussen grotere waarden accentueert en verschillen tussen kleinere waarden onderdrukt.

Softmax-activatiefunctie

De bovenstaande visualisatie laat zien hoe de softmax-activatiefunctie ruwe logits (de invoerwaarden 2,0, 1,0 en 0,5) omzet in een kansverdeling (0,7, 0,2 en 0,1). De formule in het softmax-blok geeft weer hoe elke uitgaande kans wordt berekend door de exponent van een invoerwaarde te nemen en te delen door de som van alle exponenten. 

De belangrijkste eigenschappen aan de rechterkant geven aan waarom softmax nuttig is voor classificatieproblemen met meerdere klassen. In de volgende sectie kijken we naar de wiskundige formule en hoe die werkt.

Softmax-activatiefunctie: formule en werking

Nu we begrijpen wat de softmax-activatiefunctie is, bekijken we de wiskundige formulering en hoe ze invoer omzet in kansverdelingen.

De formule voor de softmax-activatiefunctie kan wiskundig worden uitgedrukt als:

Waarbij:

• ​z_i de invoerwaarde (logit) is voor klasse i
• e^z_i de exponentiële functie is toegepast op z_i (ook geschreven als exp(z_i ​))
• K het totale aantal klassen is
• De noemer de exponenten van alle invoerwaarden optelt, zodat de uitgangen tot 1 optellen

De softmax-activatiefunctie volgt deze stappen om een vector met invoerwaarden om te zetten in een kansverdeling:

1. Exponentiëlen berekenen: eerst berekenen we de exponent (e^x) van elke invoerwaarde. Deze stap zorgt ervoor dat alle waarden positief zijn, aangezien e^x > 0 voor elk reëel getal x
2. Som van de exponentiëlen: we berekenen de som van alle exponentiële waarden uit stap 1.
3. Normaliseren: we delen elke exponentiële waarde door de som uit stap 2. Deze normalisatie zorgt ervoor dat alle uitgangen tussen 0 en 1 liggen en exact tot 1 optellen.

Laten we de softmax-formule toepassen op een eenvoudig voorbeeld om te zien hoe dit in de praktijk werkt.

Stel dat we een neuraal netwerk hebben met drie outputneuronen voor een classificatieprobleem met drie klassen (bijv. bepalen of een afbeelding een kat, hond of vogel bevat). Na de laatste berekening geeft het netwerk de volgende logits: z = [2,0, 1,0, 0,5].

Om deze logits met de softmax-functie om te zetten in kansen:

1. Exponentiëlen berekenen:
• e^2,0 = 7,389
• e^1,0 = 2,718
• e^0,5 = 1,648
2. Som van de exponentiëlen:
• 7,389 + 2,718 + 1,648 = 11,755
3. Normaliseren:
• P(klasse 1) = 7,389 / 11,755 ≈ 0,628 of 62,8%
• P(klasse 2) = 2,718 / 11,755 ≈ 0,231 of 23,1%
• P(klasse 3) = 1,648 / 11,755 ≈ 0,140 of 14,0%

De resulterende kansverdeling [0,628, 0,231, 0,140] telt op tot 1, met de hoogste kans toegekend aan de klasse die overeenkomt met de hoogste logitwaarde. Dit voorbeeld laat zien hoe de softmax-activatiefunctie de rangorde van invoerwaarden behoudt, terwijl ze deze omzet naar een geldige kansverdeling.

Merk op hoe de oorspronkelijke invoerwaarden (2,0, 1,0, 0,5) hun relatieve rangorde behouden in de uitgaande kansen, maar de verschillen ertussen zijn uitvergroot. Deze eigenschap maakt softmax bijzonder nuttig in classificatietaken waarbij we met vertrouwen de meest waarschijnlijke klasse willen identificeren.

In de volgende sectie bekijken we de verschillende manieren om de softmax-activatiefunctie te implementeren met Python.

Softmax-activatiefunctie implementeren in Python

Nu we de theorie achter de softmax-activatiefunctie begrijpen, bekijken we hoe je die in Python implementeert. We beginnen met het zelf schrijven van een softmax-functie met NumPy en kijken daarna hoe je haar gebruikt met populaire deep-learningframeworks zoals TensorFlow/Keras en PyTorch.

Softmax from scratch schrijven met NumPy

Voordat we in frameworks duiken, is het belangrijk te begrijpen hoe je de softmax-activatiefunctie from scratch implementeert. Dit helpt om intuïtie op te bouwen voor wat er onder de motorkap gebeurt.

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 probabilitiesMogelijk gemaakt door

Deze implementatie volgt de softmax-formule precies, met één belangrijke toevoeging: we trekken vóór de exponentiatie de maximale waarde van elke invoervector af. 

Deze "shift"-bewerking verandert het wiskundige resultaat niet, maar helpt numerieke overloop te voorkomen, wat kan optreden bij het berekenen van exponenten van grote getallen.

Laten we onze implementatie testen met een eenvoudig voorbeeld:

# 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))Mogelijk gemaakt door

Output:

Als we de bovenstaande code uitvoeren, zien we dat de som van de kansen voor elk voorbeeld gelijk is aan 1, wat bevestigt dat onze softmax-implementatie geldige kansverdelingen oplevert. Voor het eerste voorbeeld komt de grootste kans overeen met de grootste logit (2,0), en hetzelfde geldt voor het tweede voorbeeld.

Softmax gebruiken in TensorFlow/Keras

TensorFlow en Keras maken het eenvoudig om de softmax-activatiefunctie in je neurale netwerken te gebruiken. Laten we stap voor stap een eenvoudige classifier voor de MNIST-dataset bouwen.

Eerst importeren we de benodigde libraries en laden we de dataset:

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)Mogelijk gemaakt door

De MNIST-dataset bevat grijswaardenafbeeldingen van 28x28 pixels van handgeschreven cijfers (0-9). We normaliseren de pixelwaarden naar tussen 0 en 1 voor betere trainingsdynamiek en zetten de klasselabels om naar one-hot encoding, het voorkeursformaat voor softmax-uitgangen.

Laten we nu een neuraal netwerkmodel maken met een softmax-uitgangslaag:

# 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
])Mogelijk gemaakt door

Hier laten we twee gelijkwaardige manieren zien om de softmax-activatiefunctie in een neuraal netwerk op te nemen:

• Methode 1: direct 'softmax' als activatiefunctie opgeven in de laatste Dense-laag
• Methode 2: een aparte Softmax-laag toevoegen na de Dense-laag die ruwe logits uitgeeft

Beide benaderingen leveren identieke resultaten op, maar de tweede methode maakt het onderscheid tussen logits en kansen explicieter, wat in bepaalde scenario's handig kan zijn.

Vervolgens compileren en trainen we het model:

# 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
)Mogelijk gemaakt door

Output:

We compileren het model met de categorische cross-entropy-verliesfunctie, die is ontworpen om te werken met softmax-uitgangen. Deze verliesfunctie meet het verschil tussen de voorspelde kansverdeling en de ware one-hot-encoded labels. We gebruiken de Adam-optimizer, die de leersnelheid tijdens het trainen adaptief aanpast.

Na het trainen kunnen we het model gebruiken om voorspellingen te doen en de resultaten te visualiseren:

# 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')Mogelijk gemaakt door

Deze code selecteert een testafbeelding, stuurt die door het getrainde model en visualiseert zowel de afbeelding als de resulterende kansverdeling van de softmax-uitgang. De hoogste balk in de kansgrafiek vertegenwoordigt de voorspelling van het model.

Output:

TensorFlow biedt ook een ingebouwde functie om softmax direct toe te passen:

# 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())Mogelijk gemaakt door

Output:

Dit voorbeeld vergelijkt een aangepaste implementatie van softmax met de ingebouwde tf.nn.softmax()-functie van TensorFlow. Beide zouden identieke resultaten moeten opleveren. De aangepaste implementatie bevat ook de numerieke stabiliteitstruc waarbij de maximale waarde wordt afgetrokken vóór de exponentiatie.

Softmax gebruiken in PyTorch

Laten we nu een vergelijkbaar model implementeren met PyTorch en de CIFAR-10-dataset. We beginnen met het importeren van libraries en het inrichten van de data, zoals hieronder getoond:

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')Mogelijk gemaakt door

De bovenstaande code stelt PyTorch in om GPU-versnelling te gebruiken als die beschikbaar is, laadt de CIFAR-10-dataset (met 32x32 kleurenafbeeldingen in 10 klassen) en bereidt dataloaders voor op training en testen.

Vervolgens definiëren we een eenvoudig convolutioneel neuraal netwerk zoals hieronder getoond:

# 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 xMogelijk gemaakt door

Deze CNN verwerkt de 32x32 RGB-afbeeldingen via convolutionele lagen, past ReLU-activatie en pooling toe en eindigt met volledig verbonden lagen. Opvallend is dat het model geen softmax-laag in de forward pass bevat. In plaats daarvan geeft het ruwe logits uit.

Dit is een gangbaar patroon in PyTorch, omdat de functie CrossEntropyLoss tijdens training intern softmax toepast vóór het verlies te berekenen, wat numeriek stabieler is. 

Laten we ook bekijken hoe je desgewenst expliciet softmax opneemt:

# 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 probabilitiesMogelijk gemaakt door

We definiëren twee modelvarianten: SimpleCNN geeft ruwe logits, terwijl ModelWithSoftmax expliciet softmax toepast om kansen te produceren. Voor training gebruiken we SimpleCNN met CrossEntropyLoss, wat de standaardaanpak in PyTorch is.

Laten we een trainingsfunctie definiëren:

# 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')Mogelijk gemaakt door

Tot slot maken we een functie om modelvoorspellingen te visualiseren:

# 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()Mogelijk gemaakt door

Deze functie laat zien hoe je tijdens inferentie softmax-kansen uit een getraind model haalt. Ze stuurt een afbeelding door het model om logits te krijgen, past handmatig softmax toe met torch.nn.functional.softmax() en visualiseert vervolgens zowel de afbeelding als de resulterende kansverdeling.

Laten we nu het model trainen:

train_model()Mogelijk gemaakt door

Output:

Laten we voorspellen en kijken hoe de kansen eruitzien voor een testafbeelding:

show_prediction_example()Mogelijk gemaakt door

Output:

In de volgende sectie bekijken we de specifieke scenario's waarin softmax de optimale keuze is, wanneer je de softmax-activatiefunctie zou moeten gebruiken, en bespreken we toepassingen in de echte wereld in diverse deep-learningmodellen.

Wanneer gebruik je de softmax-activatiefunctie?

Begrijpen wanneer je de softmax-activatiefunctie gebruikt, is belangrijk voor het ontwerpen van effectieve neurale netwerken. De softmax-activatiefunctie wordt primair toegepast in de uitgangslaag van neurale netwerken die zijn ontworpen voor classificatietaken.

Softmax voor multi-class classificatie

Softmax is de standaardkeuze wanneer ons model invoer moet indelen in één van meerdere wederzijds uitsluitende categorieën. Veelvoorkomende voorbeelden zijn:

• Beeldclassificatie (objecten in foto's identificeren)
• Documentcategorisatie (onderwerpen aan tekst toekennen)
• Named entity recognition (persoonnamen, locaties, enz. identificeren)
• Spraakherkenning (audio naar tekst omzetten)

Probabilistische interpretatie en betrouwbaarheidscores

Wanneer we willen dat ons model kansen uitgeeft in plaats van alleen klassevoorspellingen, biedt softmax een probabilistische interpretatie van het vertrouwen van het model over alle mogelijke klassen.

Softmax in reinforcement learning en attention-mechanismen

In reinforcement learning en sequentiële beslissingsproblemen kan softmax worden gebruikt om actie-waarden om te zetten in een kansverdeling voor actieselectie.

Moderne transformer-gebaseerde architecturen gebruiken softmax om aandacht te verdelen over verschillende delen van de invoersequentie.

De sterke wiskundige basis en de intuïtieve probabilistische interpretatie maken de softmax-activatiefunctie bijzonder geschikt voor classificatieproblemen waarbij klassen wederzijds uitsluiten.

Deep-learningmodellen

Verschillende deep-learningarchitecturen gebruiken de softmax-activatiefunctie. 

Beeldclassificatienetwerken zoals ResNet, VGG en Inception gebruiken allemaal softmax in hun laatste laag om afbeeldingen in duizenden categorieën te classificeren. Modellen die op ImageNet zijn getraind, hebben bijvoorbeeld typisch een softmax-laag met 1000 eenheden die overeenkomen met 1000 objectcategorieën.

In taalmodellering gebruiken op RNN gebaseerde modellen softmax om het volgende woord in een reeks te voorspellen uit een vocabulaire dat tienduizenden woorden kan bevatten.

Moderne NLP-architecturen zoals BERT, GPT en T5 gebruiken softmax in meerdere componenten:

• In attention-mechanismen om te bepalen hoeveel focus op verschillende delen van de input gelegd moet worden
• In de laatste classificatielaag voor taken zoals sentimentanalyse of documentclassificatie

Variational Autoencoders (VAE's) en bepaalde Generative Adversarial Networks (GAN's) gebruiken softmax in hun discriminatorcomponenten of voor categorische latente variabelen.

In de volgende sectie bekijken we de verschillen tussen de softmax- en de sigmoid-activatiefunctie.

Softmax versus sigmoid-activatiefunctie

De sigmoidfunctie, gedefinieerd als σ(x) = 1/(1+e^(-x)), zet één reëel getal om in een waarde tussen 0 en 1. De softmax-activatiefunctie daarentegen werkt op een vector van getallen en zet die om in een kansverdeling.

Hier zijn de fundamentele verschillen tussen deze twee activatiefuncties:

Invoer- en uitvoerdimensies

• Sigmoid: neemt een enkele scalair als invoer en produceert een enkele scalair tussen 0 en 1.
• Softmax: neemt een vector van n invoeren en produceert een vector van n uitgangen die optellen tot 1.

Kansinterpretatie

• Sigmoid: de uitgang stelt de kans voor van één binaire gebeurtenis (bijv. "Is deze e-mail spam?").
• Softmax: de uitgangen stellen kansen voor over meerdere wederzijds uitsluitende klassen (bijv. "Welk cijfer van 0-9 is dit?").

Onafhankelijkheid van uitgangen

• Sigmoid: wanneer gebruikt over meerdere neuronen zijn de uitgangen onderling onafhankelijk. Meerdere uitgangen kunnen allemaal hoog of allemaal laag zijn.
• Softmax: uitgangen zijn onderling afhankelijk—als één kans toeneemt, moeten andere afnemen om tot 1 te blijven optellen.

Wiskundige relatie

Interessant is dat de sigmoidfunctie eigenlijk een speciaal geval is van de softmax-activatiefunctie wanneer er slechts twee klassen zijn. Daarom wordt sigmoid vaak "binaire softmax" genoemd.

Wanneer softmax gebruiken en wanneer sigmoid

De juiste activatiefunctie kiezen is cruciaal om te zorgen dat een neuraal netwerk betekenisvolle voorspellingen doet. De keuze tussen softmax en sigmoid hangt af van de aard van de classificatietaak.

Gebruik sigmoid wanneer:

• Je binaire classificatieproblemen oplost (twee klassen)
• Elke uitgang onafhankelijk geïnterpreteerd moet worden
• Je multi-labelclassificatie implementeert waarbij een instantie tot meerdere klassen tegelijk kan behoren
• Je attention-mechanismen of gates in recurrente neurale netwerken maakt

Gebruik softmax wanneer:

• Je te maken hebt met classificatieproblemen met meerdere klassen (meer dan twee)
• Klassen wederzijds uitsluiten (een invoer behoort tot precies één klasse)
• Je een correcte kansverdeling over alle mogelijke uitkomsten nodig hebt
• Je de laatste laag van de meeste beeldclassificatienetwerken implementeert

In een neuraal netwerk dat afbeeldingen van handgeschreven cijfers (0-9) classificeert, is de softmax-activatiefunctie bijvoorbeeld geschikt voor de uitgangslaag, omdat elke afbeelding precies één cijfer voorstelt. Voor een netwerk dat meerdere objecten in een afbeelding detecteert (bijv. "bevat persoon", "bevat auto", "bevat boom"), zijn sigmoid-activaties geschikter omdat meerdere objecten tegelijk aanwezig kunnen zijn.

Hier is een snelle referentietabel waarin de softmax- versus sigmoid-activatiefunctie wordt vergeleken:

Het onderscheid tussen deze activatiefuncties begrijpen is cruciaal voor het ontwerpen van effectieve neurale netwerken. Hoewel de softmax-activatiefunctie de standaardkeuze is voor multi-class classificatieproblemen, blijft sigmoid waardevol voor binaire classificatie en problemen die onafhankelijke kansen vereisen.

In de volgende sectie bekijken we de veelvoorkomende problemen en overwegingen bij het werken met softmax-activatiefuncties.

Veelvoorkomende problemen en overwegingen

Bij het werken met de softmax-activatiefunctie in je deep-learningmodellen kunnen verschillende uitdagingen de modelprestatie en betrouwbaarheid beïnvloeden. Als je deze problemen begrijpt en weet hoe je ze aanpakt, bouw je robuustere modellen.

Uitdagingen met numerieke stabiliteit

Numerieke stabiliteit is een cruciaal aandachtspunt bij softmax. De exponentiële bewerking in de softmax-formule kan tot numerieke over- of onderloop leiden als die niet goed wordt behandeld.

Bijvoorbeeld, bij zeer grote invoerwaarden (zoals 1000 of hoger) produceert de exponentiële functie extreem grote getallen die de maximaal representabele zwevendekommawaarde op je systeem kunnen overschrijden. Dit leidt tot overflow-fouten en "oneindig"-waarden, waardoor de uiteindelijke deling ongedefinieerde resultaten (NaN - Not a Number) kan opleveren.

De standaardoplossing, zoals genoemd in onze implementatiesectie, is om de maximale waarde van alle invoeren af te trekken vóór toepassing van de exponentiële functie. Deze shift verandert de relatieve verhoudingen na normalisatie niet, maar houdt de waarden binnen een beheersbaar bereik. 

Moderne deep-learningframeworks handelen dit probleem intern af, maar het is belangrijk het te begrijpen wanneer je aangepaste operaties implementeert of onverwacht gedrag debugt.

Softmax en overmatig zelfvertrouwen in voorspellingen

Een ander veelvoorkomend probleem met softmax is dat neurale netwerken de neiging hebben overmatig zelfverzekerd te zijn in hun voorspellingen, zelfs wanneer die fout zijn. Dit oververtrouwen ontstaat omdat:

1. De exponentiële aard van softmax kleine verschillen in logits versterkt.
2. Moderne diepe neurale netwerken krachtig genoeg zijn om trainingsdata perfect te memoriseren.
3. Cross-entropy-verlies kansen voor correcte klassen naar 1 blijft duwen, zelfs nadat een model al een goede nauwkeurigheid heeft bereikt.

In de praktijk kan dit betekenen dat een model 99% kans toekent aan een voorspelling die eigenlijk onjuist is. Dit kan problematisch zijn in kritieke toepassingen waar betrouwbare onzekerheidsschatting essentieel is. Bijvoorbeeld, een medisch diagnosesysteem dat te zelfverzekerd is in foutieve voorspellingen kan leiden tot onjuiste behandelbeslissingen.

Het verschil tussen het vertrouwen van een model (afgeleid van softmax-kansen) en de feitelijke nauwkeurigheid staat bekend als calibratiefout. Goed gekalibreerde modellen produceren betrouwbaarheidscores die overeenkomen met hun nauwkeurigheidspercentages—als een model gebeurtenissen met 80% vertrouwen voorspelt, zouden die gebeurtenissen ongeveer 80% van de tijd moeten voorkomen.

Regularisatietechnieken om de prestaties te verbeteren

Gelukkig zijn er verschillende technieken die helpen deze softmax-problemen aan te pakken:

Temperatuurschaling

Temperatuurschaling introduceert een parameter T die de "zachtheid" van de kansverdeling regelt. Door de logits te delen door deze temperatuurparameter vóór toepassing van softmax, kun je afstellen hoe scherp of uniform de resulterende verdeling wordt.

Hogere temperaturen (T > 1) leveren zachtere kansverdelingen op met minder extreme waarden, wat kan helpen oververtrouwen te verminderen. Lagere temperaturen (T < 1) maken de verdeling spitser rond de hoogste waarde. Temperatuurschaling wordt vaak als post-processing na training gebruikt om het modelvertrouwen te kalibreren zonder de rangorde van klassen te beïnvloeden.

Label smoothing

Label smoothing vervangt harde one-hot-doelvectoren door licht afgevlakte verdelingen. In plaats van het model te trainen op exacte nullen en enen, moedigt label smoothing het model aan iets minder zeker te zijn door te mikken op waarden als 0,9 voor de juiste klasse en 0,025 voor onjuiste klassen (in een 4-klassenprobleem).

Door met deze afgevlakte labels te trainen, leert het model minder zelfverzekerd te zijn in zijn voorspellingen, wat de generalisatie verbetert en het model robuuster maakt voor labelruis. Deze techniek is standaardpraktijk geworden in veel state-of-the-art beeldclassificatiemodellen.

Dropout en ensemblemethoden

Dropout tijdens training gebruiken en die ingeschakeld houden tijdens inferentie (een techniek genaamd Monte Carlo-dropout) stelt je in staat meerdere voorspellingen voor dezelfde invoer te sampelen en onzekerheid te schatten. Als het model consistente voorspellingen produceert over meerdere voorwaartse passes met verschillende dropoutpatronen, is het waarschijnlijk zekerder over zijn voorspelling.

Evenzo combineren ensemblemethoden voorspellingen van meerdere modellen om prestaties te verbeteren en betere onzekerheidsschattingen te geven. De mate van onenigheid tussen modellen in een ensemble kan dienen als maat voor onzekerheid.

Kalibratietechnieken

Platt-schaaling en andere kalibratiemethoden kunnen na de training worden toegepast om ervoor te zorgen dat de betrouwbaarheidscores van softmax daadwerkelijk overeenkomen met echte kansen. Deze methoden gebruiken doorgaans een validatieset om parameters te leren die de oorspronkelijke modeluitgangen omzetten naar goed gekalibreerde kansen.

Een eenvoudige temperatuurschaling (zoals eerder genoemd) kan bijvoorbeeld op validatiedata worden geoptimaliseerd om de calibratiefout te minimaliseren. Complexere benaderingen zijn isotone regressie en Bayesian binning.

De softmax-bottleneck

Recente onderzoeken hebben een fundamentele beperking van softmax blootgelegd, bekend als de "softmax-bottleneck". Dit verwijst naar het feit dat de expressiviteit van op softmax gebaseerde taalmodellen wordt beperkt door de rang van de gewichts matrix in de laatste laag. In natuurlijke taalcontexten met complexe afhankelijkheden kan dit voorkomen dat modellen de onderliggende voorwaardelijke verdelingen volledig vastleggen.

Geavanceerde architecturen zoals Mixture of Softmaxes (MoS) zijn voorgesteld om deze beperking aan te pakken door een gewogen combinatie van meerdere softmax-verdelingen te gebruiken.

Door je bewust te zijn van deze veelvoorkomende problemen en passende oplossingen te implementeren, kun je de betrouwbaarheid en prestaties verbeteren van modellen die de softmax-activatiefunctie gebruiken voor classificatietaken.

Conclusie

De softmax-activatiefunctie is een essentieel onderdeel van neurale netwerken voor classificatieproblemen met meerdere klassen. Ze zet ruwe logits om in interpreteerbare kansverdelingen. We hebben de wiskundige basis, implementatie in Python, vergelijking met sigmoid, praktische use-cases en technieken om veelvoorkomende uitdagingen zoals numerieke instabiliteit en oververtrouwen aan te pakken, behandeld.

Klaar om je begrip van neurale netwerken te verdiepen? 

• Bekijk onze Introductie tot activatiefuncties-tutorial of duik in frameworkspecifieke cursussen over Deep Learning met Keras en PyTorch.
• Wil je andere belangrijke activatiefuncties leren kennen? Bekijk dan ons artikel over ReLU en begin vandaag nog met het bouwen van effectievere neurale netwerken!