Batch-normalisatie: theorie en TensorFlow-implementatie

Het trainen van diepe neurale netwerken kan lastig zijn door verdwijnende of exploderende gradiënten en interne covariaatverschuiving. Deze factoren kunnen het trainingsproces aanzienlijk vertragen en het leervermogen van het netwerk belemmeren. Gelukkig kunnen we deze problemen aanpakken met normalisatietechnieken.

Hoewel er veel normalisatietechnieken zijn, is batch-normalisatie een van de populairste en een standaardonderdeel geworden in veel deep-learningarchitecturen. Het zorgt voor snellere convergentie, betere trainingsstabiliteit en een sterkere generalisatie.

In deze tutorial leggen we uit wat batch-normalisatie is, hoe het wiskundig werkt en hoe je het implementeert met TensorFlow en Keras.

Wil je de basis van neurale netwerken met Keras leren? Bekijk dan de cursus Introduction to Deep Learning in Python.

Wat is normalisatie in machine learning?

Normalisatie is een cruciale preprocessing-stap in machine learning die erop gericht is de invoergegevens te standaardiseren.

Verschillende normalisatietechnieken, zoals min-max-scaling, z-score-normalisatie en logtransformatie, worden vaak gebruikt om features te herschalen naar een consistente range of verdeling. Deze technieken helpen de impact van uitschieters te beperken, de convergentie te verbeteren en een eerlijke vergelijking tussen features te waarborgen.

Het normaliseren van invoerdata is essentieel voor effectieve modeltraining, omdat het ervoor zorgt dat alle features evenveel bijdragen aan het leerproces. Zonder normalisatie kunnen features met grotere schalen of varianties het optimalisatieproces domineren, wat leidt tot suboptimale modelprestaties.

Normalisatie stelt het model in staat betekenisvolle patronen en relaties uit de data te leren door alle features op een vergelijkbare schaal te brengen.

Wil je in het algemeen meer leren over normalisatie? Bekijk dan deze tutorial: What is Normalization in Machine Learning.

Uitdagingen bij deep-learningtraining

Het trainen van diepe neurale netwerken kent verschillende uitdagingen die de convergentie en generalisatie kunnen belemmeren:

1. Interne covariaatverschuiving: Naarmate de invoerdata door meerdere lagen gaat, kan de verdeling van activaties veranderen, waardoor het voor het model lastig wordt zich aan te passen en effectief te leren.
2. Verdwijnende en exploderende gradiënten: Diepe netwerken kunnen last hebben van verdwijnende of exploderende gradiënten, waarbij gradiënten tijdens backpropagatie te klein of te groot worden, waardoor effectieve gewichtsupdates uitblijven.
3. Gevoeligheid voor initialisatie: De initiële gewichten van het netwerk hebben grote invloed op het trainingsproces; slechte initialisatie kan leiden tot trage convergentie of zelfs mislukte training.

Batch-normalisatie pakt deze uitdagingen aan door de activaties binnen elke minibatch te normaliseren, waardoor het trainingsproces stabieler wordt en de prestaties van het model verbeteren.

Wat is batch-normalisatie?

Batch-normalisatie is een techniek die tijdens het trainen van diepe neurale netwerken de activaties van een laag binnen een minibatch normaliseert.

Dit werkt door voor elk feature in de minibatch het gemiddelde en de variantie van de activaties te berekenen en vervolgens de activaties met deze statistieken te normaliseren.

De genormaliseerde activaties worden daarna geschaald en verschoven met leerbare parameters, zodat het model zich kan aanpassen aan de optimale activatieverdeling.

Bron: Yintai Ma en Diego Klabjan.

Batch-normalisatie wordt doorgaans toegepast na de lineaire transformatie van een laag (bijv. na de matrixvermenigvuldiging in een volledig verbonden laag of na de convolutie in een convolutionele laag) en vóór de niet-lineaire activatiefunctie (bijv. ReLU).

De belangrijkste componenten van batch-normalisatie zijn:

1. Minibatchstatistieken: Het gemiddelde en de variantie van de activaties worden voor elk feature binnen de minibatch berekend.
2. Normalisatie: De activaties worden genormaliseerd door het minibatchgemiddelde af te trekken en te delen door de minibatch-standaarddeviatie.
3. Schalen en verschuiven: Leerbare parameters (γ en β) worden geïntroduceerd om de genormaliseerde activaties te schalen en te verschuiven, zodat het model de optimale activatieverdeling kan leren.

Waarom batch-normalisatie gebruiken?

Een van de uitdagingen bij het trainen van diepe neurale netwerken is de interne covariaatverschuiving. Dit gebeurt wanneer de verdeling van activaties (uitgangen) van een laag verandert gedurende het trainingsproces doordat gewichten in vorige lagen worden bijgewerkt. Deze verschuiving kan training moeilijk en traag maken.

Batch-normalisatie vermindert deze verschuiving door de activaties binnen elke minibatch te normaliseren, waardoor de input voor volgende lagen stabieler en consistenter wordt.

Het normaliseren van activaties maakt snellere convergentie met hogere leersnelheden mogelijk en maakt het model minder gevoelig voor de keuze van initialisatie.

Daarnaast introduceert het een regulariserend effect dat overfitting helpt voorkomen door de afhankelijkheid van het model van specifieke activatiepatronen te verminderen.

Deze combinatie van voordelen maakt batch-normalisatie tot een krachtig hulpmiddel voor het trainen van robuustere deep-learningmodellen. Wil je meer leren over het bouwen van robuuste modellen? Bekijk dan deze cursus over Machine Learning Monitoring Concepts.

De wiskunde achter batch-normalisatie

Nu we het "waarom" achter batch-normalisatie begrijpen, duiken we in het "hoe".

Batch-normalisatie werkt anders tijdens training en tijdens inferentie, dus laten we de wiskunde achter beide fasen uitleggen.

Batch-normalisatie tijdens training

We beginnen met de normalisatiestap. We berekenen eerst het gemiddelde en de variantie voor elk feature in een minibatch. Dit zijn de formules voor het gemiddelde en de variantie.

Vervolgens gebruiken we het gemiddelde en de variantie om de activaties te normaliseren. Dit is de formule, waarbij de ε (kleine epsilon) een kleine constante is die wordt toegevoegd voor numerieke stabiliteit:

Na de normalisatiestap gaan we door met de schaal- en verschuivingsstap. Met de leerbare parameters γ en β verschuiven we de genormaliseerde activaties met deze formule:

Met deze parameters kan het model de optimale activatieverdeling leren.

Batch-normalisatie tijdens inferentie

Tijdens inferentie vervangen we de batchstatistieken (gemiddelde en variantie) door de lopende statistieken die tijdens training zijn berekend. De lopende statistieken worden doorgaans bijgewerkt met een voortschrijdend gemiddelde met een momentumfactor.

Om het lopende gemiddelde en de lopende variantie te berekenen, kunnen we deze twee formules gebruiken, waarbij α de momentumfactor is die de updatesnelheid van de lopende statistieken bepaalt:

Het lopende gemiddelde en de lopende variantie worden als modelparameters opgeslagen en tijdens inferentie voor normalisatie gebruikt. De schaal- en verschuivingsparameters (γ en β) die tijdens training zijn geleerd, worden tijdens inferentie ook gebruikt.

Laten we nu leren hoe je batch-normalisatie implementeert met TensorFlow.

Batch-normalisatie in TensorFlow

Laten we beginnen met het importeren van de benodigde libraries:

import tensorflow as tf 
from tensorflow import kerasMogelijk gemaakt door

Vervolgens laden we de MNIST-dataset, die bestaat uit 60.000 trainingsafbeeldingen en 10.000 testafbeeldingen van handgeschreven cijfers. We laden de dataset met de functie keras.datasets.mnist.load_data() en splitsen deze in trainingsdata (x_train, y_train) en testdata (x_test, y_test):

# Load the MNIST dataset
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()Mogelijk gemaakt door

Voor de preprocessing van de data nemen we de volgende stappen:

• We reshapen de trainings- en testafbeeldingen naar de vorm (num_samples, 28, 28, 1), waarbij num_samples het aantal afbeeldingen is, en elke afbeelding een 28x28-grijswaardenafbeelding met één kanaal is.
• We normaliseren de pixelwaarden van de afbeeldingen door ze te delen door 255,0, zodat ze tussen 0 en 1 liggen.
• We converteren de trainings- en testlabels naar categorisch formaat met keras.utils.to_categorical(), wat de integerlabels omzet naar one-hot-gecodeerde vectoren.

# Preprocess the data
x_train = x_train.reshape((60000, 28, 28, 1)) / 255.0  # Reshape and normalize training images
x_test = x_test.reshape((10000, 28, 28, 1)) / 255.0    # Reshape and normalize test images
y_train = keras.utils.to_categorical(y_train)         # Convert training labels to categorical format
y_test = keras.utils.to_categorical(y_test)           # Convert test labels to categorical formatMogelijk gemaakt door

Nu gaan we door naar de volgende stap: het definiëren van de modelarchitectuur. Daarvoor doen we het volgende:

• We definiëren de modelarchitectuur met de keras.Sequential-API, waarmee je lagen sequentieel kunt stapelen.
• Het model bestaat uit convolutionele lagen (Conv2D) voor feature-extractie, gevolgd door batch-normalisatielagen (BatchNormalization) om de activaties te normaliseren.
• We gebruiken maxpooling (MaxPooling2D) om de featuremaps te downsamplen.
• We flattenen de featuremaps (Flatten) voordat we ze doorgeven aan de dense lagen.
• De laatste dense laag heeft 10 units met softmax-activatie, overeenkomend met de 10 cijferklassen.

# Define the model architecture
model = keras.Sequential([
    keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    keras.layers.BatchNormalization(),
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    keras.layers.BatchNormalization(),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.BatchNormalization(),
    keras.layers.Dense(10, activation='softmax')
])Mogelijk gemaakt door

• De Adam-optimizer ('adam') voor optimalisatie.
• Het categorische cross-entropieverlies ('categorical_crossentropy') als verliesfunctie, omdat dit een multiclass-classificatietaak is.
• Nauwkeurigheid ('accuracy') als evaluatiemetriek om de prestaties van het model te meten.

# Compile the model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])Mogelijk gemaakt door

Vervolgens trainen we het model met de methode .fit():

• We geven de trainingsdata (x_train, y_train), batchgrootte, aantal epochs en validatiedata (x_test, y_test) op.
• De batch_size bepaalt het aantal samples per gradiëntupdate.
• De parameter epochs geeft aan hoe vaak het model over de volledige trainingsdata heen iterereert.
• De validatiedata wordt gebruikt om de prestaties van het model op ongeziene data tijdens de training te evalueren.

# Train the model
model.fit(x_train, y_train, batch_size=128, epochs=5, validation_data=(x_test, y_test))Mogelijk gemaakt door

Door deze stappen te volgen en batch-normalisatielagen in de modelarchitectuur op te nemen, kunnen we het model efficiënt trainen op de MNIST-dataset, met voordeel van de normalisatie van activaties en verbeterde trainingsstabiliteit.

Nu we hebben geleerd wat batch-normalisatie is en hoe je het implementeert, bekijken we de voordelen.

Overwegingen bij de implementatie

Laten we nu dieper ingaan op de implementatie van batch-normalisatie in deep-learningarchitecturen.

Plaatsing in neurale netwerkarchitecturen

Batch-normalisatielagen werken het best wanneer ze strategisch in ons netwerk worden geplaatst. Meestal zet je ze na de lineaire transformatie (bijv. convolutionele of volledig verbonden lagen) en vóór de niet-lineaire activatiefunctie.

In convolutionele netwerken betekent dit dat je batch-normalisatie na elke convolutionele laag en vóór de activatiefunctie plaatst.

Evenzo is het in volledig verbonden netwerken gebruikelijk om batch-normalisatie toe te voegen na de lineaire transformatie en vóór de activatiefunctie van elke verborgen laag.

De plaatsing van batch-normalisatielagen kan invloed hebben op de prestaties en het trainingsgedrag van ons model. Experimenteren kan nodig zijn om de optimale configuratie voor elke specifieke netwerkarchitectuur te vinden.

Invloed van batchgrootte

De batchgrootte die tijdens training wordt gebruikt, kan de effectiviteit van batch-normalisatie beïnvloeden. Grotere batches leveren nauwkeurigere schattingen van de batchstatistieken (gemiddelde en variantie), wat leidt tot betere normalisatie en stabielere training.

Het vergroten van de batchgrootte verhoogt echter ook het geheugengebruik en de rekeneisen, wat een beperking kan zijn afhankelijk van de beschikbare hardware.

Het is belangrijk de batchgrootte en de rekentechnische haalbaarheid in balans te houden, terwijl je ervoor zorgt dat de batchstatistieken betrouwbaar blijven voor normalisatie.

Regularisatie-effecten en implicaties

Batch-normalisatie introduceert van nature een regularisatie-effect door de ruis die de minibatchstatistieken met zich meebrengen. De stochastiek die door de batchstatistieken wordt geïntroduceerd, werkt als een vorm van regularisatie, vermindert overfitting en verbetert de generalisatie.

Dit regularisatie-effect kan echter interacteren met andere regularisatietechnieken, zoals dropout of L2-regularisatie.

Wanneer je batch-normalisatie gebruikt, is het essentieel om rekening te houden met de samenhang tussen verschillende regularisatiemethoden en ze dienovereenkomstig aan te passen om over-regularisatie of verminderde prestaties te voorkomen.

Experimenteren en het monitoren van de modelprestaties op validatiedata kunnen helpen de juiste balans van regularisatietechnieken te vinden bij het gebruik van batch-normalisatie.

Beperkingen en uitdagingen van batch-normalisatie

Hoewel batch-normalisatie een nuttige techniek is, zijn er enkele beperkingen en uitdagingen waar we ons bewust van moeten zijn.

Batch-normalisatie in niet-convolutionele architecturen

Batch-normalisatie is oorspronkelijk ontworpen voor convolutionele neurale netwerken (CNN's) en is in dit domein bijzonder succesvol.

De effectiviteit in niet-convolutionele architecturen, zoals recurrente neurale netwerken (RNN's) of transformers, kan echter beperkt zijn.

De sequentiële aard van RNN's en de attention-mechanismen in transformers kunnen het toepassen van batch-normalisatie uitdagender maken.

Alternatieve normalisatietechnieken, zoals layer-normalisatie of instance-normalisatie, zijn voor deze architecturen mogelijk geschikter.

Kleine batchgroottes en prestaties tijdens inferentie

Batch-normalisatie is afhankelijk van de batchstatistieken die tijdens training zijn berekend om de activaties te normaliseren. Wanneer de batchgrootte klein is, kunnen de batchstatistieken minder betrouwbaar worden en ruis of instabiliteit in het normalisatieproces introduceren.

Dit kan leiden tot suboptimale prestaties of zelfs trainingsmoeilijkheden, vooral wanneer de batchgrootte wordt verkleind om geheugenbeperkingen op te vangen.

Tijdens inferentie gebruikt batch-normalisatie de lopende statistieken die tijdens training zijn berekend, die mogelijk niet nauwkeurig de statistieken van individuele samples of kleine batches weergeven. Dit kan leiden tot een mismatch tussen de verdelingen tijdens training en inferentie, wat de prestaties van het model kan beïnvloeden.

Nadelen en afwegingen van batch-normalisatie

Batch-normalisatie brengt extra rekenoverhead met zich mee tijdens training door de berekening van batchstatistieken en de normalisatiebewerking. Deze overhead kan het geheugenverbruik en de trainingstijd vergroten, vooral bij grote modellen of datasets.

Batch-normalisatie kan ongeschikt zijn voor bepaalde soorten data of taken waarbij het normalisatieproces belangrijke informatie kan vervormen of betekenisvolle variaties kan wegnemen.

Zo kan batch-normalisatie ongewenste effecten hebben bij taken met fijne details of precieze ruimtelijke informatie, zoals segmentatie of lokalisatie.

Het regularisatie-effect van batch-normalisatie kan soms op onverwachte manieren interageren met andere regularisatietechnieken, zoals dropout, wat zorgvuldige afstemming en overweging vereist.

Hoe de beperkingen van batch-normalisatie te mitigeren

Ondanks beperkingen en uitdagingen blijft batch-normalisatie een veelgebruikte en effectieve techniek in deep learning. Onderzoekers en praktijkmensen blijven manieren verkennen om deze problemen aan te pakken en de oorspronkelijke formulering te verbeteren.

Laten we een paar benaderingen bekijken om de beperkingen van batch-normalisatie te mitigeren:

• Adaptieve batch-normalisatie: Deze techniek past de batchstatistieken aan op basis van de specifieke kenmerken van elk sample, wat helpt de problemen bij kleine batchgroottes te verlichten.
• Virtuele batch-normalisatie: Deze methode berekent de normalisatiestatistieken met een virtuele batch die samples uit meerdere batches bevat, wat de stabiliteit en betrouwbaarheid van het normalisatieproces verbetert.
• Hybride normalisatietechnieken: Het combineren van batch-normalisatie met andere normalisatiemethoden, zoals layer-normalisatie of instance-normalisatie, kan helpen de beperkingen aan te pakken die specifiek zijn voor bepaalde architecturen of taken.

Varianten en uitbreidingen van batch-normalisatie

Laten we nu verschillende varianten en uitbreidingen van batch-normalisatie bekijken die we ook kunnen gebruiken om de potentiële uitdagingen van batch-normalisatie aan te pakken.

Layer-normalisatie

Layer-normalisatie werkt op de activaties over alle kanalen binnen een laag, in plaats van over de batchdimensie.

Het normaliseert de activaties op basis van het gemiddelde en de variantie die per individueel sample in de batch worden berekend.

Layer-normalisatie is vooral nuttig voor recurrente neurale netwerken (RNN's) en scenario's waarin de batchgrootte klein of variabel is.

Group-normalisatie

Group-normalisatie verdeelt de kanalen in groepen en berekent de normalisatiestatistieken binnen elke groep.

Het vormt een middenweg tussen layer-normalisatie en batch-normalisatie door een subset van kanalen samen te normaliseren.

Group-normalisatie is effectief in situaties waarin de batchgrootte beperkt is, zoals in geheugengelimiteerde omgevingen of bij het verwerken van afbeeldingen met hoge resolutie.

Instance-normalisatie

Instance-normalisatie past normalisatie toe op elk individueel kanaal van elk sample in de batch.

Het wordt vaak gebruikt bij style transfer en beeldgeneratietaken, waar het doel is de content te normaliseren met behoud van de stijl.

Instance-normalisatie heeft in dit soort toepassingen de kwaliteit en stabiliteit van gegenereerde beelden aantoonbaar verbeterd.

Batch-renormalisatie

Batch-renormalisatie breidt batch-normalisatie uit door extra correctietermen aan het normalisatieproces toe te voegen.

Het is bedoeld om de discrepantie tussen batchstatistieken en populatiestatistieken aan te pakken, vooral wanneer de batchgrootte klein is.

Batch-renormalisatie helpt de training te stabiliseren en verbetert het generalisatievermogen van het model, met name in scenario's met beperkte batchgroottes.

Gewicht-normalisatie

Gewicht-normalisatie is een techniek die de gewichten van een neuraal netwerk herparameteriseert om de grootte en richting van gewichten te ontkoppelen.

Het normaliseert de gewichten door ze te delen door hun Euclidische norm en introduceert een leerbare schaalparameter.

Gewicht-normalisatie kan samen met batch-normalisatie worden gebruikt of als een alternatieve normalisatiemethode.

Er is aangetoond dat het in sommige gevallen de conditionering van het optimalisatieprobleem verbetert en de convergentie versnelt.

Deze varianten en uitbreidingen van batch-normalisatie bieden extra tools en technieken om specifieke uitdagingen aan te pakken en de training en prestaties van deep-learningmodellen te verbeteren. Elke variant heeft zijn eigen sterke punten en aandachtspunten, en de keuze hangt af van de specifieke eisen van de taak, de modelarchitectuur en de beschikbare rekenmiddelen.

Conclusie

Batch-normalisatie is uitgegroeid tot een cruciale techniek in deep learning, met aanzienlijke voordelen voor het trainen van diepe neurale netwerken.

Door activaties binnen minibatches te normaliseren, kunnen we interne covariaatverschuiving aanpakken, de convergentie verbeteren en de generalisatie versterken. Houd als aankomend of junior dataprofessional deze kernpunten in gedachten:

• Neem batch-normalisatielagen op in je deep-learningmodellen om de trainingsstabiliteit en prestaties te verbeteren.
• Experimenteer met de plaatsing van batch-normalisatielagen en monitor de impact op de prestaties van je model.
• Blijf op de hoogte van het nieuwste onderzoek en de nieuwste ontwikkelingen in normalisatietechnieken om de meest effectieve methoden voor je projecten in te zetten.

Wil je machine learning engineer worden? Overweeg dan dit 12-cursussen carrièrefocustraject tot Machine Learning Engineer.