Welkom bij Deel 3 van de Applied Deep Learning-serie. Deel 1 was een hands-on introductie tot kunstmatige neurale netwerken, die zowel de theorie en de toepassing met veel code voorbeelden en visualisatie. In Deel 2 hebben we deep learning toegepast op real-world datasets, waarbij de 3 meest voorkomende problemen als casestudy ‘ s werden behandeld: binaire classificatie, multiclass classificatie en regressie.
nu zullen we beginnen met het duiken in specifieke deep learning architecturen, te beginnen met de eenvoudigste: Autoencoders.
- Inleiding
- architectuur
- implementatie
- Denoising Autoencoders
- schaarse Autoencoders
- Use Cases
- conclusie
de code voor dit artikel is hier beschikbaar als een Jupyter notebook, download en probeer het zelf.
Inleiding
Auto-encoders zijn een specifiek type feedforward neurale netwerken waarbij de invoer gelijk is aan de uitvoer. Ze comprimeren de input in een lagerdimensionale code en reconstrueren de output van deze representatie. De code is een compacte ” samenvatting “of” compressie ” van de invoer, ook wel de latent-ruimte representatie genoemd.
een auto-encoder bestaat uit 3 componenten: encoder, code en decoder. De encoder comprimeert de invoer en produceert de code, de decoder reconstrueert de invoer alleen met behulp van deze code.
om een auto-encoder te bouwen hebben we 3 dingen nodig: een coderingsmethode, decoderingsmethode en een verliesfunctie om de output met het doel te vergelijken. We zullen deze onderzoeken in de volgende sectie.
Auto-encoders zijn voornamelijk een dimensionaliteitsreductie (of-compressie) algoritme met een paar belangrijke eigenschappen:
- Data-specific: Auto-encoders zijn alleen in staat om zinvol te comprimeren gegevens vergelijkbaar met wat ze zijn opgeleid op. Omdat ze functies leren die specifiek zijn voor de gegeven trainingsgegevens, zijn ze anders dan een standaard datacompressiealgoritme zoals gzip. Dus we kunnen niet verwachten dat een auto-encoder getraind op handgeschreven cijfers om landschapsfoto ‘ s te comprimeren.
- verlies: De output van de autoencoder zal niet precies hetzelfde zijn als de input, het zal een nauwe maar gedegradeerde representatie zijn. Als je lossless compressie wilt zijn ze niet de manier om te gaan.
- Unsupervised: om een auto-encoder te trainen, hoeven we niets bijzonders te doen, gewoon de ruwe invoergegevens erop gooien. Auto-encoders worden beschouwd als een unsupervised leertechniek omdat ze geen expliciete labels nodig hebben om op te trainen. Maar om preciezer te zijn, ze worden zelf gecontroleerd omdat ze hun eigen labels genereren uit de trainingsgegevens.
architectuur
laten we de details van de encoder, code en decoder onderzoeken. Zowel de encoder en decoder zijn volledig verbonden feedforward neurale netwerken, in wezen de ANNs we behandeld in Deel 1. Code is een enkele laag van een ANN met de dimensionaliteit van onze keuze. Het aantal knooppunten in de codelaag (code grootte) is een hyperparameter die we instellen voordat we de auto-encoder trainen.
Dit is een meer gedetailleerde visualisatie van een auto-encoder. Eerst gaat de ingang door de encoder, die een volledig aangesloten ANN is, om de code te produceren. De decoder, die dezelfde ANN-structuur heeft, produceert de uitvoer alleen met behulp van de code. Het doel is om een uitvoer te krijgen die identiek is aan de invoer. Merk op dat de decoderarchitectuur het spiegelbeeld van de encoder is. Dit is geen vereiste, maar het is meestal het geval. De enige vereiste is dat de dimensionaliteit van de input en output hetzelfde moet zijn. Alles in het midden kan worden bespeeld.
er zijn 4 hyperparameters die we moeten instellen voordat we een auto-encoder trainen:
- codegrootte: aantal knopen in de middelste laag. Kleiner formaat resulteert in meer compressie.
- aantal lagen: de auto-encoder kan zo diep zijn als we willen. In de bovenstaande figuur hebben we 2 lagen in zowel de encoder en decoder, zonder rekening te houden met de input en output.
- aantal knopen per laag: de auto-encoderarchitectuur waaraan we werken wordt een gestapelde auto-encoder genoemd omdat de lagen de ene na de andere worden gestapeld. Meestal zien gestapelde auto-encoders eruit als een”sandwitch”. Het aantal knooppunten per laag neemt af met elke volgende laag van de encoder en neemt weer toe in de decoder. Ook de decoder is symmetrisch aan de encoder in termen van laagstructuur. Zoals hierboven vermeld is dit niet nodig en hebben we volledige controle over deze parameters.
- Loss functie: we gebruiken mean squared error (mse) of binary crossentropy. Als de invoerwaarden in het bereik liggen dan gebruiken we meestal crossentropie, anders gebruiken we de gemiddelde kwadraatfout. Voor meer details kijk op deze video.
Auto-encoders worden op dezelfde manier getraind als ANNs via backpropagatie. Bekijk de introductie van Deel 1 voor meer details over hoe neurale netwerken worden getraind, het is direct van toepassing op de auto-encoders.
implementatie
laten we nu een auto-encoder implementeren voor de volgende architectuur, 1 verborgen laag in de encoder en decoder.
we zullen de extreem populaire MNIST-dataset als input gebruiken. Het bevat zwart-wit afbeeldingen van handgeschreven cijfers.
ze hebben Grootte 28×28 en we gebruiken ze als een vector van 784 getallen ertussen . Controleer de jupyter notebook voor de details.
we zullen nu de autoencoder implementeren met Keras. De hyperparameters zijn: 128 knooppunten in de verborgen laag, code grootte is 32, en binaire crossentropie is de verliesfunctie.
dit lijkt erg op de ANNs waar we aan werkten, maar nu gebruiken we de keras functionele API. Raadpleeg deze handleiding voor details, maar hier is een snelle vergelijking. Voordat we gebruikt om lagen toe te voegen met behulp van de sequentiële API als volgt:
model.add(Dense(16, activation='relu'))
model.add(Dense(8, activation='relu'))
met de functionele API doen we dit:
layer_1 = Dense(16, activation='relu')(input)
layer_2 = Dense(8, activation='relu')(layer_1)
het is uitgebreider, maar een meer flexibele manier om complexe modellen te definiëren. We kunnen gemakkelijk delen van ons model pakken, bijvoorbeeld alleen de decoder, en daarmee werken. De output van dichte methode is een opvraagbare laag, met behulp van de functionele API bieden wij het met de input en de output op te slaan. De uitvoer van een laag wordt de invoer van de volgende laag. Met de sequentiële API de add methode impliciet behandeld dit voor ons.
merk op dat alle lagen de relu-activeringsfunctie gebruiken, omdat dit de standaard is voor diepe neurale netwerken. De laatste laag maakt gebruik van de sigmoid activering omdat we de uitgangen moeten tussen . De ingang is ook in hetzelfde bereik.
let ook op de functie aanroep passen, voordat we met ANNs:
model.fit(x_train, y_train)
maar nu wel.:
model.fit(x_train, x_train)
onthoud dat de doelen van de autoencoder hetzelfde zijn als de invoer. Daarom leveren we de trainingsgegevens als doelwit.
visualisatie
laten we nu visualiseren hoe goed onze autoencoder zijn invoer reconstrueert.
We draaien de autoencoder op de test set gewoon met behulp van de predict functie van Keras. Voor elke afbeelding in de testset krijgen we de uitvoer van de auto-encoder. We verwachten dat de output zeer vergelijkbaar is met de input.
ze zijn inderdaad vrij gelijkaardig, maar niet precies hetzelfde. We kunnen het duidelijker zien in het laatste cijfer “4”. Aangezien dit een eenvoudige taak onze auto-encoder uitgevoerd vrij goed.
advies
wij hebben volledige controle over de architectuur van de auto-encoder. We kunnen het zeer krachtig maken door het aantal lagen, knopen per laag en vooral de code grootte te verhogen. Het verhogen van deze hyperparameters zal de autoencoder meer complexe coderingen laten leren. Maar we moeten oppassen om het niet te krachtig te maken. Anders zal de autoencoder gewoon leren om zijn ingangen naar de uitvoer te kopiëren, zonder enige betekenisvolle representatie te leren. Het zal alleen de identiteitsfunctie nabootsen. De autoencoder zal de trainingsgegevens perfect reconstrueren, maar het zal Overvliegen zonder te kunnen generaliseren naar nieuwe instanties, wat niet is wat we willen.
daarom geven we de voorkeur aan een “sandwitch” – architectuur en houden we de code bewust klein. Aangezien de codeerlaag een lagere dimensionaliteit heeft dan de inputgegevens, wordt de autoencoder gezegd undercomplete te zijn. Het zal niet in staat zijn om de ingangen direct te kopiëren naar de uitgang,en zal worden gedwongen om intelligente functies te leren. Als de invoergegevens een patroon hebben, bijvoorbeeld het cijfer “1” bevat meestal een wat rechte lijn en het cijfer “0” is cirkelvormig, zal het dit feit leren en het coderen in een compactere vorm. Als de invoergegevens volledig willekeurig waren zonder enige interne correlatie of afhankelijkheid, dan zal een undercomplete autoencoder niet in staat zijn om het perfect te herstellen. Maar gelukkig is er in de echte wereld veel afhankelijkheid.
het Denoiseren van auto-encoders
het klein houden van de codelaag dwong onze auto-encoder om een intelligente weergave van de gegevens te leren. Er is een andere manier om de autoencoder dwingen om nuttige functies te leren, die willekeurige ruis toe te voegen aan de ingangen en waardoor het herstellen van de oorspronkelijke ruisvrije gegevens. Op deze manier kan de autoencoder de invoer niet simpelweg naar de uitvoer kopiëren omdat de invoer ook willekeurige ruis bevat. We vragen het om de ruis af te trekken en de onderliggende zinvolle gegevens te produceren. Dit wordt een denoising autoencoder genoemd.
de bovenste rij bevat de originele afbeeldingen. We voegen willekeurige Gaussiaanse ruis toe aan hen en de lawaaierige gegevens worden de invoer naar de auto-encoder. De autoencoder ziet het originele beeld helemaal niet. Maar dan verwachten we dat de autoencoder het ruisvrije originele beeld regenereert.
er is slechts één klein verschil tussen de implementatie van de denoising autoencoder en de reguliere. De architectuur verandert helemaal niet, alleen de fit-functie. We trainden de reguliere auto-encoder als volgt:
autoencoder.fit(x_train, x_train)
Denoising autoencoder wordt getraind als:
autoencoder.fit(x_train_noisy, x_train)
zo simpel is het, al het andere is precies hetzelfde. De invoer van de autoencoder is de lawaaierige afbeelding, en het verwachte doel is de oorspronkelijke ruisvrije.
visualisatie
laten we nu visualiseren of we in staat zijn om de ruisvrije afbeeldingen te herstellen.
ziet er goed uit. De onderste rij is de autoencoder-uitvoer. We kunnen het beter doen door complexere auto-encoderarchitectuur te gebruiken, zoals convolutionele auto-encoders. We zullen kronkels behandelen in het komende artikel.
dunne Auto-encoders
we introduceerden twee manieren om de auto-encoder te dwingen nuttige functies te leren: de code klein houden en auto-encoders denoiseren. De derde methode is het gebruik van regularisatie. We kunnen de auto-encoder regulariseren door een sparsity-beperking te gebruiken, zodat slechts een fractie van de knooppunten niet-nulwaarden zou hebben, actieve knooppunten genoemd.
in het bijzonder voegen we een strafterm toe aan de verliesfunctie, zodat slechts een fractie van de knooppunten actief wordt. Dit dwingt de autoencoder om elke invoer te vertegenwoordigen als een combinatie van een klein aantal knooppunten, en vereist het om interessante structuur in de gegevens te ontdekken. Deze methode werkt zelfs als de code groot is, omdat slechts een kleine subset van de knooppunten op elk moment actief zal zijn.
het is vrij eenvoudig om dit te doen in Keras met slechts één parameter. Ter herinnering, eerder hebben we de codelaag als volgt gemaakt:
code = Dense(code_size, activation='relu')(input_img)
we voegen nu een andere parameter toe genaamd activity_regularizer door de regularisatiesterkte te specificeren. Dit is meestal een waarde in het bereik . Hier kozen we 10e-6.
code = Dense(code_size, activation='relu', activity_regularizer=l1(10e-6))(input_img)
het uiteindelijke verlies van het sparse model is 0,01 hoger dan het standaardmodel, als gevolg van de toegevoegde regularisatieterm.
laten we aantonen dat de coderingen gegenereerd door het geregulariseerde model inderdaad schaars zijn. Als we kijken naar het histogram van codewaarden voor de beelden in de test set, de verdeling is als volgt:
het gemiddelde voor het standaard model is 6.6 maar voor het geregulariseerde model is het 0.8, een vrij grote reductie. We kunnen zien dat een groot deel van de code waarden in het geregulariseerde model inderdaad 0, dat is wat we wilden. De variantie van het geregulariseerde model is ook vrij laag.
Use Cases
nu kunnen we de volgende vragen stellen. Hoe goed zijn auto-encoders in het comprimeren van de invoer? En zijn ze een veelgebruikte deep learning techniek?
helaas worden auto-encoders niet veel gebruikt in echte toepassingen. Als een compressiemethode, ze niet beter presteren dan de alternatieven, bijvoorbeeld jpeg doet Foto Compressie beter dan een auto-encoder. En het feit dat auto-encoders data-specifiek zijn maakt ze onpraktisch als een algemene techniek. Ze hebben 3 veel voorkomende use cases al:
- data denoising: we hebben hier een voorbeeld van gezien op beelden.
- Dimensionaliteitsreductie: het visualiseren van hoogdimensionale gegevens is een uitdaging. t-SNE is de meest gebruikte methode, maar worstelt met een groot aantal dimensies (meestal boven 32). Dus Auto-encoders worden gebruikt als een voorbewerkingsstap om de dimensionaliteit te verminderen, en deze gecomprimeerde representatie wordt gebruikt door t-SNE om de gegevens in 2D-ruimte te visualiseren. Voor geweldige artikelen over t-SNE zie hier en hier.
- Variational Autoencoders (VAE): dit is een meer moderne en complexe use-case van autoencoders en we zullen ze behandelen in een ander artikel. Maar als een snelle samenvatting, VAE leert de parameters van de kansverdeling modelleren van de inputgegevens, in plaats van het leren van een willekeurige functie in het geval van vanilla autoencoders. Door monsternemingspunten uit deze verdeling kunnen we ook de VAE als generatief model gebruiken. Hier is een goede referentie.
conclusie
Auto-encoders zijn een zeer nuttige dimensionaliteitsreductietechniek. Ze zijn erg populair als lesmateriaal in inleidende deep learning cursussen, waarschijnlijk vanwege hun eenvoud. In dit artikel hebben we ze in detail behandeld en ik hoop dat je ervan hebt genoten.
de volledige code voor dit artikel is hier beschikbaar als u het zelf wilt hacken. Als je feedback hebt, neem dan gerust contact met me op via twitter.