TensorFlow Autoencoder: datu kopa ar padziļinātu mācību piemēru

Kas ir automātiskais kodētājs?

Autoencoder ir instruments, lai mācītos datu kodēšanas efektīvi kādā nekontrolētā veidā. Tas ir mākslīgā neironu tīkla veids, kas palīdz iemācīties attēlot datu kopas dimensiju samazināšanai, apmācot neironu tīklu ignorēt signāla troksni. Tas ir lielisks līdzeklis, lai atjaunotu ievadi.

Vienkāršiem vārdiem sakot, mašīna uzņem, teiksim, attēlu, un tā var radīt cieši saistītu attēlu. Ievads šāda veida neironu tīklā nav apzīmēts, tas nozīmē, ka tīkls spēj mācīties bez uzraudzības. Precīzāk, ievade tiek kodēta tīklā, lai koncentrētos tikai uz vissvarīgāko funkciju. Tas ir viens no iemesliem, kāpēc auto kodētājs ir populārs izmēru samazināšanai. Bez tam, automātiskos kodētājus var izmantot, lai izveidotu ģeneratīvus mācību modeļus . Piemēram, neironu tīklu var apmācīt ar seju kopumu un pēc tam radīt jaunas sejas.

Šajā TensorFlow Autoencoder apmācībā jūs uzzināsiet:

• Kas ir automātiskais kodētājs?
• Kā darbojas Autoencoder?
• Stacked Autoencoder piemērs
• Izveidojiet Autoencoder ar TensorFlow
• Attēlu pirmapstrāde
• Iestatiet datu kopas aprēķinātāju
• Veidojiet tīklu

Kā darbojas Autoencoder?

Automātiskā kodētāja mērķis ir iegūt aptuvenu ievadi, koncentrējoties tikai uz galvenajām iezīmēm. Jūs domājat, kāpēc ne tikai iemācīties kopēt un ielīmēt ievadi, lai izveidotu izvadi. Faktiski autokoders ir ierobežojumu kopums, kas liek tīklam apgūt jaunus datu atspoguļošanas veidus, kas atšķiras no produkcijas kopēšanas.

Tipisks automātiskais kodētājs tiek definēts ar ieeju, iekšējo attēlojumu un izeju (ievades aptuvenību). Mācīšanās notiek slāņos, kas pievienoti iekšējai reprezentācijai. Faktiski ir divi galvenie slāņu bloki, kas izskatās kā tradicionāls neironu tīkls. Neliela atšķirība ir tā, ka slānim, kurā ir izeja, jābūt vienādam ar ievadi. Zemāk redzamajā attēlā sākotnējā ievade nonāk pirmajā blokā, ko sauc par kodētāju . Šis iekšējais attēlojums saspiež (samazina) ievades lielumu. Otrajā blokā notiek ieejas rekonstrukcija. Šis ir dekodēšanas posms.

Autoencoder darbība

Modelis atjauninās svarus, samazinot zaudējumu funkciju. Modelis tiek sodīts, ja rekonstrukcijas rezultāts atšķiras no ievadītā.

Konkrēti iedomājieties attēlu ar izmēru 50x50 (ti, 250 pikseļi) un neironu tīklu ar tikai vienu slēptu slāni, kas sastāv no simts neironiem. Mācīšanās notiek uz objektu kartes, kas ir divas reizes mazāka par ievadīto. Tas nozīmē, ka tīklam jāatrod veids, kā rekonstruēt 250 pikseļus tikai ar neironu vektoru, kas ir vienāds ar 100.

Stacked Autoencoder piemērs

Šajā Autoencoder apmācībā jūs uzzināsiet, kā izmantot sakrautu autoencoder. Arhitektūra ir līdzīga tradicionālajam neironu tīklam. Ievads nonāk slēptajā slānī, lai to saspiestu vai samazinātu tā lielumu, un pēc tam sasniedz rekonstrukcijas slāņus. Mērķis ir radīt izejas attēlu tikpat tuvu kā oriģinālam. Modelim ir jāapgūst veids, kā sasniegt savu uzdevumu saskaņā ar ierobežojumu kopumu, tas ir, ar zemāku dimensiju.

Mūsdienās Deep Learning automātiskie kodētāji galvenokārt tiek izmantoti attēla denoisešanai. Iedomājieties attēlu ar skrāpējumiem; cilvēks joprojām spēj atpazīt saturu. Automātiskā kodētāja atdalīšanas ideja ir pievienot attēlam troksni, lai piespiestu tīklu iemācīties datu pamatā esošo modeli.

Otra noderīgā Autoencoder Deep Learning saime ir variācijas autoencoder. Šāda veida tīkls var ģenerēt jaunus attēlus. Iedomājieties, ka jūs apmācāt tīklu ar vīrieša tēlu; šāds tīkls var radīt jaunas sejas.

Izveidojiet Autoencoder ar TensorFlow

Šajā apmācībā jūs uzzināsiet, kā izveidot sakrautu autokoderu, lai rekonstruētu attēlu.

Jūs izmantosiet CIFAR-10 datu kopu, kas satur 60000 32x32 krāsu attēlus. Autoencoder datu kopa jau ir sadalīta starp 50000 attēliem apmācībai un 10000 testēšanai. Ir līdz desmit klasēm:

• Lidmašīna
• Automašīna
• Putns
• Kaķis
• Brieži
• Suns
• Varde
• Zirgs
• Kuģis
• Smagā mašīna

Jums ir jāielādē attēli šajā vietrāžā https://www.cs.toronto.edu/~kriz/cifar.html un jāatsprauž. Mapē for-10-batches-py ir piecas datu partijas ar 10000 attēliem katrā nejaušā secībā.

Pirms veidojat un apmācāt savu modeli, jums jāpielieto daži datu apstrādes veidi. Jūs rīkosieties šādi:

1. Importējiet datus
2. Konvertējiet datus melnbaltā formātā
3. Pievienojiet visas partijas
4. Kontrolējiet apmācības datu kopu
5. Kontrolējiet attēlu vizualizatoru

Attēlu pirmapstrāde

1. darbība. Importējiet datus.

Saskaņā ar oficiālo vietni, jūs varat augšupielādēt datus ar šādu kodu. Autoencoder kods ielādēs datus vārdnīcā ar datiem un etiķeti . Ņemiet vērā, ka kods ir funkcija.

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. solis. Konvertējiet datus melnbaltā formātā

Vienkāršības labad datus konvertēsit pelēktoņos. Tas nozīmē, ka krāsu attēlam ir tikai viena dimensija pret trim. Lielākā daļa neironu tīkla darbojas tikai ar vienu dimensijas ievadi.

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

3. solis. Pievienojiet visas partijas

Tagad, kad abas funkcijas ir izveidotas un datu kopa ir ielādēta, varat ierakstīt cilpu, lai pievienotu datus atmiņā. Rūpīgi pārbaudot, izpakotā faila ar datiem nosaukums ir data_batch_ ar numuru no 1 līdz 5. Jūs varat pārslēgt failus un pievienot tiem datus.

Kad šī darbība ir pabeigta, jūs pārvēršat krāsu datus pelēkā mēroga formātā. Kā redzat, datu forma ir 50000 un 1024. Tagad 32 * 32 pikseļi ir saplacināti līdz 2014. gadam.

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

Piezīme. Mainiet './cifar-10-batches-py/data_batch_' uz faktisko faila atrašanās vietu. Piemēram, Windows mašīnai ceļš varētu būt faila nosaukums = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)

4. solis. Kontrolējiet apmācības datu kopu

Lai apmācību padarītu ātrāku un vieglāku, jūs apmācīsit modeli tikai uz zirga attēliem. Zirgi etiķetes datos ir septītā klase. Kā minēts CIFAR-10 datu kopas dokumentācijā, katrā klasē ir 5000 attēlu. Varat izdrukāt datu formu, lai apstiprinātu, ka ir 5000 attēlu ar 1024 kolonnām, kā parādīts zemāk esošajā TensorFlow Autoencoder piemērā.

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

5. solis) Kontrolējiet attēlu vizualizatoru

Visbeidzot, jūs izveidojat funkciju, lai attēlotu attēlus. Šī funkcija būs nepieciešama, lai izdrukātu rekonstruēto attēlu no automātiskā kodētāja.

Vienkāršs attēlu drukāšanas veids ir objekta imshow izmantošana no matplotlib bibliotēkas. Ņemiet vērā, ka datu forma jāpārvērš no 1024 uz 32 * 32 (ti, attēla formāts).

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

Funkcijai nepieciešami 3 argumenti:

• Attēls: ievade
• Forma: saraksts, attēla izmērs
• Karte: izvēlieties krāsu karti. Pēc noklusējuma pelēks

Varat mēģināt uzzīmēt pirmo datu kopas attēlu. Jums vajadzētu redzēt vīrieti uz zirga.

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

Iestatiet datu kopas aprēķinātāju

Labi, tagad, kad datu kopa ir gatava lietošanai, jūs varat sākt izmantot Tensorflow. Pirms modeļa izveidošanas izmantosim Tensorflow datu kopas novērtētāju, lai barotu tīklu.

Jūs izveidosiet datu kopu ar TensorFlow aprēķinātāju. Lai atsvaidzinātu prātu, jums jāizmanto:

• from_tensor_slices
• atkārtot
• partija

Pilns datu kopas izveides kods ir:

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

Ņemiet vērā, ka x ir vietturis ar šādu formu:

• [None, n_inputs]: iestatiet uz None, jo attēlu plūsmas tīklā skaits ir vienāds ar pakešu lielumu.

Lai iegūtu sīkāku informāciju, lūdzu, skatiet lineārās regresijas apmācību.

Pēc tam jums jāizveido iterators. Bez šīs koda rindas dati netiks cauri cauruļvadam.

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

Tagad, kad cauruļvads ir gatavs, varat pārbaudīt, vai pirmais attēls ir tāds pats kā iepriekš (ti, cilvēks uz zirga).

Jūs iestatāt partijas lielumu uz 1, jo datu kopu vēlaties padot tikai ar vienu attēlu. Datu izmērus var redzēt, izmantojot print (sess.run (features) .shape). Tas ir vienāds ar (1, 1024). 1 nozīmē, ka katram plūsmai ir tikai viens attēls ar 1024. Ja partijas lielums ir iestatīts uz diviem, cauruļvadā iet divi attēli. (Nemainiet pakešu lielumu. Pretējā gadījumā tas radīs kļūdu. Uz funkciju plot_image () var pāriet tikai viens attēls.

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

Veidojiet tīklu

Ir pienācis laiks izveidot tīklu. Jūs apmācīsit sakrautu autokoderu, tas ir, tīklu ar vairākiem slēptiem slāņiem.

Jūsu tīklā būs viens ievades slānis ar 1024 punktiem, ti, 32x32, attēla forma.

Kodētāja blokam būs viens augšējais slēptais slānis ar 300 neironiem, centrālais slānis ar 150 neironiem. Dekodera bloks ir simetrisks kodētājam. Tālāk redzamajā attēlā varat vizualizēt tīklu. Ņemiet vērā, ka varat mainīt slēpto un centrālo slāņu vērtības.

Autoencoder tīkla izveide

Autokodera uzbūve ir ļoti līdzīga jebkuram citam dziļas mācīšanās modelim.

Jūs izveidosiet modeli, rīkojoties šādi:

1. Definējiet parametrus
2. Definējiet slāņus
3. Definējiet arhitektūru
4. Definējiet optimizāciju
5. Palaidiet modeli
6. Novērtējiet modeli

Iepriekšējā sadaļā jūs uzzinājāt, kā izveidot cauruļvadu modeļa padevei, tāpēc nav nepieciešams vēlreiz izveidot datu kopu. Jūs izveidosiet automātisko kodētāju ar četriem slāņiem. Jūs izmantojat Xavier inicializāciju. Šī ir metode, kā iestatīt sākotnējos svarus, kas vienādi ar ievades un izvades dispersiju. Visbeidzot, jūs izmantojat elu aktivācijas funkciju. Jūs regulējat zaudējumu funkciju ar L2 regulatoru.

1. solis. Definējiet parametrus

Pirmais solis nozīmē noteikt neironu skaitu katrā slānī, mācīšanās ātrumu un regulatora hiperparametru.

Pirms tam jūs daļēji importējat funkciju. Tā ir labāka metode, lai definētu blīvo slāņu parametrus. Zemāk esošais kods nosaka autokodētāja arhitektūras vērtības. Kā jau minēts iepriekš, auto kodētājam ir divi slāņi, pirmajos slāņos ir 300 neironi, bet otrajā - 150. To vērtības tiek saglabātas mapēs n_hidden_1 un n_hidden_2.

Jums jādefinē mācīšanās ātrums un L2 hiperparametrs. Vērtības tiek saglabātas mapēs learning_rate un 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 inicializācijas paņēmienu no objekta xavier_initializer izsauc no novērtētāja ieguldījuma. Tajā pašā aprēķinātājā jūs varat pievienot regulatoru ar l2_ regularizer

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

2. solis. Definējiet slāņus

Ir iestatīti visi blīvo slāņu parametri; jūs varat visu iesaiņot mainīgajā dense_layer, izmantojot objekta daļēju. dense_layer, kas izmanto ELU aktivizēšanu, Xavier inicializāciju un L2 legalizāciju.

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

3. solis. Definējiet arhitektūru

Aplūkojot arhitektūras attēlu, jūs atzīmējat, ka tīkls sakrauj trīs slāņus ar izvades slāni. Zemāk esošajā kodā jūs savienojat atbilstošos slāņus. Piemēram, pirmais slānis aprēķina punktu punktu starp ievades matricas pazīmēm un matricām, kas satur 300 svarus. Pēc punktprodukta aprēķināšanas izeja nonāk Elu aktivizācijas funkcijā. Izeja kļūst par nākamā slāņa ievadi, tāpēc jūs to izmantojat, lai aprēķinātu hidden_2 un tā tālāk. Matricu reizināšana katram slānim ir vienāda, jo jūs izmantojat to pašu aktivizācijas funkciju. Ņemiet vērā, ka pēdējā slānī, izvados, netiek lietota aktivizācijas funkcija. Tam ir jēga, jo tas ir rekonstruētais ievads

## 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. solis. Definējiet optimizāciju

Pēdējais solis ir optimizētāja izveidošana. Jūs izmantojat vidējā kvadrāta kļūdu kā zaudējumu funkciju. Ja atceraties lineārās regresijas apmācību, jūs zināt, ka MSE tiek aprēķināta ar starpību starp paredzēto rezultātu un reālo etiķeti. Šeit iezīme ir iezīme, jo modelis mēģina rekonstruēt ievadi. Tādēļ vēlaties iegūt kvadrāta starpības starp prognozētās izejas un ievades vidējo vērtību. Izmantojot TensorFlow, zaudējumu funkciju varat kodēt šādi:

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

Pēc tam jums jāoptimizē zaudējumu funkcija. Slīpumu aprēķināšanai jūs izmantojat Ādama optimizētāju. Mērķa funkcija ir samazināt zaudējumus.

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

Pirms modeļa apmācības vēl viens iestatījums. Jūs vēlaties izmantot partijas lielumu 150, tas ir, padot cauruļvadu ar 150 attēliem katrā atkārtojumā. Jums atkārtoti jāaprēķina atkārtojumu skaits. Tas ir mazsvarīgi darīt:

Ja vēlaties katru reizi nodot 150 attēlus un zināt, ka datu kopā ir 5000 attēlu, atkārtojumu skaits ir vienāds ar. Python jūs varat palaist šādus kodus un pārliecināties, vai izeja ir 33:

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

5. solis. Palaidiet modeli

Visbeidzot, apmāciet modeli. Jūs apmācāt modeli ar 100 laikmetiem. Tas ir, modelis simtkārt redzēs attēlus optimizētā svarā.

Jūs jau esat iepazinies ar kodiem, lai apmācītu modeli Tensorflow. Neliela atšķirība ir datu nosūtīšana pirms apmācības. Tādā veidā modelis trenējas ātrāk.

Jūs esat ieinteresēts izdrukāt zaudējumus pēc desmit laikmetiem, lai redzētu, vai modelis kaut ko mācās (ti, zaudējumi samazinās). Apmācība ilgst 2 līdz 5 minūtes, atkarībā no jūsu datortehnikas.

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

6. solis) Novērtējiet modeli

Tagad, kad esat apmācījis savu modeli, ir pienācis laiks to novērtēt. Jums jāimportē testa sert no faila / 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'])

PIEZĪME. Windows mašīnai kods kļūst test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch")

Jūs varat mēģināt izdrukāt attēlus 13, kas ir zirgs

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

Lai novērtētu modeli, jūs izmantosiet šī attēla pikseļu vērtību un redzēsit, vai kodētājs pēc 1024 pikseļu samazināšanas var rekonstruēt to pašu attēlu. Ņemiet vērā, ka jūs definējat funkciju, lai novērtētu modeli uz dažādiem attēliem. Modelim vajadzētu darboties labāk tikai ar zirgiem.

Funkcijai ir divi argumenti:

• df: importējiet testa datus
• image_number: norādiet importējamo attēlu

Funkcija ir sadalīta trīs daļās:

1. Pārveidojiet attēlu līdz pareizajai dimensijai, ti, 1, 1024
2. Padodiet modeli ar neredzētu attēlu, kodējiet / atšifrējiet attēlu
3. Izdrukājiet reālo un rekonstruēto attēlu

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

Tagad, kad novērtēšanas funkcija ir definēta, jūs varat apskatīt rekonstruēto attēla numuru trīspadsmit

reconstruct_image(df =test_x, image_number = 13) 

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

Kopsavilkums

Automātiskā kodētāja galvenais mērķis ir saspiest ievades datus un pēc tam tos saspiest izvadē, kas līdzinās sākotnējiem datiem.

Autoenkodētāja arhitektūra, kas ir simetriska ar pagrieziena slāni ar nosaukumu centrālais slānis.

Automātisko kodētāju var izveidot, izmantojot:

• Daļējs: lai izveidotu blīvus slāņus ar tipisku iestatījumu:

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

• dense_layer (): lai matricu reizinātu

zaudējumu funkciju un optimizāciju varat definēt ar:

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

Pēdējā laikā veiciet sesiju, lai apmācītu modeli.