Hva er en autokoder?
En Autoencoder er et verktøy for å lære datakoding effektivt på en ukontrollert måte. Det er en type kunstig nevralt nettverk som hjelper deg med å lære representasjonen av datasett for dimensjonsreduksjon ved å trene nevrale nettverk for å ignorere signalstøyen. Det er et flott verktøy for å gjenskape en innspill.
Med enkle ord tar maskinen, la oss si et bilde, og kan produsere et nært beslektet bilde. Inndataene i denne typen nevrale nettverk er umerket, noe som betyr at nettverket er i stand til å lære uten tilsyn. Mer presist er inngangen kodet av nettverket for kun å fokusere på den mest kritiske funksjonen. Dette er en av grunnene til at autoencoder er populær for dimensjonsreduksjon. Dessuten kan autokodere brukes til å produsere generative læringsmodeller . For eksempel kan nevrale nettverk trent med et sett med ansikter og deretter produsere nye ansikter.
I denne TensorFlow Autoencoder-opplæringen vil du lære:
- Hva er en autokoder?
- Hvordan fungerer Autoencoder?
- Stacked Autoencoder Eksempel
- Bygg en autokoder med TensorFlow
- Forbehandling av bilder
- Sett datasettestimator
- Bygg nettverket
Hvordan fungerer Autoencoder?
Hensikten med en autokoder er å produsere en tilnærming av inngangen ved å bare fokusere på de essensielle egenskapene. Du kan tenke hvorfor ikke bare lære å kopiere og lime inn inngangen for å produsere utdataene. Faktisk er en autokoder et sett med begrensninger som tvinger nettverket til å lære nye måter å representere dataene på, forskjellig fra bare å kopiere utdataene.
En typisk autokoder er definert med en inngang, en intern representasjon og en utgang (en tilnærming til inngangen). Læringen skjer i lagene festet til den interne representasjonen. Faktisk er det to hovedblokker med lag som ser ut som et tradisjonelt nevralt nettverk. Den lille forskjellen er at laget som inneholder utgangen må være lik inngangen. På bildet nedenfor går den originale inngangen inn i den første blokken som kalles koderen . Denne interne representasjonen komprimerer (reduserer) størrelsen på inngangen. I den andre blokken oppstår rekonstruksjonen av inngangen. Dette er avkodingsfasen.
Arbeid med Autoencoder
Modellen oppdaterer vektene ved å minimere tapfunksjonen. Modellen straffes hvis gjenoppbyggingsutgangen er forskjellig fra inngangen.
Konkret, forestill deg et bilde med en størrelse på 50x50 (dvs. 250 piksler) og et nevralt nettverk med bare ett skjult lag sammensatt av hundre nevroner. Læringen gjøres på et funksjonskart som er to ganger mindre enn inngangen. Det betyr at nettverket må finne en måte å rekonstruere 250 piksler med bare en nevronvektor lik 100.
Stacked Autoencoder Eksempel
I denne Autoencoder-opplæringen lærer du hvordan du bruker en stablet autoencoder. Arkitekturen ligner på et tradisjonelt nevralt nettverk. Inngangen går til et skjult lag for å bli komprimert, eller redusere størrelsen, og når deretter rekonstruksjonslagene. Målet er å produsere et utgangsbilde så nært som originalen. Modellen må lære seg en måte å oppnå oppgaven på under et sett med begrensninger, det vil si med en lavere dimensjon.
I dag brukes autokodere i dyp læring hovedsakelig for å benekte et bilde. Se for deg et bilde med riper; et menneske er fortsatt i stand til å gjenkjenne innholdet. Ideen med å benekte autoencoder er å legge til støy i bildet for å tvinge nettverket til å lære mønsteret bak dataene.
Den andre nyttige familien av Autoencoder Deep Learning er variasjonell autoencoder. Denne typen nettverk kan generere nye bilder. Tenk deg at du trener et nettverk med bildet av en mann; et slikt nettverk kan produsere nye ansikter.
Bygg en autokoder med TensorFlow
I denne opplæringen lærer du hvordan du bygger en stablet autokoder for å rekonstruere et bilde.
Du vil bruke CIFAR-10 datasettet som inneholder 60000 32x32 fargebilder. Autoencoder-datasettet er allerede delt mellom 50000 bilder for opplæring og 10000 for testing. Det er opptil ti klasser:
- Fly
- Bil
- Fugl
- Katt
- Hjort
- Hund
- Frosk
- Hest
- Skip
- Lastebil
Du må laste ned bildene i denne URL-en https://www.cs.toronto.edu/~kriz/cifar.html og pakke den ut. Mappen for-10-batches-py inneholder fem batcher av data med 10000 bilder hver i tilfeldig rekkefølge.
Før du bygger og trener modellen din, må du bruke litt databehandling. Du fortsetter som følger:
- Importer dataene
- Konverter dataene til svart-hvitt-format
- Legg til alle batchene
- Konstruer treningsdatasettet
- Konstruer et bildevisualiseringsprogram
Forbehandling av bilder
Trinn 1) Importer dataene.
I følge det offisielle nettstedet kan du laste opp dataene med følgende kode. Autoencoder-koden vil laste inn dataene i en ordbok med dataene og etiketten . Merk at koden er en funksjon.
import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict
Trinn 2) Konverter dataene til svart-hvitt-format
For enkelhets skyld vil du konvertere dataene til gråtoner. Det vil si med bare en dimensjon mot tre for fargebilde. Det meste av nevrale nettverk fungerer bare med en dimensjonsinngang.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Trinn 3) Legg til alle batchene
Nå som begge funksjonene er opprettet og datasettet er lastet inn, kan du skrive en sløyfe for å legge til dataene i minnet. Hvis du sjekker nøye, får utpakkingsfilen med dataene navnet data_batch_ med et tall fra 1 til 5. Du kan sløyfe over filene og legge den til data.
Når dette trinnet er gjort, konverterer du fargedataene til et gråskalaformat. Som du kan se, er formen på dataene 50000 og 1024. De 32 * 32 pikslene er nå flate til 2014.
# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)
Merk: Endre './cifar-10-batches-py/data_batch_' til den faktiske plasseringen av filen din. For eksempel for Windows-maskin kan banen være filnavn = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Trinn 4) Konstruer treningsdatasettet
For å gjøre treningen raskere og enklere, vil du kun trene en modell på hestebildene. Hestene er den syvende klassen i merkedataene. Som nevnt i dokumentasjonen til CIFAR-10 datasettet, inneholder hver klasse 5000 bilder. Du kan skrive ut formen på dataene for å bekrefte at det er 5.000 bilder med 1024 kolonner, som vist i trinnet nedenfor for TensorFlow Autoencoder.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Trinn 5) Konstruer et bildevisualiseringsprogram
Til slutt konstruerer du en funksjon for å plotte bildene. Du trenger denne funksjonen for å skrive ut det rekonstruerte bildet fra autokoderen.
En enkel måte å skrive ut bilder på er å bruke objektet imshow fra matplotlib-biblioteket. Merk at du må konvertere formen på dataene fra 1024 til 32 * 32 (dvs. format på et bilde).
# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")
Funksjonen tar 3 argumenter:
- Bilde: inngangen
- Form: liste, dimensjonen til bildet
- Cmap: velg fargekartet. Som standard grå
Du kan prøve å plotte det første bildet i datasettet. Du burde se en mann på en hest.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Sett datasettestimator
Nå som datasettet er klart til bruk, kan du begynne å bruke Tensorflow. Før vi bygger modellen, la oss bruke datasettestimatoren til Tensorflow for å mate nettverket.
Du vil bygge et datasett med TensorFlow estimator. For å oppdatere tankene dine, må du bruke:
- fra_tensor_slices
- gjenta
- parti
Den fulle koden for å bygge datasettet er:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Merk at x er en plassholder med følgende form:
- [Ingen, n_innganger]: Sett til Ingen fordi antall bildemater til nettverket er lik batchstørrelsen.
For detaljer, se opplæringen om lineær regresjon.
Etter det må du opprette iteratoren. Uten denne kodelinjen vil ingen data gå gjennom rørledningen.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Nå som rørledningen er klar, kan du sjekke om det første bildet er det samme som før (dvs. en mann på en hest).
Du setter batchstørrelsen til 1 fordi du bare vil mate datasettet med ett bilde. Du kan se dimensjonen til dataene med utskrift (sess.run (features) .shape). Det er lik (1, 1024). 1 betyr at bare ett bilde med 1024 mates hver. Hvis batchstørrelsen er satt til to, vil to bilder gå gjennom rørledningen. (Ikke endre batchstørrelsen. Ellers vil det kaste en feil. Bare ett bilde av gangen kan gå til funksjonen plot_image ().
## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)
Bygg nettverket
Det er på tide å konstruere nettverket. Du vil trene en stablet autokoder, det vil si et nettverk med flere skjulte lag.
Nettverket ditt vil ha ett inngangslag med 1024 poeng, dvs. 32x32, formen på bildet.
Koderblokken vil ha et øverste skjulte lag med 300 nevroner, et sentralt lag med 150 nevroner. Dekoderblokken er symmetrisk med koderen. Du kan visualisere nettverket på bildet nedenfor. Merk at du kan endre verdiene til skjulte og sentrale lag.
Bygg nettverket for Autoencoder
Å bygge en autokoder er veldig lik alle andre dyplæringsmodeller.
Du vil konstruere modellen ved å følge disse trinnene:
- Definer parametrene
- Definer lagene
- Definer arkitekturen
- Definer optimaliseringen
- Kjør modellen
- Evaluer modellen
I forrige avsnitt lærte du hvordan du oppretter en rørledning for å mate modellen, så det er ikke nødvendig å opprette datasettet en gang til. Du vil konstruere en autokoder med fire lag. Du bruker Xavier initialisering. Dette er en teknikk for å angi startvektene som er like variansen til både inngang og utgang. Til slutt bruker du elu-aktiveringsfunksjonen. Du regulerer tapsfunksjonen med L2-regulator.
Trinn 1) Definer parametrene
Det første trinnet innebærer å definere antall nevroner i hvert lag, læringsfrekvensen og hyperparameteret til regulatoren.
Før det importerer du funksjonen delvis. Det er en bedre metode for å definere parametrene til de tette lagene. Koden nedenfor definerer verdiene til autokoderarkitekturen. Som oppført tidligere har autokoderen to lag, med 300 nevroner i de første lagene og 150 i de andre lagene. Verdiene deres er lagret i n_hidden_1 og n_hidden_2.
Du må definere læringsgraden og L2-hyperparameteret. Verdiene lagres i learning_rate og l2_reg
from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001
Xavier-initialiseringsteknikken kalles med objektet xavier_initializer fra estimatorbidraget. I samme estimator kan du legge til regulatoren med l2_regularizer
## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
Trinn 2) Definer lagene
Alle parametrene til de tette lagene er satt; du kan pakke alt i variabelen dense_layer ved å bruke objektet delvis. dense_layer som bruker ELU-aktivering, Xavier initialisering og L2 regularisering.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
Trinn 3) Definer arkitekturen
Hvis du ser på bildet av arkitekturen, bemerker du at nettverket stabler tre lag med et utgangslag. I koden nedenfor kobler du de aktuelle lagene. For eksempel beregner det første laget punktproduktet mellom inngangsmatrisefunksjonene og matrisene som inneholder de 300 vektene. Etter at punktproduktet er beregnet, går utgangen til Elu-aktiveringsfunksjonen. Utgangen blir inngangen til neste lag, det er derfor du bruker den til å beregne hidden_2 og så videre. Matriksmultiplikasjonen er den samme for hvert lag fordi du bruker den samme aktiveringsfunksjonen. Merk at det siste laget, utganger, ikke bruker en aktiveringsfunksjon. Det gir mening fordi dette er den rekonstruerte inngangen
## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)
Trinn 4) Definer optimaliseringen
Det siste trinnet er å konstruere optimalisereren. Du bruker Mean Square Error som en tapsfunksjon. Hvis du husker opplæringen om lineær regresjon, vet du at MSE beregnes med forskjellen mellom den forventede produksjonen og den virkelige etiketten. Her er etiketten funksjonen fordi modellen prøver å rekonstruere inngangen. Derfor vil du ha gjennomsnittet av summen av forskjellen på firkanten mellom forutsagt utgang og inngang. Med TensorFlow kan du kode tapsfunksjonen som følger:
loss = tf.reduce_mean(tf.square(outputs - features))
Deretter må du optimalisere tapsfunksjonen. Du bruker Adam optimizer for å beregne stigningene. Den objektive funksjonen er å minimere tapet.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
En innstilling til før du trener modellen. Du vil bruke en batchstørrelse på 150, det vil si mate rørledningen med 150 bilder hver iterasjon. Du må beregne antall iterasjoner manuelt. Dette er trivielt å gjøre:
Hvis du vil sende 150 bilder hver gang, og du vet at det er 5000 bilder i datasettet, er antall iterasjoner lik. I python kan du kjøre følgende koder og sørge for at utdataene er 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Trinn 5) Kjør modellen
Sist men ikke minst, trene modellen. Du trener modellen med 100 epoker. Det vil si at modellen vil se 100 ganger bildene til optimaliserte vekter.
Du er allerede kjent med kodene for å trene en modell i Tensorflow. Den lille forskjellen er å pipe dataene før du kjører treningen. På denne måten trener modellen raskere.
Du er interessert i å skrive ut tapet etter ti epoker for å se om modellen lærer noe (dvs. tapet avtar). Treningen tar 2 til 5 minutter, avhengig av maskinvaren din.
## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt
Trinn 6) Evaluer modellen
Nå som du har fått modellen trent, er det på tide å evaluere den. Du må importere testserten fra filen / cifar-10-batches-py /.
test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])
MERKNAD: For en Windows-maskin blir koden test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")
Du kan prøve å skrive ut bildene 13, som er en hest
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
For å evaluere modellen vil du bruke pikselverdien til dette bildet og se om koderen kan rekonstruere det samme bildet etter å ha krympet 1024 piksler. Merk at du definerer en funksjon for å evaluere modellen på forskjellige bilder. Modellen skal fungere bedre bare på hester.
Funksjonen tar to argumenter:
- df: Importer testdataene
- image_number: angi hvilket bilde du vil importere
Funksjonen er delt inn i tre deler:
- Form bildet til riktig dimensjon, dvs. 1, 1024
- Mat modellen med det usynlige bildet, kod / dekoder bildet
- Skriv ut det virkelige og rekonstruerte bildet
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()
Nå som evalueringsfunksjonen er definert, kan du se på det rekonstruerte bildet nummer tretten
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Sammendrag
Det primære formålet med en autokoder er å komprimere inngangsdataene, og deretter komprimere dem til en utgang som ser ut som de originale dataene.
Arkitekturen til en autoencoder symmetrisk med et pivotlag som heter det sentrale laget.
Du kan opprette autokoderen ved å bruke:
- Delvis: for å lage de tette lagene med den typiske innstillingen:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- dense_layer (): for å lage matrisemultiplikasjonen
du kan definere tapsfunksjonen og optimaliseringen med:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Sist kjørt en økt for å trene modellen.