TensorFlow Autoencoder: Tietojoukko syvällisen oppimisen esimerkillä

Mikä on autokooderi?

Autoencoder on työkalu oppimiseen tietojen koodaus tehokkaasti valvomattoman tavalla. Se on eräänlainen keinotekoinen hermoverkko, joka auttaa sinua oppimaan datasarjojen esityksen ulottuvuuden vähentämiseksi kouluttamalla hermoverkkoa sivuuttamaan signaalikohinan. Se on loistava työkalu panoksen luomiseen.

Yksinkertaisesti sanottuna kone ottaa, sanotaan esimerkiksi kuva, ja voi tuottaa läheisen kuvan. Tämäntyyppisen hermoverkon syötettä ei ole merkitty, mikä tarkoittaa, että verkko pystyy oppimaan ilman valvontaa. Tarkemmin sanottuna verkko koodaa tulon keskittymään vain kriittisimpään ominaisuuteen. Tämä on yksi syy siihen, miksi autokooderi on suosittu dimensioiden pienentämisessä. Lisäksi autokoodereita voidaan käyttää generatiivisten oppimismallien tuottamiseen . Esimerkiksi hermoverkko voidaan kouluttaa joukolla kasvoja ja tuottaa sitten uusia kasvoja.

Tässä TensorFlow Autoencoder -opetusohjelmassa opit:

• Mikä on autokooderi?
• Kuinka Autoencoder toimii?
• Esimerkki pinotusta automaattikooderista
• Rakenna automaattikooderi TensorFlow: lla
• Kuvan esikäsittely
• Aseta tietojoukkoestimaattori
• Rakenna verkko

Kuinka Autoencoder toimii?

Autokooderin tarkoituksena on tuottaa tulo likimääräisesti keskittymällä vain olennaisiin ominaisuuksiin. Saatat ajatella, miksi et vain oppisi kopioimaan ja liittämään syötettä tuotoksen tuottamiseksi. Itse asiassa autokooderi on joukko rajoituksia, jotka pakottavat verkon oppimaan uusia tapoja edustaa tietoja, jotka eroavat pelkästään lähdön kopioinnista.

Tyypillinen autokooderi määritellään tulolla, sisäisellä esityksellä ja lähdöllä (tulon likiarvo). Oppiminen tapahtuu sisäiseen esitykseen kiinnitetyissä kerroksissa. Itse asiassa on olemassa kaksi pääkerroslohkoa, joka näyttää perinteiseltä hermoverkolta. Pieni ero on, että ulostulon sisältävän kerroksen on oltava sama kuin tulo. Alla olevassa kuvassa alkuperäinen tulo menee ensimmäiseen lohkoon, jota kutsutaan kooderiksi . Tämä sisäinen esitys pakkaa (pienentää) tulon kokoa. Toisessa lohkossa tapahtuu tulon rekonstruointi. Tämä on dekoodausvaihe.

Autoencoderin toiminta

Malli päivittää painot minimoimalla häviötoiminnon. Malli saa rangaistuksen, jos jälleenrakennustulos eroaa syötteestä.

Kuvittele konkreettisesti kuva, jonka koko on 50x50 (eli 250 pikseliä) ja hermoverkko, jossa on vain yksi piilotettu kerros, joka koostuu sadasta neuronista. Oppiminen tapahtuu kartalla, joka on kaksi kertaa pienempi kuin tulo. Se tarkoittaa, että verkon on löydettävä tapa rekonstruoida 250 pikseliä vain hermovektorin ollessa 100.

Esimerkki pinotusta automaattikooderista

Tässä Autoencoder-opetusohjelmassa opit pinotun kooderin käyttämisen. Arkkitehtuuri on samanlainen kuin perinteinen hermoverkko. Tulo menee piilotettuun kerrokseen pakattavaksi tai pienentämään sen kokoa ja saavuttaa sitten rekonstruointikerrokset. Tavoitteena on tuottaa yhtä lähdekuva kuin alkuperäinen. Mallin on opittava tapa saavuttaa tehtävänsä joukossa rajoituksia, toisin sanoen alemmalla ulottuvuudella.

Nykyään Deep Learningin automaattikoodereita käytetään pääasiassa kuvan poistamiseen. Kuvittele kuva, jossa on naarmuja; ihminen pystyy edelleen tunnistamaan sisällön. Automaattikooderin tyhjentämisen idea on lisätä kuvaan kohinaa pakottaakseen verkko oppimaan datan takana oleva kuvio.

Toinen hyödyllinen Autoencoder Deep Learning -perhe on variaatioautokooderi. Tämän tyyppinen verkko voi luoda uusia kuvia. Kuvittele, että koulutat verkkoa miehen kuvalla; tällainen verkko voi tuottaa uusia kasvoja.

Rakenna automaattikooderi TensorFlow: lla

Tässä opetusohjelmassa opit rakentamaan pinotun automaattisen kooderin kuvan rekonstruoimiseksi.

Käytät CIFAR-10-tietojoukkoa, joka sisältää 60000 32x32-värikuvaa. Autoencoder-tietojoukko on jo jaettu 50000 kuvan harjoittelua varten ja 10000 kuvan testaamista varten. Luokkia on enintään kymmenen:

• Lentokone
• Auto
• Lintu
• Kissa
• Peura
• Koira
• Sammakko
• Hevonen
• Alus
• Kuorma-auto

Sinun on ladattava kuvat tähän URL-osoitteeseen https://www.cs.toronto.edu/~kriz/cifar.html ja purettava se. Kansio for-10-batches-py sisältää viisi erää tietoa, joissa on 10000 kuvaa kukin satunnaisessa järjestyksessä.

Ennen mallin rakentamista ja kouluttamista sinun on käytettävä tietojenkäsittelyä. Toimi seuraavasti:

1. Tuo tiedot
2. Muunna tiedot mustavalkoiseksi
3. Liitä kaikki erät
4. Rakenna harjoitustietojoukko
5. Rakenna kuvan visualisointi

Kuvan esikäsittely

Vaihe 1) Tuo tiedot.

Virallisen verkkosivuston mukaan voit ladata tiedot seuraavalla koodilla. Autoencoder-koodi lataa tiedot sanakirjaan tiedot ja tarran kanssa . Huomaa, että koodi on funktio.

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

Vaihe 2) Muunna tiedot mustavalkoiseen muotoon

Yksinkertaisuuden vuoksi muunnat tiedot harmaasävyiksi. Eli vain yksi ulottuvuus kolmea vastaan ​​värikuvassa. Suurin osa hermoverkosta toimii vain yhden ulottuvuuden tulon kanssa.

def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Vaihe 3) Liitä kaikki erät

Nyt kun molemmat toiminnot on luotu ja tietojoukko ladattu, voit kirjoittaa silmukan tietojen liittämiseksi muistiin. Jos tarkistat tarkkaan, puretun tiedoston sisältävän tiedoston nimi on data_batch_ numerolla 1-5. Voit yhdistää tiedostot ja liittää ne dataan.

Kun tämä vaihe on valmis, muunnat väritiedot harmaasävymuotoon. Kuten näette, datan muoto on 50000 ja 1024. 32 * 32 pikseliä on nyt litistetty vuoteen 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)

Huomaa: Muuta './cifar-10-batches-py/data_batch_' tiedoston todelliseen sijaintiin. Esimerkiksi Windows-koneelle polku voi olla tiedostonimi = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)

Vaihe 4) Rakenna harjoitustietojoukko

Harjoittelun nopeuttamiseksi ja helpottamiseksi harjoittelet mallia vain hevoskuvilla. Hevoset ovat seitsemäs luokka etikettitiedoissa. Kuten CIFAR-10-tietojoukon dokumentaatiossa mainitaan, jokainen luokka sisältää 5000 kuvaa. Voit tulostaa tietojen muodon varmistaaksesi, että on 5 000 kuvaa 1024 sarakkeella, kuten alla olevassa TensorFlow Autoencoder -esimerkkivaiheessa on esitetty.

horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)

Vaihe 5) Rakenna kuvan visualisointi

Lopuksi muodostat funktion kuvien piirtämiseksi. Tarvitset tätä toimintoa, kun haluat tulostaa rekonstruoidun kuvan autokooderista.

Helppo tapa tulostaa kuvia on käyttää objektin imshow matplotlib-kirjastosta. Huomaa, että sinun on muunnettava tietojen muoto arvosta 1024 muotoon 32 * 32 (eli kuvan muoto).

# 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")

Funktiossa on 3 argumenttia:

• Kuva: tulo
• Muoto: luettelo, kuvan ulottuvuus
• Cmap: valitse värikartta. Oletuksena harmaa

Voit yrittää piirtää tietojoukon ensimmäisen kuvan. Sinun pitäisi nähdä mies hevosella.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r") 

Aseta tietojoukkoestimaattori

No, nyt, kun tietojoukko on käyttövalmis, voit alkaa käyttää Tensorflow-ohjelmaa. Ennen mallin rakentamista käytetään verkon syöttämiseen Tensorflow-tietojoukkoestimaattoria.

Rakennat tietojoukon TensorFlow-estimaattorilla. Päivitä mielesi käyttämällä seuraavia:

• from_tensor_slices
• toistaa
• erä

Tietokokonaisuuden koko koodi on:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size) 

Huomaa, että x on paikkamerkki, jolla on seuraava muoto:

• [Ei mitään, n_tulot]: Valitse Ei mitään, koska verkkoon syötetyn kuvan määrä on yhtä suuri kuin eräkoko.

Katso lisätietoja lineaarisen regressio-oppaasta.

Sen jälkeen sinun on luotava iteraattori. Ilman tätä koodiriviä tietoja ei mene putkilinjan läpi.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next() 

Nyt kun putki on valmis, voit tarkistaa, onko ensimmäinen kuva sama kuin aiemmin (ts. Mies hevosella).

Asetat eräkoon 1, koska haluat syöttää tietojoukon vain yhdellä kuvalla. Näet tietojen ulottuvuudet tulostuksella (sess.run (features) .shape). Se on yhtä suuri kuin (1, 1024). 1 tarkoittaa, että vain yksi kuva, jossa on 1024, syötetään kukin. Jos eräkoko on asetettu kahteen, putkilinjan läpi kulkee kaksi kuvaa. (Älä muuta eräkokoa. Muuten se aiheuttaa virheen. Vain yksi kuva kerrallaan voi siirtyä funktioon 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)

Rakenna verkko

On aika rakentaa verkko. Koulutat pinotun kooderin eli verkon, jossa on useita piilotettuja kerroksia.

Verkossasi on yksi syöttökerros, jossa on 1024 pistettä, eli 32x32, kuvan muoto.

Kooderilohkossa on yksi piilotettu yläkerros, jossa on 300 hermosolua, ja keskikerros, jossa on 150 hermosolua. Dekooderilohko on symmetrinen kooderille. Voit visualisoida verkon alla olevassa kuvassa. Huomaa, että voit muuttaa piilotettujen ja keskitasojen arvoja.

Verkon rakentaminen Autoencoderille

Autokooderin rakentaminen on hyvin samanlainen kuin mikä tahansa muu syvällisen oppimisen malli.

Rakennat mallin seuraavasti:

1. Määritä parametrit
2. Määritä kerrokset
3. Määritä arkkitehtuuri
4. Määritä optimointi
5. Suorita malli
6. Arvioi malli

Edellisessä osassa opit luomaan putkilinjan mallin syöttämiseksi, joten tietojoukkoa ei tarvitse luoda uudelleen. Rakennat neljä koodikerrosta olevan kooderin. Käytät Xavier-alustusta. Tämä on tekniikka, jolla alkupainot asetetaan yhtä suuriksi kuin tulon ja lähdön varianssi. Lopuksi käytät elu aktivointitoimintoa. Normalisoit tappiotoiminnon L2-säätimellä.

Vaihe 1) Määritä parametrit

Ensimmäisessä vaiheessa määritetään jokaisen kerroksen neuronien lukumäärä, oppimisnopeus ja säätimen hyperparametri.

Ennen sitä tuot funktion osittain. Se on parempi menetelmä määritellä tiheiden kerrosten parametrit. Alla oleva koodi määrittää autokooderin arkkitehtuurin arvot. Kuten edellä on lueteltu, autokooderissa on kaksi kerrosta, ensimmäisissä kerroksissa on 300 neuronia ja toisissa kerroksissa 150. Niiden arvot tallennetaan n_hidden_1 ja n_hidden_2.

Sinun on määritettävä oppimisnopeus ja L2-hyperparametri. Arvot tallennetaan learning_rate ja 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-alustusmenetelmää kutsutaan objektilla xavier_initializer estimaattoriosoitteesta. Samassa estimaattorissa voit lisätä säätimen l2_ regularizerilla

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Vaihe 2) Määritä kerrokset

Kaikki tiheiden kerrosten parametrit on asetettu; Voit pakata kaiken muuttujaan dense_layer käyttämällä osiobjektia. dense_layer, joka käyttää ELU-aktivointia, Xavier-alustusta ja L2-laillistamista.

## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)

Vaihe 3) Määritä arkkitehtuuri

Jos tarkastelet arkkitehtuurin kuvaa, huomaat, että verkko pinottaa kolme tasoa ulostulotasolla. Yhdistä alla olevaan koodiin sopivat kerrokset. Esimerkiksi ensimmäinen kerros laskee pistetulon syöttömatriisin ominaisuuksien ja 300 painoa sisältävien matriisien välillä. Kun pistetuote on laskettu, lähtö siirtyy Elu-aktivointitoimintoon. Tuloksesta tulee seuraavan kerroksen tulo, minkä vuoksi sitä käytetään piilotetun_2 ja niin edelleen laskemiseen. Matriisien kertolasku on sama jokaiselle tasolle, koska käytät samaa aktivointitoimintoa. Huomaa, että viimeinen taso, lähdöt, ei käytä aktivointitoimintoa. Se on järkevää, koska tämä on rekonstruoitu panos

## 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)

Vaihe 4) Määritä optimointi

Viimeinen vaihe on rakentaa optimoija. Keskimääräinen neliövirhe käytetään menetystoimintona. Jos muistat lineaarisen regressiohjeen, tiedät, että MSE lasketaan ennustetun ulostulon ja todellisen tarran erolla. Tässä tarra on ominaisuus, koska malli yrittää rekonstruoida syötteen. Siksi haluat ennustetun lähdön ja syötteen välisen neliön eron keskiarvon. TensorFlow-sovelluksella voit koodata menetystoiminnon seuraavasti:

loss = tf.reduce_mean(tf.square(outputs - features)) 

Sitten sinun on optimoitava menetystoiminto. Laske kaltevuudet Adam-optimoijan avulla. Tavoitteena on minimoida menetys.

## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Vielä yksi asetus ennen mallin harjoittelua. Haluat käyttää eräkokoa 150, ts. Syöttää putkistoon 150 kuvaa kutakin iteraatiota kohti. Sinun on laskettava iteraatioiden määrä manuaalisesti. Tämä on triviaalia:

Jos haluat välittää 150 kuvaa joka kerta ja tiedät, että tietojoukossa on 5000 kuvaa, toistojen määrä on yhtä suuri kuin. Pythonissa voit suorittaa seuraavat koodit ja varmistaa, että lähtö on 33:

BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

Vaihe 5) Suorita malli

Viimeisenä mutta ei vähäisimpänä, kouluta mallia. Harjoittelet mallia 100 aikakaudella. Toisin sanoen malli näkee kuvat 100 kertaa optimoidulla painolla.

Olet jo perehtynyt koodeihin mallin kouluttamiseksi Tensorflow'ssa. Pieni ero on tietojen välittäminen ennen harjoituksen suorittamista. Tällä tavalla malli harjoittaa nopeammin.

Olet kiinnostunut tulostamaan häviön kymmenen aikakauden jälkeen, jotta näet, oppieko malli jotain (ts. Menetys vähenee). Harjoittelu kestää 2–5 minuuttia koneesi laitteistosta riippuen.

## 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

Vaihe 6) Arvioi malli

Nyt kun mallisi on koulutettu, on aika arvioida se. Testisertti on tuotava tiedostosta / 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'])

HUOMAUTUS: Windows-koneessa koodista tulee test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")

Voit yrittää tulostaa kuvat 13, joka on hevonen

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r") 

Mallin arvioimiseksi käytetään tämän kuvan pikseliarvoa ja näet, pystyykö kooderi rekonstruoimaan saman kuvan kutistettuaan 1024 pikseliä. Huomaa, että määrität toiminnon mallin arvioimiseksi eri kuvissa. Mallin tulisi toimia paremmin vain hevosilla.

Funktiolla on kaksi argumenttia:

• df: Tuo testitiedot
• image_number: ilmoita tuotava kuva

Toiminto on jaettu kolmeen osaan:

1. Muuta kuva oikeaan mittaan eli 1, 1024
2. Syötä malli näkymättömällä kuvalla, koodaa / purkaa kuva
3. Tulosta todellinen ja rekonstruoitu kuva

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()

Nyt kun arviointitoiminto on määritetty, voit katsoa rekonstruoidun kuvan numeron kolmetoista

reconstruct_image(df =test_x, image_number = 13) 

INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

Yhteenveto

Autokooderin ensisijainen tarkoitus on pakata syötetyt tiedot ja purkaa ne sitten lähtöön, joka näyttää läheiseltä alkuperäiseltä.

Autoenkooderin arkkitehtuuri, joka on symmetrinen keskikerrokseksi kutsutun kääntökerroksen kanssa.

Voit luoda automaattisen kooderin seuraavasti:

• Osittainen: Tiheiden kerrosten luominen tyypillisellä asetuksella:

• tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer

• dense_layer (): matriisin kertolasku

voit määrittää häviöfunktion ja optimoinnin:

loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Suorita viimeinen istunto mallin kouluttamiseksi.