Mis on autokooder?
Autoencoder on vahend õppida andmekodeerimisskeemi tõhusalt järelevalveta viisil. See on kunstliku närvivõrgu tüüp, mis aitab teil õppida andmekogumite kujutist mõõtmete vähendamiseks, õpetades närvivõrku signaalimüra eirama. See on suurepärane vahend sisendi taastamiseks.
Lihtsamalt öeldes teeb masin, ütleme näiteks, pildi ja suudab luua lähedase pildi. Sellise närvivõrgu sisend on sildistamata, see tähendab, et võrk on võimeline õppima ilma järelevalveta. Täpsemalt, võrk kodeerib sisendi, et keskenduda ainult kõige kriitilisemale funktsioonile. See on üks põhjustest, miks autokooder on populaarne mõõtmete vähendamiseks. Pealegi saab autokoodereid kasutada generatiivsete õppemudelite loomiseks . Näiteks saab närvivõrku treenida näokomplektiga ja seejärel luua uusi nägusid.
Selles TensorFlow Autoencoderi õpetuses saate teada:
- Mis on autokooder?
- Kuidas Autoencoder töötab?
- Virnastatud automaatkoodri näide
- Ehitage TensorFlow abil automaatkooder
- Kujutise eeltöötlus
- Määra andmekogumi prognoosija
- Ehitage võrk
Kuidas Autoencoder töötab?
Autokooderi eesmärk on toota sisend ligilähedaselt, keskendudes ainult olulistele tunnustele. Võite mõelda, miks mitte ainult õppida sisendi kopeerimist ja kleepimist väljundi loomiseks. Tegelikult on autokooder piirangute kogum, mis sunnib võrku õppima uusi võimalusi andmete esitamiseks, mis erinevad ainult väljundi kopeerimisest.
Tüüpiline autokooder määratletakse sisendi, sisemise kujutise ja väljundiga (sisendi ligikaudne väärtus). Õppimine toimub sisemise kujutise külge kinnitatud kihtides. Tegelikult on kaks kihtide plokki, mis näeb välja nagu traditsiooniline närvivõrk. Väike erinevus on see, et väljundit sisaldav kiht peab olema sisendiga võrdne. Alloleval pildil läheb algne sisend esimesse plokki, mida nimetatakse koodriks . See sisemine esitus tihendab (vähendab) sisendi suurust. Teises plokis toimub sisendi rekonstrueerimine. See on dekodeerimise etapp.
Autoencoderi töö
Mudel ajakohastab kaalu, minimeerides kadumisfunktsiooni. Mudelit karistatakse juhul, kui rekonstrueerimise väljund erineb sisendist.
Konkreetselt kujutlege pilti suurusega 50x50 (st 250 pikslit) ja närvivõrku, kus on ainult üks peidetud kiht, mis koosneb sajast neuronist. Õppimine toimub funktsioonikaardil, mis on sisendist kaks korda väiksem. See tähendab, et võrk peab leidma viisi, kuidas rekonstrueerida 250 pikslit ainult neuronite vektoriga, mis on võrdne 100-ga.
Virnastatud automaatkoodri näide
Selles Autoencoderi õpetuses saate teada, kuidas virnastatud autokooderit kasutada. Arhitektuur sarnaneb traditsioonilise närvivõrguga. Sisend läheb tihendatud või selle suuruse vähendamiseks peidetud kihti ja jõuab seejärel rekonstrueerimiskihtideni. Eesmärk on toota originaaliga sama lähedane väljundpilt. Mudel peab õppima viisi, kuidas oma ülesannet täita piirangute alusel, see tähendab madalama mõõtmega.
Tänapäeval kasutatakse Deep Learningu autokoodereid peamiselt pildi eemaldamiseks. Kujutage ette kriimustustega pilti; inimene suudab ikkagi sisu ära tunda. Autokooderi tühjendamise idee on lisada pildile müra, et sundida võrku õppima andmete taga olevat mustrit.
Teine kasulik Autoencoder Deep Learning perekond on variatsiooniline autoencoder. Seda tüüpi võrk võib luua uusi pilte. Kujutage ette, et treenite mehe kuvandiga võrku; selline võrk võib luua uusi nägusid.
Ehitage TensorFlow abil automaatkooder
Selles õpetuses saate teada, kuidas luua pildi rekonstrueerimiseks virnastatud auto kooder.
Kasutate CIFAR-10 andmekogumit, mis sisaldab 60000 32x32 värvilist pilti. Autoencoderi andmekogum on juba jagatud koolituse jaoks 50000 pildi ja testimiseks 10000 pildi vahel. Klassid on kuni kümme:
- Lennuk
- Autod
- Lind
- Kass
- Hirved
- Koer
- Konn
- Hobune
- Laev
- Veoauto
Peate selle URL-i pildid alla laadima https://www.cs.toronto.edu/~kriz/cifar.html ja pakkima. Kaust for-10-batches-py sisaldab viit andmepartiid, milles igaühes on 10000 pilti juhuslikus järjekorras.
Enne oma mudeli koostamist ja koolitamist peate rakendama mõnda andmetöötlust. Te jätkate järgmiselt:
- Importige andmed
- Teisendage andmed mustvalgeks
- Lisage kõik partiid
- Ehitage koolituse andmekogum
- Ehitage pildi visualiseerija
Kujutise eeltöötlus
1. samm. Importige andmed.
Ametliku veebisaidi andmetel saate andmeid üles laadida järgmise koodiga. Autoencoderi kood laadib andmed sõnastikku koos andmete ja sildiga . Pange tähele, et kood on funktsioon.
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
2. samm. Teisendage andmed mustvalgeks
Lihtsuse huvides teisendate andmed halltooniks. See tähendab, et värvipildi jaoks on ainult üks mõõde kolme vastu. Suurem osa närvivõrgust töötab ainult ühe dimensiooni sisendiga.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Samm 3) Lisage kõik partiid
Nüüd, kui mõlemad funktsioonid on loodud ja andmekogum laaditud, saate kirjutada silmuse andmete lisamiseks mällu. Hoolikalt kontrollides nimetatakse andmetega lahtipakitud faili nimeks data_batch_ numbriga 1 kuni 5. Võite failide vahel üle vaadata ja andmetele lisada.
Kui see samm on tehtud, teisendate värvid andmed halli skaala vormingusse. Nagu näete, on andmete kuju 50000 ja 1024. 32 * 32 pikslit on nüüd tasandatud aastani 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)
Märkus. Muutke './cifar-10-batches-py/data_batch_' oma faili tegelikuks asukohaks. Näiteks Windowsi masina jaoks võib tee olla failinimi = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
4. samm. Koostage koolituse andmekogum
Treeningu kiiremaks ja lihtsamaks muutmiseks treenite mudeli ainult hobuse piltidel. Hobused on märgistuse andmetes seitsmes klass. Nagu CIFAR-10 andmekogumi dokumentatsioonis mainitud, sisaldab iga klass 5000 pilti. Andmete kuju saate printida 1024 veeruga 5000 pildi kinnitamiseks, nagu on näidatud allpool TensorFlow Autoencoderi näites.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
5. samm. Ehitage pildi visualiseerija
Lõpuks koostate funktsiooni piltide joonistamiseks. Seda funktsiooni vajate rekonstrueeritud pildi printimiseks autokooderist.
Lihtne viis piltide printimiseks on kasutada matplotlibi teegist pärit objekti imshow. Pange tähele, et peate andmete kuju teisendama väärtusest 1024 väärtuseks 32 * 32 (st pildi formaat).
# 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")
Funktsioonil on 3 argumenti:
- Pilt: sisend
- Kuju: loend, pildi mõõde
- Cmap: valige värvikaart. Vaikimisi hall
Võite proovida joonistada andmekogumi esimese pildi. Peaksite nägema meest hobusel.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Määra andmekogumi prognoosija
Olgu, nüüd, kui andmekogum on kasutamiseks valmis, võite hakata kasutama Tensorflow'i. Enne mudeli koostamist kasutame võrgu toitmiseks Tensorflow andmekogumi hinnangut.
Ehitate andmekogumi koos TensorFlow hinnanguga. Meele värskendamiseks peate kasutama järgmist.
- from_tensor_slices
- kordama
- partii
Andmekogumi loomise täielik kood on:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Pange tähele, et x on järgmise kujuga kohatäide:
- [Puudub, n_sisendid]: määrake olekuks Puudub, kuna võrku olevate piltide arv võrdub partii suurusega.
üksikasjade saamiseks vaadake palun lineaarse regressiooni õpetust.
Pärast seda peate looma iteraatori. Ilma selle koodireata ei lähe torujuhtme kaudu andmeid.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Nüüd, kui torujuhe on valmis, saate kontrollida, kas esimene pilt on sama mis varem (st mees hobusel).
Määrasite partii suuruseks 1, kuna soovite andmekogumit edastada ainult ühe pildiga. Andmete mõõtmeid näete printimisega (sess.run (features) .shape). See on võrdne (1, 1024). 1 tähendab, et kumbki on voogesitatud ainult üks pilt, mille 1024 Kui partii suurus on seatud kahele, siis läbib torujuhtme kaks pilti. (Ärge muutke partii suurust. Vastasel juhul põhjustab see tõrke. Funktsioonile plot_image () saab minna ainult üks pilt korraga.
## 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)
Ehitage võrk
On aeg võrgu ülesehitada. Koolitate virnastatud automaatkooderit, see tähendab mitme varjatud kihiga võrku.
Teie võrgus on üks sisendkiht 1024 punktiga, st 32x32, pildi kuju.
Kodeerijaplokil on üks peidetud ülemine kiht 300 neuroniga, keskne kiht 150 neuroniga. Dekoodriplokk on kodeerijale sümmeetriline. Võrgustiku saate visualiseerida alloleval pildil. Pange tähele, et saate muuta varjatud ja keskmiste kihtide väärtusi.
Autoencoderi võrgu loomine
Autokooderi ehitamine on väga sarnane mis tahes muu süvaõppemudeliga.
Mudeli koostate järgmiselt:
- Määratlege parameetrid
- Määrake kihid
- Määrake arhitektuur
- Määrake optimeerimine
- Käivitage mudel
- Hinnake mudelit
Eelmises jaotises õppisite, kuidas luua gaasijuhet mudeli söötmiseks, nii et pole vaja andmekogumit veel kord luua. Ehitate nelja kihiga autokoodri. Kasutate Xavieri initsialiseerimist. See on tehnika, millega algkaalud määratakse võrdseks nii sisendi kui ka väljundi dispersiooniga. Lõpuks kasutate elu aktiveerimise funktsiooni. Reguleerite kadumisfunktsiooni L2 regulaatoriga.
1. samm. Määratlege parameetrid
Esimene samm tähendab neuronite arvu määratlemist igas kihis, õppimiskiirust ja korrigeerija hüperparameetrit.
Enne seda impordite funktsiooni osaliselt. Tihedate kihtide parameetrite määratlemiseks on parem meetod. Allolev kood määratleb autokooderi arhitektuuri väärtused. Nagu eespool loetletud, on autokooderil kaks kihti, esimeses kihis on 300 ja teises kihis 150 neuronit. Nende väärtused salvestatakse n_hidden_1 ja n_hidden_2.
Peate määratlema õppimise määra ja L2 hüperparameetri. Väärtused salvestatakse kataloogidesse 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
Xavieri initsialiseerimistehnikat kutsutakse objekti xavier_initializer abil hinnangu andja panusest. Samas prognoosijas saate regulaatori lisada l2_ regularizeriga
## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
2. samm. Määrake kihid
Kõik tihedate kihtide parameetrid on seatud; saate pakendada muutuja dense_layer kõik, kasutades objekti osalist. dense_layer, mis kasutab ELU aktiveerimist, Xavieri initsialiseerimist ja L2 seadistamist.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
3. samm. Määratlege arhitektuur
Arhitektuuri pilti vaadates märkisite, et võrk virnastab kolm kihti väljundkihiga. Allolevas koodis ühendate sobivad kihid. Näiteks arvutab esimene kiht punkttoote sisendmaatriksitunnuste ja 300 kaalu sisaldavate maatriksite vahel. Pärast punkttoote arvutamist läheb väljund Elu aktiveerimisfunktsioonile. Väljundist saab järgmise kihi sisend, seetõttu kasutate seda peidetud_2 ja nii edasi arvutamiseks. Maatriksite korrutamine on iga kihi jaoks sama, kuna kasutate sama aktiveerimisfunktsiooni. Pange tähele, et viimane kiht, väljundid, ei rakenda aktiveerimisfunktsiooni. See on mõttekas, sest see on rekonstrueeritud sisend
## 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)
4. samm. Määrake optimeerimine
Viimane samm on optimeerija koostamine. Kaotuse funktsioonina kasutate keskmist ruutviga. Kui meenutate lineaarse regressiooni õpetust, teate, et MSE arvutatakse prognoositava väljundi ja tegeliku sildi erinevusega. Siin on silt silt, kuna mudel üritab sisendit rekonstrueerida. Seetõttu soovite prognoositava väljundi ja sisendi ruutu erinevuse summa keskmist. TensorFlow abil saate kaotuse funktsiooni kodeerida järgmiselt:
loss = tf.reduce_mean(tf.square(outputs - features))
Seejärel peate optimeerima kaotuse funktsiooni. Gradientide arvutamiseks kasutate Adami optimeerijat. Eesmärgiks on kaotuse minimeerimine.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Enne mudeli treenimist veel üks seade. Soovite kasutada partii suurust 150, st toita torujuhet 150 kordusega 150 pilti. Te peate iteratsioonide arvu käsitsi arvutama. See on tühine teha:
Kui soovite iga kord edastada 150 pilti ja teate, et andmekogumis on 5000 pilti, on korduste arv võrdne. Pythonis saate käivitada järgmised koodid ja veenduda, et väljund on 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
5. samm. Käivitage mudel
Viimasena, kuid mitte vähem tähtsana, treenige mudelit. Koolitate 100 epohhiga mudelit. See tähendab, et mudel näeb pilte 100 korda optimeeritud kaaluni.
Tensorflowis mudeli koolitamise koodid on teile juba tuttavad. Väike erinevus seisneb andmete edastamises enne koolituse läbimist. Nii treenib mudel kiiremini.
Olete huvitatud kaotuse printimisest pärast kümmet ajastut, et näha, kas mudel midagi õpib (st kadu väheneb). Koolitus võtab 2 kuni 5 minutit, olenevalt teie masina riistvarast.
## 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
Samm 6) Hinnake mudelit
Nüüd, kui olete oma mudeli koolitanud, on aeg seda hinnata. Peate testiserdi importima failist / 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'])
MÄRKUS. Windowsi masina puhul saab kood test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")
Võite proovida printida pilte 13, mis on hobune
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
Mudeli hindamiseks kasutate selle pildi piksliväärtust ja vaadake, kas kodeerija suudab pärast 1024 piksli kahanemist sama pilti rekonstrueerida. Pange tähele, et määrate funktsiooni mudeli hindamiseks erinevatel piltidel. Mudel peaks paremini töötama ainult hobustel.
Funktsioonil on kaks argumenti:
- df: testiandmete importimine
- pildi_number: märkige, milline pilt imporditakse
Funktsioon on jagatud kolmeks osaks:
- Kujundage pilt õigesse mõõtmesse, st 1, 1024
- Söödake mudel nähtamatu pildiga, kodeerige / dekodeerige pilt
- Prindi tegelik ja rekonstrueeritud pilt
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üüd, kui hindamisfunktsioon on määratletud, saate vaadata rekonstrueeritud pildi numbrit kolmteist
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Kokkuvõte
Autokoodri peamine eesmärk on sisendandmete kokkusurumine ja seejärel tihendamine algväljunditega sarnanevaks väljundiks.
Autokooderi arhitektuur, mis on sümmeetriline pöördekihiga, mille nimi on keskne kiht.
Autokoodri saate luua järgmiselt:
- Osaline: tihedate kihtide loomiseks tüüpilise seadistusega:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- tihe_kiht (): maatriksi korrutamiseks
kaotuse funktsiooni ja optimeerimise saate määratleda järgmiselt:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Viimasena käivitage seanss mudeli koolitamiseks.