Hvad er en autokoder?
En Autoencoder er et værktøj til effektiv indlæring af datakodning uden opsyn. Det er en type kunstigt neuralt netværk, der hjælper dig med at lære repræsentationen af datasæt til dimensioneringsreduktion ved at træne det neurale netværk til at ignorere signalstøj. Det er et godt værktøj til at genskabe et input.
Med enkle ord tager maskinen, lad os sige et billede, og kan producere et nært beslægtet billede. Input i denne form for neuralt netværk er umærket, hvilket betyder, at netværket er i stand til at lære uden opsyn. Mere præcist er input kodet af netværket for kun at fokusere på den mest kritiske funktion. Dette er en af grundene til, at autoencoder er populær til reduktion af dimensionalitet. Desuden kan autokodere bruges til at producere generative læringsmodeller . For eksempel kan det neurale netværk trænes med et sæt ansigter og derefter producere nye ansigter.
I denne TensorFlow Autoencoder-tutorial lærer du:
- Hvad er en autokoder?
- Hvordan fungerer Autoencoder?
- Stablet autokodereksempel
- Byg en autokoder med TensorFlow
- Billedforbehandling
- Indstil datasætestimator
- Byg netværket
Hvordan fungerer Autoencoder?
Formålet med en autokoder er at producere en tilnærmelse af input ved kun at fokusere på de væsentlige funktioner. Du tænker måske hvorfor ikke bare lære at kopiere og indsætte input for at producere output. Faktisk er en autokoder et sæt begrænsninger, der tvinger netværket til at lære nye måder at repræsentere dataene på, forskelligt fra blot at kopiere output.
En typisk autokoder er defineret med en indgang, en intern repræsentation og en udgang (en tilnærmelse af indgangen). Læringen sker i de lag, der er knyttet til den interne repræsentation. Faktisk er der to hovedblokke af lag, der ligner et traditionelt neuralt netværk. Den lille forskel er, at laget, der indeholder output, skal være lig med input. På billedet nedenfor går den originale input ind i den første blok kaldet koderen . Denne interne repræsentation komprimerer (reducerer) størrelsen på input. I den anden blok opstår rekonstruktionen af input. Dette er afkodningsfasen.
Arbejde med Autoencoder
Modellen opdaterer vægtene ved at minimere tabsfunktionen. Modellen straffes, hvis genopbygningsoutputtet er forskelligt fra input.
Konkret kan du forestille dig et billede med en størrelse på 50x50 (dvs. 250 pixels) og et neuralt netværk med kun et skjult lag sammensat af hundrede neuroner. Læringen foregår på et funktionskort, der er to gange mindre end input. Det betyder, at netværket skal finde en måde at rekonstruere 250 pixels med kun en neuronvektor svarende til 100.
Stablet autokodereksempel
I denne Autoencoder-selvstudie lærer du, hvordan du bruger en stablet autoencoder. Arkitekturen ligner et traditionelt neuralt netværk. Indgangen går til et skjult lag for at blive komprimeret eller reducere dets størrelse og når derefter rekonstruktionslagene. Målet er at producere et outputbillede så tæt som originalen. Modellen skal lære en måde at nå sin opgave på under et sæt begrænsninger, det vil sige med en lavere dimension.
I dag bruges autokodere i dyb læring hovedsageligt til at benævne et billede. Forestil dig et billede med ridser; et menneske er stadig i stand til at genkende indholdet. Ideen med at benægte autoencoder er at tilføje støj til billedet for at tvinge netværket til at lære mønsteret bag dataene.
Den anden nyttige familie af Autoencoder Deep Learning er variation autoencoder. Denne type netværk kan generere nye billeder. Forestil dig, at du træner et netværk med billedet af en mand; et sådant netværk kan producere nye ansigter.
Byg en autokoder med TensorFlow
I denne vejledning lærer du, hvordan man bygger en stablet autoencoder til at rekonstruere et billede.
Du bruger CIFAR-10 datasættet, der indeholder 60000 32x32 farvebilleder. Autoencoder-datasættet er allerede delt mellem 50000 billeder til træning og 10000 til test. Der er op til ti klasser:
- Fly
- Automobil
- Fugl
- Kat
- Hjort
- Hund
- Frø
- Hest
- Skib
- Lastbil
Du skal downloade billederne i denne URL https://www.cs.toronto.edu/~kriz/cifar.html og pakke den ud. Mappen for-10-batches-py indeholder fem batches data med 10000 billeder hver i tilfældig rækkefølge.
Før du bygger og træner din model, skal du anvende noget databehandling. Du fortsætter som følger:
- Importer dataene
- Konverter dataene til sort / hvid-format
- Tilføj alle batches
- Konstruer træningsdatasættet
- Konstruer et visualiseringsbillede
Billedforbehandling
Trin 1) Importer dataene.
Ifølge den officielle hjemmeside kan du uploade dataene med følgende kode. Autoencoder-koden indlæser dataene i en ordbog med dataene og etiketten . Bemærk, at koden er en funktion.
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
Trin 2) Konverter dataene til sort / hvid-format
For nemheds skyld konverterer du dataene til en gråtoneskala. Det vil sige med kun en dimension mod tre for farvebillede. Det meste af det neurale netværk fungerer kun med input til en dimension.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Trin 3) Tilføj alle batcher
Nu hvor begge funktioner oprettes og datasættet indlæses, kan du skrive en sløjfe for at tilføje dataene i hukommelsen. Hvis du kontrollerer omhyggeligt, hedder den udpakkede fil med dataene data_batch_ med et tal fra 1 til 5. Du kan løbe over filerne og føje den til data.
Når dette trin er udført, konverterer du farvedataene til et gråskalaformat. Som du kan se, er formen på dataene 50000 og 1024. De 32 * 32 pixels er nu flade 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)
Bemærk: Skift './cifar-10-batches-py/data_batch_' til den faktiske placering af din fil. For eksempel til Windows-maskine kunne stien være filnavn = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Trin 4) Konstruer træningsdatasættet
For at gøre træningen hurtigere og lettere, træner du kun en model på hestebillederne. Hestene er den syvende klasse i etiketdataene. Som nævnt i dokumentationen til CIFAR-10 datasættet indeholder hver klasse 5000 billeder. Du kan udskrive formen på dataene for at bekræfte, at der er 5.000 billeder med 1024 kolonner, som vist i nedenstående eksempel på TensorFlow Autoencoder.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Trin 5) Konstruer en billedvisualisator
Endelig konstruerer du en funktion til at plotte billederne. Du skal bruge denne funktion til at udskrive det rekonstruerede billede fra autokoderen.
En nem måde at udskrive billeder på er at bruge objektimshowet fra matplotlib-biblioteket. Bemærk, at du skal konvertere formen på dataene fra 1024 til 32 * 32 (dvs. format på et billede).
# 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")
Funktionen tager 3 argumenter:
- Billede: input
- Form: liste, dimensionens størrelse på billedet
- Cmap: vælg farvekortet. Som standard grå
Du kan prøve at plotte det første billede i datasættet. Du skulle se en mand på en hest.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Indstil datasætestimator
Nu, når datasættet er klar til brug, kan du begynde at bruge Tensorflow. Før vi bygger modellen, lad os bruge datasætestimatoren for Tensorflow til at føde netværket.
Du vil oprette et datasæt med TensorFlow estimator. For at opdatere dit sind skal du bruge:
- fra_tensor_slices
- gentage
- parti
Den fulde kode til at oprette datasættet er:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Bemærk, at x er en pladsholder med følgende form:
- [Ingen, n_input]: Indstil til Ingen, fordi antallet af billedfremføringer til netværket er lig med batchstørrelsen.
for detaljer, se vejledningen om lineær regression.
Derefter skal du oprette iteratoren. Uden denne kodelinje går ingen data gennem pipelinen.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Nu hvor rørledningen er klar, kan du kontrollere, om det første billede er det samme som før (dvs. en mand på en hest).
Du indstiller batchstørrelsen til 1, fordi du kun vil føde datasættet med et billede. Du kan se dimensionen af dataene med print (sess.run (features) .shape). Det er lig med (1, 1024). 1 betyder, at der kun fødes et billede med 1024 hver. Hvis batchstørrelsen er indstillet til to, går to billeder gennem pipelinen. (Ændr ikke batchstørrelsen. Ellers vil det kaste en fejl. Kun et billede ad gangen kan gå til funktionen 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)
Byg netværket
Det er tid til at konstruere netværket. Du træner en stablet autokoder, det vil sige et netværk med flere skjulte lag.
Dit netværk har et inputlag med 1024 punkter, dvs. 32x32, billedets form.
Encoderblokken vil have et øverste skjult lag med 300 neuroner, et centralt lag med 150 neuroner. Dekoderblokken er symmetrisk med koderen. Du kan visualisere netværket på nedenstående billede. Bemærk, at du kan ændre værdierne for skjulte og centrale lag.
Opbygning af netværket til Autoencoder
Opbygning af en autokoder ligner meget enhver anden dyb læringsmodel.
Du konstruerer modellen ved at følge disse trin:
- Definer parametrene
- Definer lagene
- Definer arkitekturen
- Definer optimeringen
- Kør modellen
- Evaluer modellen
I det forrige afsnit lærte du, hvordan du opretter en pipeline til at føde modellen, så der er ikke behov for at oprette datasættet igen. Du konstruerer en autokoder med fire lag. Du bruger Xavier initialisering. Dette er en teknik til at indstille de oprindelige vægte lig med variansen af både input og output. Endelig bruger du elu-aktiveringsfunktionen. Du regulerer tabsfunktionen med L2-regulator.
Trin 1) Definer parametrene
Det første trin indebærer at definere antallet af neuroner i hvert lag, læringshastigheden og hyperparameteret til regulatoren.
Før det importerer du funktionen delvist. Det er en bedre metode til at definere parametrene for de tætte lag. Koden nedenfor definerer værdierne for autoencoder-arkitekturen. Som nævnt før har autokoderen to lag med 300 neuroner i de første lag og 150 i de andet lag. Deres værdier er gemt i n_hidden_1 og n_hidden_2.
Du skal definere indlæringshastigheden og L2-hyperparameteret. Værdierne er gemt 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 kaldes med objektet xavier_initializer fra estimatorbidraget. I samme estimator kan du tilføje 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)
Trin 2) Definer lagene
Alle parametre for de tætte lag er indstillet; du kan pakke alt i variablen dense_layer ved at bruge objektet delvis. dense_layer, der bruger ELU-aktivering, Xavier initialisering og L2-regulering.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
Trin 3) Definer arkitekturen
Hvis du ser på billedet af arkitekturen, bemærker du, at netværket stabler tre lag med et outputlag. I nedenstående kode forbinder du de relevante lag. For eksempel beregner det første lag prikproduktet mellem inputmatricefunktionerne og matricerne, der indeholder de 300 vægte. Når dot-produktet er beregnet, går output til Elu-aktiveringsfunktionen. Outputtet bliver input til det næste lag, det er derfor, du bruger det til at beregne hidden_2 og så videre. Multiplikation af matricer er de samme for hvert lag, fordi du bruger den samme aktiveringsfunktion. Bemærk, at det sidste lag, output, ikke anvender en aktiveringsfunktion. Det giver mening, fordi dette er det rekonstruerede input
## 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)
Trin 4) Definer optimeringen
Det sidste trin er at konstruere optimizer. Du bruger den gennemsnitlige firkantfejl som en tabsfunktion. Hvis du husker vejledningen om lineær regression, ved du, at MSE beregnes med forskellen mellem det forudsagte output og den virkelige etiket. Her er etiketten funktionen, fordi modellen forsøger at rekonstruere input. Derfor vil du have gennemsnittet af summen af forskellen i kvadratet mellem forudsagt output og input. Med TensorFlow kan du kode tabsfunktionen som følger:
loss = tf.reduce_mean(tf.square(outputs - features))
Derefter skal du optimere tabsfunktionen. Du bruger Adam optimizer til at beregne gradienterne. Den objektive funktion er at minimere tabet.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Endnu en indstilling inden træning af modellen. Du vil bruge en batchstørrelse på 150, dvs. foder rørledningen med 150 billeder hver iteration. Du skal beregne antallet af gentagelser manuelt. Dette er trivielt at gøre:
Hvis du vil sende 150 billeder hver gang, og du ved, at der er 5000 billeder i datasættet, er antallet af iterationer lig med. I python kan du køre følgende koder og sørge for, at output er 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Trin 5) Kør modellen
Sidst men ikke mindst, træne modellen. Du træner modellen med 100 epoker. Det vil sige, at modellen vil se 100 gange billederne til optimerede vægte.
Du er allerede bekendt med koderne til at træne en model i Tensorflow. Den lille forskel er at pibe dataene, inden du kører træningen. På denne måde træner modellen hurtigere.
Du er interesseret i at udskrive tabet efter ti epoker for at se, om modellen lærer noget (dvs. tabet falder). Træningen tager 2 til 5 minutter afhængigt af maskinens hardware.
## 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
Trin 6) Evaluer modellen
Nu hvor du har din model uddannet, er det tid til at evaluere den. Du skal 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'])
BEMÆRK: For en Windows-maskine bliver koden test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")
Du kan prøve at udskrive billederne 13, som er en hest
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
For at evaluere modellen skal du bruge pixelværdien af dette billede og se om koderen kan rekonstruere det samme billede efter at have krympet 1024 pixels. Bemærk, at du definerer en funktion til at evaluere modellen på forskellige billeder. Modellen skal kun fungere bedre på heste.
Funktionen tager to argumenter:
- df: Importer testdataene
- image_number: angiv hvilket billede der skal importeres
Funktionen er opdelt i tre dele:
- Omform billedet til den korrekte dimension, dvs. 1, 1024
- Fodre modellen med det usynlige billede, kod / afkod billedet
- Udskriv det rigtige og rekonstruerede billede
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()
Nu hvor evalueringsfunktionen er defineret, kan du se det rekonstruerede billednummer tretten
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Resumé
Det primære formål med en autoencoder er at komprimere inputdataene og derefter komprimere dem til en output, der ligner de originale data.
Arkitekturen for en autokoder symmetrisk med et drejelag, der hedder det centrale lag.
Du kan oprette autokoderen ved hjælp af:
- Delvis: for at oprette de tætte lag med den typiske indstilling:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- dense_layer (): for at lave matrixmultiplikationen
du kan definere tabsfunktionen og optimeringen med:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Sidste løb en session for at træne modellen.