Čo je Autoencoder?
Autoencoder je nástroj pre výučbu dát efektívne kódovanie v neriadené spôsobom. Je to typ umelej neurónovej siete, ktorá vám pomôže naučiť sa reprezentáciu súborov údajov na zníženie dimenzionality trénovaním neurónovej siete tak, aby ignorovala šum signálu. Je to vynikajúci nástroj na opätovné vytvorenie vstupu.
Jednoduchými slovami, stroj urobí, povedzme obrázok, a dokáže vytvoriť úzko súvisiaci obrázok. Vstup v tomto druhu neurónovej siete nie je označený, čo znamená, že sieť je schopná učiť sa bez dozoru. Presnejšie, vstup je kódovaný sieťou tak, aby sa sústredil iba na najdôležitejšie funkcie. To je jeden z dôvodov, prečo je autoencoder obľúbený pre znižovanie rozmerov. Okrem toho možno autokodéry použiť na výrobu generatívnych modelov výučby . Napríklad neurónová sieť môže byť trénovaná so sadou tvárí a potom môže vytvárať nové tváre.
V tomto výukovom programe TensorFlow Autoencoder sa dozviete:
- Čo je Autoencoder?
- Ako funguje Autoencoder?
- Skladaný príklad automatického kódovača
- Zostavte si automatický kódovač s TensorFlow
- Predbežné spracovanie obrazu
- Nastavte nástroj na odhadovanie množiny údajov
- Budujte sieť
Ako funguje Autoencoder?
Účelom automatického kódovača je vytvoriť aproximáciu vstupu zameraním iba na základné funkcie. Môžete si myslieť, prečo sa nielen naučiť, ako kopírovať a prilepiť vstup, aby sa vytvoril výstup. Autoencoder je v skutočnosti súbor obmedzení, ktoré nútia sieť učiť sa nové spôsoby reprezentácie údajov, odlišné od iba kopírovania výstupu.
Typický autoencoder je definovaný so vstupom, vnútornou reprezentáciou a výstupom (aproximácia vstupu). Učenie sa deje vo vrstvách pripojených k vnútornej reprezentácii. V skutočnosti existujú dva hlavné bloky vrstiev, ktoré vyzerajú ako tradičná neurónová sieť. Malý rozdiel je v tom, že vrstva obsahujúca výstup sa musí rovnať vstupu. Na obrázku nižšie pôjde pôvodný vstup do prvého bloku s názvom kodér . Toto interné znázornenie komprimuje (zmenšuje) veľkosť vstupu. V druhom bloku nastáva rekonštrukcia vstupu. Toto je fáza dekódovania.
Práca Autoencoderu
Model bude aktualizovať váhy tak, že minimalizuje stratovú funkciu. Model je penalizovaný, ak sa výstup rekonštrukcie líši od vstupu.
Konkrétne si predstavte obrázok s veľkosťou 50x50 (tj. 250 pixelov) a neurónovou sieťou s iba jednou skrytou vrstvou zloženou zo sto neurónov. Učenie sa vykonáva na mape funkcií, ktorá je dvakrát menšia ako vstup. To znamená, že sieť musí nájsť spôsob, ako rekonštruovať 250 pixelov iba s vektorom neurónov rovným 100.
Skladaný príklad automatického kódovača
V tomto návode pre automatický kódovač sa naučíte, ako používať automatický kódovač na sebe. Architektúra je podobná tradičnej neurónovej sieti. Vstup prechádza do skrytej vrstvy, aby ju bolo možné komprimovať, alebo zmenšiť jej veľkosť, a potom sa dostane do vrstiev rekonštrukcie. Cieľom je vytvoriť výstupný obraz čo najbližší originálu. Model sa musí naučiť spôsob, ako dosiahnuť svoju úlohu v rámci súboru obmedzení, to znamená s nižšou dimenziou.
V súčasnosti sa automatické kódovače v programe Deep Learning používajú hlavne na potlačenie obrazu. Predstavte si obrázok so škrabancami; človek je stále schopný rozpoznať obsah. Myšlienkou deaktivácie automatického kódovača je pridať do obrazu šum, ktorý prinúti sieť naučiť sa štruktúru dát.
Ďalšou užitočnou rodinou Autoencoder Deep Learning je variačný autoencoder. Tento typ siete môže generovať nové obrázky. Predstavte si, že trénujete sieť s obrazom muža; takáto sieť môže priniesť nové tváre.
Zostavte si automatický kódovač s TensorFlow
V tomto výučbe sa dozviete, ako vytvoriť skladaný automatický kódovač na rekonštrukciu obrázka.
Použijete dataset CIFAR-10, ktorý obsahuje 60000 farebných obrázkov 32 x 32. Dátový súbor Autoencoder je už rozdelený medzi 50 000 obrázkov na trénovanie a 10 000 na testovanie. Existuje až desať tried:
- Lietadlo
- Automobil
- Vták
- Kat
- Jeleň
- pes
- Žaba
- Kôň
- Loď
- Nákladné auto
Musíte si stiahnuť obrázky z tejto adresy URL https://www.cs.toronto.edu/~kriz/cifar.html a rozbaliť ich. Priečinok for-10-batches-py obsahuje päť dávok údajov s 10 000 obrázkami v náhodnom poradí.
Pred zostavením a školením modelu musíte použiť určité spracovanie údajov. Budete postupovať nasledovne:
- Importujte údaje
- Konvertujte údaje do čiernobieleho formátu
- Pripojte všetky dávky
- Vytvorte súbor údajov o školení
- Vytvorte si vizualizér obrázkov
Predbežné spracovanie obrazu
Krok 1) Importujte údaje.
Podľa oficiálnych webových stránok môžete údaje nahrať pomocou nasledujúceho kódu. Kód Autoencoderu načíta údaje do slovníka s údajmi a štítkom . Upozorňujeme, že kód je funkciou.
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
Krok 2) Konvertujte údaje do čiernobieleho formátu
Pre jednoduchosť prevediete údaje do odtieňov sivej. To znamená, že pre farebný obrázok je iba jedna dimenzia proti trom. Väčšina neurónových sietí funguje iba s jednorozmerným vstupom.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Krok 3) Pripojte všetky dávky
Teraz, keď sú vytvorené obe funkcie a načítaná množina údajov, môžete napísať slučku, aby ste mohli pridať údaje do pamäte. Ak to dôkladne skontrolujete, rozbalený súbor s údajmi má názov data_batch_ s číslom od 1 do 5. Súbory môžete prepnúť do slučiek a pripojiť k údajom.
Po dokončení tohto kroku prevediete údaje o farbách do formátu šedej stupnice. Ako vidíte, tvar údajov je 50000 a 1024. 32 * 32 pixelov je od roku 2014 vyrovnaných.
# 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)
Poznámka: Zmeňte súbor „./cifar-10-batches-py/data_batch_“ na skutočné umiestnenie vášho súboru. Napríklad pre stroj s Windows môže byť cesta názov súboru = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Krok 4) Vytvorte tréningovú množinu údajov
Aby bol výcvik rýchlejší a ľahší, budete trénovať model iba na obrázkoch koňa. Kone sú siedmou triedou v údajoch na štítku. Ako je uvedené v dokumentácii k súboru údajov CIFAR-10, každá trieda obsahuje 5 000 obrázkov. Tvar údajov môžete vytlačiť, aby ste sa ubezpečili, že existuje 5 000 obrázkov s 1024 stĺpcami, ako je uvedené v nasledujúcom príklade kroku s automatickým kódovačom TensorFlow.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Krok 5) Vytvorte vizualizér obrázkov
Nakoniec skonštruujete funkciu na vykreslenie obrázkov. Túto funkciu budete potrebovať na tlač rekonštruovaného obrázka z automatického kódovača.
Jednoduchým spôsobom, ako tlačiť obrázky, je použitie objektu imshow z knižnice matplotlib. Upozorňujeme, že je potrebné previesť tvar údajov z 1024 na 32 * 32 (tj. Formát obrázka).
# 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")
Funkcia má 3 argumenty:
- Obrázok: vstup
- Tvar: zoznam, rozmer obrázka
- Cmap: vyberte farebnú mapu. Štandardne šedá
Môžete sa pokúsiť vykresliť prvý obrázok v množine údajov. Mali by ste vidieť človeka na koni.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Nastavte nástroj na odhadovanie množiny údajov
V poriadku, teraz, keď je množina údajov pripravená na použitie, môžete začať používať Tensorflow. Pred zostavením modelu použijeme na napájanie siete odhadovač Tasorflow z datasetu.
Budete zostavovať množinu údajov s odhadom TensorFlow. Na osvieženie mysle musíte použiť:
- from_tensor_slices
- opakovať
- šarža
Celý kód na zostavenie množiny údajov je:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Všimnite si, že x je zástupný symbol s nasledujúcim tvarom:
- [None, n_inputs]: Nastavené na None, pretože počet podávania obrázkov do siete sa rovná veľkosti dávky.
Podrobnosti nájdete v príručke lineárnej regresie.
Potom musíte vytvoriť iterátor. Bez tohto riadku kódu nebudú potrubím prechádzať žiadne údaje.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Teraz, keď je potrubie pripravené, môžete skontrolovať, či je prvý obrázok rovnaký ako predtým (tj. Muž na koni).
Veľkosť dávky nastavíte na 1, pretože chcete datovú množinu kŕmiť iba jedným obrázkom. Rozmer dát môžete vidieť pomocou print (sess.run (features) .shape). Rovná sa (1, 1024). 1 znamená, že každý kanál je napájaný iba jedným obrázkom s číslom 1024. Ak je veľkosť dávky nastavená na dve, potom potrubím prejdú dva obrázky. (Nemeňte veľkosť dávky. V opačnom prípade to spôsobí chybu. K funkcii plot_image () môže prejsť iba jeden obrázok súčasne.
## 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)
Budujte sieť
Je čas vybudovať sieť. Budete trénovať naskladaný automatický kódovač, teda sieť s viacerými skrytými vrstvami.
Vaša sieť bude mať jednu vstupnú vrstvu s 1024 bodmi, teda s tvarom obrázka 32 x 32.
Blok kódovača bude mať jednu hornú skrytú vrstvu s 300 neurónmi, centrálnu vrstvu so 150 neurónmi. Dekódovací blok je symetrický s kódovacím zariadením. Sieť si môžete vizualizovať na obrázku nižšie. Upozorňujeme, že môžete zmeniť hodnoty skrytých a stredových vrstiev.
Budovanie siete pre Autoencoder
Budovanie autoencodera je veľmi podobné ako v prípade každého iného modelu hlbokého učenia.
Model zostavíte podľa týchto krokov:
- Definujte parametre
- Definujte vrstvy
- Definujte architektúru
- Definujte optimalizáciu
- Spustiť model
- Vyhodnoťte model
V predchádzajúcej časti ste sa naučili, ako vytvoriť kanál na vloženie modelu, takže už nie je potrebné vytvárať ďalšiu množinu údajov. Budete konštruovať autoencoder so štyrmi vrstvami. Používate inicializáciu Xavier. Toto je technika na nastavenie počiatočných váh rovnajúcich sa variancii vstupu a výstupu. Na záver použijete funkciu aktivácie elu. Funkciu straty regulujete regulátorom L2.
Krok 1) Definujte parametre
Prvý krok znamená definovať počet neurónov v každej vrstve, rýchlosť učenia a hyperparameter regulátora.
Pred tým funkciu čiastočne naimportujete. Je to lepšia metóda na definovanie parametrov hustých vrstiev. Nasledujúci kód definuje hodnoty architektúry automatického kódovača. Ako je uvedené vyššie, autoencoder má dve vrstvy, s 300 neurónmi v prvých vrstvách a 150 v druhých vrstvách. Ich hodnoty sú uložené v bodoch n_hidden_1 a n_hidden_2.
Musíte definovať rýchlosť učenia a hyperparameter L2. Hodnoty sú uložené v learning_rate a 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
Technika inicializácie Xavier sa volá s objektom xavier_initializer z príspevku odhadcu. V rovnakom odhade môžete pridať regulátor s l2_regularizer
## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)
Krok 2) Definujte vrstvy
Všetky parametre hustých vrstiev boli nastavené; môžete zabaliť všetko do premennej thick_layer pomocou objektu partial. thick_layer, ktorý používa aktiváciu ELU, inicializáciu Xavier a regularizáciu L2.
## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)
Krok 3) Definujte architektúru
Ak sa pozriete na obrázok architektúry, všimnete si, že sieť spája tri vrstvy s výstupnou vrstvou. V nižšie uvedenom kóde spojíte príslušné vrstvy. Prvá vrstva napríklad počíta bodový produkt medzi znakmi vstupnej matice a maticami obsahujúcimi 300 váh. Po vypočítaní produktu s bodkami prejde výstup do aktivačnej funkcie Elu. Výstup sa stane vstupom ďalšej vrstvy, preto ho použijete na výpočet skrytých_2 atď. Násobenie matíc je pre každú vrstvu rovnaké, pretože používate rovnakú aktivačnú funkciu. Upozorňujeme, že posledná vrstva, výstupy, neaktivuje aktivačnú funkciu. Má to zmysel, pretože toto je rekonštruovaný vstup
## 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)
Krok 4) Definujte optimalizáciu
Posledným krokom je konštrukcia optimalizátora. Strednú štvorcovú chybu použijete ako stratovú funkciu. Ak si spomeniete na tutoriál lineárnej regresie, viete, že MSE sa počíta s rozdielom medzi predpovedaným výstupom a skutočným štítkom. Tu je to vlastnosť štítok, pretože model sa pokúša rekonštruovať vstup. Preto chcete priemer súčtu rozdielu štvorca medzi predpokladaným výstupom a vstupom. S TensorFlow môžete kódovať stratovú funkciu nasledovne:
loss = tf.reduce_mean(tf.square(outputs - features))
Potom musíte optimalizovať stratovú funkciu. Na výpočet gradientov používate Adamov optimalizátor. Cieľom je minimalizovať straty.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Pred tréningom modelu ešte jedno nastavenie. Chcete použiť veľkosť dávky 150, to znamená, že do kanálu dodáte 150 obrázkov pri každej iterácii. Počet iterácií musíte vypočítať manuálne. Je to triviálne:
Ak chcete zakaždým odovzdať 150 obrázkov a viete, že v množine údajov je 5 000 obrázkov, počet iterácií sa rovná. V pythone môžete spustiť nasledujúce kódy a skontrolovať, či je výstup 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Krok 5) Spustite model
V neposlednom rade trénujte model. Model trénujete so 100 epochami. To znamená, že model uvidí stokrát viac obrázkov ako optimalizované váhy.
S kódmi na trénovanie modelu v Tensorflow ste už oboznámení. Mierny rozdiel spočíva v odoslaní údajov do dátového kanálu pred spustením školenia. Takto model trénuje rýchlejšie.
Zaujíma vás, ako vytlačiť stratu po desiatich epochách, aby ste zistili, či sa model niečo učí (tj. Strata klesá). Výcvik trvá 2 až 5 minút, v závislosti od hardvéru vášho stroja.
## 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
Krok 6) Vyhodnoťte model
Teraz, keď máte svoj model vyškolený, je čas ho vyhodnotiť. Musíte importovať testovaciu sert zo súboru / 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'])
POZNÁMKA: Pre zariadenie so systémom Windows sa kód stane test_data = unfickle (r "E: \ cifar-10-batches-py \ test_batch")
Môžete sa pokúsiť vytlačiť obrázky 13, čo je kôň
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
Na vyhodnotenie modelu použijete pixlovú hodnotu tohto obrázka a zistíte, či kódovač dokáže rekonštruovať rovnaký obrázok po zmenšení na 1024 pixelov. Nezabudnite, že definujete funkciu na vyhodnotenie modelu na rôznych obrázkoch. Model by mal fungovať lepšie iba na koňoch.
Funkcia má dva argumenty:
- df: Importuje údaje z testu
- image_number: uveďte, aký obrázok sa má importovať
Funkcia je rozdelená do troch častí:
- Zmeňte tvar obrázka na správny rozmer, tj. 1 1024
- Nakŕmte model neviditeľným obrázkom, kódujte / dekódujte obrázok
- Vytlačte si skutočný a zrekonštruovaný obrázok
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()
Keď je teraz definovaná vyhodnocovacia funkcia, môžete si pozrieť zrekonštruovaný obrázok číslo trinásť
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
Zhrnutie
Primárnym účelom automatického kódovača je komprimovať vstupné údaje a potom ich dekomprimovať na výstup, ktorý vyzerá veľmi podobne ako pôvodné údaje.
Architektúra autoencodera symetrického s otočnou vrstvou pomenovanou centrálna vrstva.
Automatický kódovač môžete vytvoriť pomocou:
- Čiastočné: vytvorenie hustých vrstiev s typickým nastavením:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- thick_layer (): aby sa násobenie matice stalo
môžete definovať stratovú funkciu a optimalizáciu pomocou:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Naposledy spustite reláciu na trénovanie modelu.