Vad är en autokodare?
En autokodare är ett verktyg för effektiv inlärning av datakodning på ett övervakat sätt. Det är en typ av artificiellt neurala nätverk som hjälper dig att lära dig hur datauppsättningar representeras för dimensioneringsreduktion genom att träna neuronnätverket för att ignorera signalbruset. Det är ett utmärkt verktyg för att återskapa en ingång.
Med enkla ord tar maskinen, låt oss säga en bild, och kan producera en närbesläktad bild. Ingångarna i denna typ av neurala nätverk är omärkta, vilket innebär att nätverket kan lära sig utan tillsyn. Mer exakt är ingången kodad av nätverket för att bara fokusera på den mest kritiska funktionen. Detta är en av anledningarna till att autokodare är populär för dimensioneringsreduktion. Dessutom kan autokodare användas för att producera generativa inlärningsmodeller . Till exempel kan det neurala nätverket tränas med en uppsättning ansikten och sedan producera nya ansikten.
I denna TensorFlow Autoencoder-handledning lär du dig:
- Vad är en autokodare?
- Hur fungerar Autoencoder?
- Stacked Autoencoder Exempel
- Skapa en autokodare med TensorFlow
- Bildförbehandling
- Ställ in datamängdsberäknaren
- Bygg nätverket
Hur fungerar Autoencoder?
Syftet med en autokodare är att producera en approximation av ingången genom att bara fokusera på de väsentliga funktionerna. Du kanske tänker varför inte bara lära dig att kopiera och klistra in ingången för att producera utdata. Faktum är att en autokodare är en uppsättning begränsningar som tvingar nätverket att lära sig nya sätt att representera data, annorlunda än att bara kopiera utdata.
En typisk autokodare definieras med en ingång, en intern representation och en utgång (en approximation av ingången). Lärandet sker i skikten fästa vid den interna representationen. Faktum är att det finns två huvudsakliga lagerblock som ser ut som ett traditionellt neuralt nätverk. Den lilla skillnaden är att skiktet som innehåller utdata måste vara lika med ingången. På bilden nedan går originalinmatningen till det första blocket som kallas kodaren . Denna interna representation komprimerar (minskar) storleken på ingången. I det andra blocket sker rekonstruktionen av ingången. Detta är avkodningsfasen.
Arbeta med Autoencoder
Modellen uppdaterar vikterna genom att minimera förlustfunktionen. Modellen straffas om återuppbyggnadsutgången skiljer sig från ingången.
Föreställ dig konkret en bild med en storlek på 50x50 (dvs. 250 pixlar) och ett neuralt nätverk med bara ett dolt lager bestående av hundra neuroner. Lärandet sker på en funktionskarta som är två gånger mindre än ingången. Det betyder att nätverket måste hitta ett sätt att rekonstruera 250 pixlar med endast en neuronsvektor som är lika med 100.
Stacked Autoencoder Exempel
I den här Autoencoder-självstudien lär du dig hur du använder en staplad autoencoder. Arkitekturen liknar ett traditionellt neuralt nätverk. Ingången går till ett dolt lager för att komprimeras eller minska dess storlek och når sedan rekonstruktionsskikten. Målet är att producera en utgående bild så nära originalet. Modellen måste lära sig ett sätt att uppnå sin uppgift under en uppsättning begränsningar, det vill säga med en lägre dimension.
Numera används autokodare i Deep Learning främst för att denoisera en bild. Föreställ dig en bild med repor; en människa kan fortfarande känna igen innehållet. Tanken med att förneka autoencoder är att lägga till brus i bilden för att tvinga nätverket att lära sig mönstret bakom data.
Den andra användbara familjen av Autoencoder Deep Learning är variationer av autoencoder. Denna typ av nätverk kan generera nya bilder. Tänk dig att du tränar ett nätverk med bilden av en man; ett sådant nätverk kan producera nya ansikten.
Skapa en autokodare med TensorFlow
I den här handledningen lär du dig hur du bygger en staplad autokodare för att rekonstruera en bild.
Du kommer att använda CIFAR-10-datasetet som innehåller 60000 32x32 färgbilder. Autoencoder-datasetet är redan uppdelat mellan 50000 bilder för utbildning och 10000 för testning. Det finns upp till tio klasser:
- Flygplan
- Bil
- Fågel
- Katt
- Rådjur
- Hund
- Groda
- Häst
- Fartyg
- Lastbil
Du måste ladda ner bilderna i denna URL https://www.cs.toronto.edu/~kriz/cifar.html och packa upp den. Mappen för-10-satser-py innehåller fem satser med data med 10000 bilder vardera i slumpmässig ordning.
Innan du bygger och tränar din modell måste du tillämpa en del databehandling. Du fortsätter enligt följande:
- Importera data
- Konvertera data till svartvitt format
- Lägg till alla satser
- Konstruera utbildningsdataset
- Konstruera en bildvisualiserare
Bildförbehandling
Steg 1) Importera data.
Enligt den officiella webbplatsen kan du ladda upp data med följande kod. Autoencoder-koden laddar data i en ordlista med data och etikett . Observera att koden är 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
Steg 2) Konvertera data till svartvitt format
För enkelhetens skull kommer du att konvertera data till en gråskala. Det vill säga med endast en dimension mot tre för färger bild. Det mesta av det neurala nätverket fungerar bara med en dimensionsingång.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Steg 3) Lägg till alla satser
Nu när båda funktionerna har skapats och datamängden laddats kan du skriva en slinga för att lägga till data i minnet. Om du kontrollerar noggrant får namnet på zip-filen med data data_batch_ med ett nummer från 1 till 5. Du kan slinga över filerna och lägga till den i data.
När detta steg är klart konverterar du färgdata till ett gråskaleformat. Som du kan se är formen på data 50000 och 1024. De 32 * 32 pixlarna är nu platta till 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)
Obs! Ändra './cifar-10-batches-py/data_batch_' till din faktiska plats. Till exempel för Windows-maskin kan sökvägen vara filnamn = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Steg 4) Konstruera träningsdatasetet
För att göra träningen snabbare och enklare tränar du bara en modell på hästbilderna. Hästarna är den sjunde klassen i etikettdata. Som nämnts i dokumentationen för datasetet CIFAR-10 innehåller varje klass 5000 bilder. Du kan skriva ut formen på data för att bekräfta att det finns 5.000 bilder med 1024 kolumner som visas i exemplet nedan för TensorFlow Autoencoder.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Steg 5) Konstruera en bildvisualiserare
Slutligen konstruerar du en funktion för att plotta bilderna. Du behöver den här funktionen för att skriva ut den rekonstruerade bilden från autokodaren.
Ett enkelt sätt att skriva ut bilder är att använda objektbilden från matplotlib-biblioteket. Observera att du måste konvertera formen på data från 1024 till 32 * 32 (dvs. format på en bild).
# 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 tar 3 argument:
- Bild: ingången
- Form: lista, dimensionens storlek
- Cmap: välj färgkarta. Som standard är grå
Du kan försöka plotta den första bilden i datasetet. Du borde se en man på en häst.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Ställ in datamängdsberäknaren
Nu när datamängden är redo att användas kan du börja använda Tensorflow. Innan vi bygger modellen, låt oss använda Dataset estimator för Tensorflow för att mata nätverket.
Du kommer att bygga en datamängd med TensorFlow-beräknaren. För att uppdatera dig måste du använda:
- från_tensor_skivor
- upprepa
- omgång
Den fullständiga koden för att bygga datamängden är:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Observera att x är en platshållare med följande form:
- [Ingen, n_ingångar]: Ställ in på Ingen eftersom antalet bildmatningar till nätverket är lika med batchstorleken.
För mer information, se handledningen om linjär regression.
Efter det måste du skapa iteratorn. Utan denna kod kommer ingen data att gå igenom rörledningen.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Nu när rörledningen är klar kan du kontrollera om den första bilden är densamma som tidigare (dvs. en man på en häst).
Du ställer in batchstorleken till 1 eftersom du bara vill mata dataset med en bild. Du kan se dimensionens data med utskrift (sess.run (features) .shape). Det är lika med (1, 1024). 1 betyder att endast en bild med 1024 matas vardera. Om batchstorleken är inställd på två kommer två bilder att gå igenom rörledningen. (Ändra inte batchstorleken. Annars ger det ett fel. Endast en bild i taget kan gå till 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)
Bygg nätverket
Det är dags att bygga nätverket. Du kommer att träna en staplad autokodare, det vill säga ett nätverk med flera dolda lager.
Ditt nätverk kommer att ha ett inmatningsskikt med 1024 punkter, dvs. 32x32, bildens form.
Kodarblocket kommer att ha ett översta dolt lager med 300 neuroner, ett centralt lager med 150 neuroner. Avkodarblocket är symmetriskt med kodaren. Du kan visualisera nätverket på bilden nedan. Observera att du kan ändra värdena för dolda och centrala lager.
Bygga nätverket för Autoencoder
Att bygga en autokodare liknar mycket alla andra modeller för djup inlärning.
Du kommer att konstruera modellen enligt följande steg:
- Definiera parametrarna
- Definiera lager
- Definiera arkitekturen
- Definiera optimeringen
- Kör modellen
- Utvärdera modellen
I föregående avsnitt lärde du dig hur du skapar en pipeline för att mata modellen, så det finns inget behov av att skapa datamängden en gång till. Du kommer att konstruera en autokodare med fyra lager. Du använder Xavier-initialiseringen. Detta är en teknik för att ställa in initialvikterna lika med variansen för både ingång och utgång. Slutligen använder du elu-aktiveringsfunktionen. Du reglerar förlustfunktionen med L2-regulator.
Steg 1) Definiera parametrarna
Det första steget innebär att man definierar antalet neuroner i varje lager, inlärningshastigheten och hyperparametern för regulatorn.
Innan dess importerar du funktionen delvis. Det är en bättre metod att definiera parametrarna för de täta skikten. Koden nedan definierar värdena för autokodarkitekturen. Som nämnts tidigare har autokodaren två lager, med 300 nervceller i de första lagren och 150 i de andra lagren. Deras värden lagras i n_hidden_1 och n_hidden_2.
Du måste definiera inlärningshastigheten och L2-hyperparametern. Värdena lagras i learning_rate och 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-initialiseringstekniken anropas med objektet xavier_initializer från uppskattningsbidraget. I samma uppskattare kan du lägga till regulatorn 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)
Steg 2) Definiera lager
Alla parametrar för de täta skikten har ställts in; du kan packa allt i variabeln dense_layer genom att använda objektet partiellt. dense_layer som använder ELU-aktivering, Xavier-initialisering och L2-regularisering.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
Steg 3) Definiera arkitekturen
Om du tittar på bilden av arkitekturen noterar du att nätverket staplar tre lager med ett utgående lager. I koden nedan ansluter du lämpliga lager. Till exempel beräknar det första lagret punktprodukten mellan ingångsmatrisfunktionerna och matriserna som innehåller de 300 vikterna. Efter att punktprodukten har beräknats går utgången till Elu-aktiveringsfunktionen. Utgången blir ingången till nästa lager, det är därför du använder den för att beräkna hidden_2 och så vidare. Matriseringsmultiplikationen är densamma för varje lager eftersom du använder samma aktiveringsfunktion. Observera att det sista lagret, utgångar, inte använder en aktiveringsfunktion. Det är vettigt eftersom det här är den rekonstruerade ingången
## 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)
Steg 4) Definiera optimeringen
Det sista steget är att konstruera optimeraren. Du använder Mean Square Error som en förlustfunktion. Om du kommer ihåg handledningen om linjär regression vet du att MSE beräknas med skillnaden mellan den förutsagda utgången och den verkliga etiketten. Här är etiketten funktionen eftersom modellen försöker rekonstruera ingången. Därför vill du ha medelvärdet av summan av skillnaden i kvadraten mellan förutsagd utgång och ingång. Med TensorFlow kan du koda förlustfunktionen enligt följande:
loss = tf.reduce_mean(tf.square(outputs - features))
Då måste du optimera förlustfunktionen. Du använder Adam optimizer för att beräkna lutningarna. Objektivfunktionen är att minimera förlusten.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Ytterligare en inställning innan du tränar modellen. Du vill använda en satsstorlek på 150, det vill säga mata rörledningen med 150 bilder varje iteration. Du måste beräkna antalet iterationer manuellt. Detta är trivialt att göra:
Om du vill skicka 150 bilder varje gång och du vet att det finns 5000 bilder i datasetet är antalet iterationer lika med. I python kan du köra följande koder och se till att utdata är 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Steg 5) Kör modellen
Sist men inte minst, träna modellen. Du tränar modellen med 100 epoker. Det vill säga modellen ser 100 gånger bilderna till optimerade vikter.
Du är redan bekant med koderna för att träna en modell i Tensorflow. Den lilla skillnaden är att leda data innan du kör träningen. På detta sätt tränar modellen snabbare.
Du är intresserad av att skriva ut förlusten efter tio epoker för att se om modellen lär sig något (dvs. förlusten minskar). Träningen tar 2 till 5 minuter, beroende på maskinens maskinvara.
## 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
Steg 6) Utvärdera modellen
Nu när du har fått din modell utbildad är det dags att utvärdera den. Du måste importera testserten från 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'])
OBS: För en Windows-maskin blir koden test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")
Du kan försöka skriva ut bilderna 13, som är en häst
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
För att utvärdera modellen använder du pixelvärdet för denna bild och ser om kodaren kan rekonstruera samma bild efter att krympa 1024 pixlar. Observera att du definierar en funktion för att utvärdera modellen på olika bilder. Modellen ska fungera bättre bara på hästar.
Funktionen tar två argument:
- df: Importera testdata
- bildnummer: ange vilken bild som ska importeras
Funktionen är uppdelad i tre delar:
- Forma bilden till rätt dimension, dvs. 1, 1024
- Mata modellen med den osynliga bilden, koda / avkoda bilden
- Skriv ut den riktiga och rekonstruerade bilden
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 när utvärderingsfunktionen är definierad kan du titta på det rekonstruerade bildnumret tretton
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Sammanfattning
Det primära syftet med en autokodare är att komprimera ingångsdata och sedan packa upp den till en utgång som ser ut som originaldata.
Arkitekturen för en autokodare symmetrisk med ett pivotlager som heter det centrala lagret.
Du kan skapa autokodaren med:
- Delvis: för att skapa täta lager med den typiska inställningen:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- dense_layer (): för att göra matrixmultiplikationen
du kan definiera förlustfunktionen och optimeringen med:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Senast kör en session för att träna modellen.