Batch Normalisering

Batch normalisering er en transformerende teknik inden for deep learning, der markant forbedrer træningsprocessen af neurale netværk. Teknikken blev introduceret af Sergey Ioffe og Christian Szegedy i 2015 og adresserer problemet med intern covariate shift, som refererer til ændringer i fordelingen af netværkets aktiveringer under træning. Denne ordlistepost dykker ned i detaljerne omkring batch normalisering og udforsker dens mekanismer, anvendelser og fordele i moderne deep learning-modeller.

Hvad er Batch Normalisering?

Batch normalisering er en metode, der bruges til at stabilisere og accelerere træningen af kunstige neurale netværk. Den normaliserer inputtene til hvert lag i et netværk ved at justere og skalere aktiveringerne. Denne proces indebærer at beregne gennemsnittet og variansen af hver feature i et mini-batch og bruge disse statistikker til at normalisere aktiveringerne. Ved at gøre dette sikrer batch normalisering, at inputtene til hvert lag har en stabil fordeling, hvilket er afgørende for effektiv træning.

Intern Covariate Shift

Intern covariate shift er et fænomen, hvor fordelingen af input til et lag i et neuralt netværk ændrer sig under træning. Dette sker, fordi parametrene i de foregående lag opdateres og ændrer aktiveringerne, der sendes videre. Batch normalisering afhjælper dette problem ved at normalisere inputtene til hvert lag, hvilket sikrer en ensartet inputfordeling og dermed muliggør en mere glidende og effektiv træningsproces.

Mekanismen bag Batch Normalisering

Batch normalisering implementeres som et lag i et neuralt netværk og udfører flere operationer under forward pass:

1. Beregning af Gennemsnit og Varians: For mini-batchen beregnes gennemsnittet ($\mu_B$) og variansen ($\sigma_B^2$) for hver feature.
2. Normalisering af Aktiveringer: Gennemsnittet trækkes fra hver aktivering, og der divideres med standardafvigelsen, så de normaliserede aktiveringer får gennemsnit nul og varians én. En lille konstant epsilon ($\epsilon$) tilføjes for at undgå division med nul.
3. Skalering og Forskydning: Lærbare parametre gamma ($\gamma$) og beta ($\beta$) anvendes til at skalere og forskyde de normaliserede aktiveringer. Dette gør det muligt for netværket at lære den optimale skalering og forskydning for inputtene til hvert lag.

Matematisk udtrykkes dette for en feature $x_i$ som:

$$ \hat{x_i} = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}} $$

$$ y_i = \gamma \hat{x_i} + \beta $$

Fordele ved Batch Normalisering

1. Accelereret Træning: Ved at adressere intern covariate shift muliggør batch normalisering hurtigere konvergens og brugen af højere læringsrater uden risiko for divergens.
2. Forbedret Stabilitet: Den stabiliserer træningsprocessen ved at opretholde konsistente inputfordelinger gennem lagene, hvilket reducerer risikoen for forsvindende eller eksploderende gradienter.
3. Regulariseringseffekt: Batch normalisering introducerer en let regularisering og kan potentielt mindske behovet for andre teknikker som dropout.
4. Reduceret Følsomhed over for Initialisering: Den mindsker modellens afhængighed af de initiale vægtværdier og gør det lettere at træne dybere netværk.
5. Fleksibilitet: De lærbare parametre ($\gamma$) og ($\beta$) tilføjer fleksibilitet, så modellen adaptivt kan skalere og forskyde input.

Anvendelser og Brugstilfælde

Batch normalisering bruges bredt i forskellige deep learning-opgaver og -arkitekturer, herunder:

• Billedklassificering: Forbedrer træningen af convolutional neural networks (CNNs) ved at stabilisere input på tværs af lagene.
• Naturlig Sprogbehandling (NLP): Forbedrer ydeevnen i recurrent neural networks (RNNs) og transformer-arkitekturer ved at stabilisere inputfordelinger.
• Generative Modeller: Bruges i generative adversarial networks (GANs) til at stabilisere træningen af både generator- og discriminator-netværk.

Eksempel i TensorFlow

I TensorFlow kan batch normalisering implementeres via tf.keras.layers.BatchNormalization()-laget:

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, input_shape=(784,)),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Activation('relu'),
    tf.keras.layers.Dense(10),
    tf.keras.layers.Activation('softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5, batch_size=32)

Eksempel i PyTorch

I PyTorch implementeres batch normalisering med nn.BatchNorm1d for fuldt forbundne lag eller nn.BatchNorm2d for convolutionelle lag:

import torch
import torch.nn as nn

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(784, 64)
        self.bn = nn.BatchNorm1d(64)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(64, 10)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        x = self.fc1(x)
        x = self.bn(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x

model = Model()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

Batch normalisering er en uundværlig teknik for deep learning-praktikere, der adresserer interne covariate shifts og muliggør hurtigere og mere stabil træning af neurale netværk. Dens integration i populære frameworks som TensorFlow og PyTorch har gjort den tilgængelig og bredt anvendt, hvilket har ført til markante forbedringer i ydeevne på tværs af mange anvendelser. I takt med at kunstig intelligens udvikler sig, forbliver batch normalisering et centralt værktøj til at optimere træningen af neurale netværk.