Co je Autoencoder?
Autoencoder je nástroj pro výuku dat efektivně kódování v neřízené způsobem. Jedná se o typ umělé neuronové sítě, která vám pomůže naučit se reprezentaci datových souborů pro snížení dimenzionality trénováním neuronové sítě tak, aby ignorovala šum signálu. Je to skvělý nástroj pro opětovné vytvoření vstupu.
Jednoduše řečeno, stroj pořídí, řekněme obrázek, a dokáže vytvořit úzce související obrázek. Vstup v tomto typu neuronové sítě je neoznačený, což znamená, že síť je schopná se učit bez dohledu. Přesněji řečeno, vstup je zakódován sítí, aby se soustředil pouze na nejkritičtější funkci. To je jeden z důvodů, proč je autoencoder oblíbený pro redukci rozměrů. Kromě toho lze automatické kodéry použít k výrobě generativních modelů učení . Neuronová síť může být například trénována sadou tváří a poté může vytvářet nové tváře.
V tomto výukovém programu TensorFlow Autoencoder se naučíte:
- Co je Autoencoder?
- Jak Autoencoder funguje?
- Skládaný příklad Autoencoderu
- Vytvořte Autoencoder s TensorFlow
- Předzpracování obrazu
- Nastavit odhad datové sady
- Budujte síť
Jak Autoencoder funguje?
Účelem autoencoderu je vytvořit aproximaci vstupu se zaměřením pouze na základní funkce. Možná si pomyslíte, proč se nejen naučíte kopírovat a vložit vstup, abyste vytvořili výstup. Autoencoder je ve skutečnosti sada omezení, která nutí síť naučit se nové způsoby reprezentace dat, odlišné od pouhého kopírování výstupu.
Typický autoencoder je definován vstupem, interní reprezentací a výstupem (aproximace vstupu). K učení dochází ve vrstvách připojených k vnitřní reprezentaci. Ve skutečnosti existují dva hlavní bloky vrstev, které vypadají jako tradiční neuronová síť. Mírný rozdíl spočívá v tom, že vrstva obsahující výstup se musí rovnat vstupu. Na následujícím obrázku půjde původní vstup do prvního bloku s názvem kodér . Tato interní reprezentace komprimuje (zmenšuje) velikost vstupu. Ve druhém bloku dochází k rekonstrukci vstupu. Toto je fáze dekódování.
Práce Autoencoderu
Model bude aktualizovat váhy minimalizací funkce ztráty. Model je penalizován, pokud se výstup rekonstrukce liší od vstupu.
Konkrétně si představte obrázek o velikosti 50x50 (tj. 250 pixelů) a neurální síť pouze s jednou skrytou vrstvou složenou ze sto neuronů. Učení se provádí na mapě prvků, která je dvakrát menší než vstup. To znamená, že síť musí najít způsob, jak rekonstruovat 250 pixelů pouze s vektorem neuronů rovným 100.
Skládaný příklad Autoencoderu
V tomto výukovém programu Autoencoder se naučíte, jak používat skládaný autoencoder. Architektura je podobná tradiční neuronové síti. Vstup přejde do skryté vrstvy, aby byla komprimována nebo zmenšena její velikost, a poté dosáhne vrstev rekonstrukce. Cílem je vytvořit výstupní obraz co nejblíže originálu. Model se musí naučit způsob, jak dosáhnout svého úkolu v rámci souboru omezení, tj. S nižší dimenzí.
V dnešní době se automatické kódovače v programu Deep Learning používají hlavně k potlačení obrazu. Představte si obrázek se škrábanci; člověk je stále schopen rozpoznat obsah. Myšlenkou deaktivace autoencoderu je přidání šumu do obrazu, který donutí síť naučit se vzor za daty.
Další užitečnou rodinou Autoencoder Deep Learning je variační autoencoder. Tento typ sítě může generovat nové obrázky. Představte si, že trénujete síť s obrazem muže; taková síť může přinést nové tváře.
Vytvořte Autoencoder s TensorFlow
V tomto kurzu se naučíte, jak vytvořit skládaný automatický kodér pro rekonstrukci obrázku.
Budete používat datovou sadu CIFAR-10, která obsahuje 60000 barevných obrázků 32 x 32. Datová sada Autoencoder je již rozdělena mezi 50 000 obrázků pro trénink a 10 000 pro testování. Existuje až deset tříd:
- Letoun
- Automobil
- Pták
- Kočka
- Jelen
- Pes
- Žába
- Kůň
- Loď
- Kamion
Musíte stáhnout obrázky na této adrese URL https://www.cs.toronto.edu/~kriz/cifar.html a rozbalit je. Složka for-10-batches-py obsahuje pět dávek dat, každý s 10 000 obrázky v náhodném pořadí.
Před sestavením a trénováním modelu musíte použít určité zpracování dat. Budete postupovat následovně:
- Importujte data
- Převeďte data do černobílého formátu
- Připojte všechny dávky
- Vytvořte datovou sadu školení
- Vytvořte vizualizátor obrázků
Předzpracování obrazu
Krok 1) Importujte data.
Podle oficiálních webových stránek můžete data nahrát pomocí následujícího kódu. Kód Autoencoderu načte data do slovníku s daty a štítkem . Všimněte si, že kód je funkce.
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) Převeďte data do černobílého formátu
Pro zjednodušení převedete data na stupně šedi. To znamená, že u barevného obrazu je pouze jedna dimenze proti třem. Většina neuronové sítě funguje pouze se vstupem jedné dimenze.
def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)
Krok 3) Připojte všechny dávky
Nyní, když jsou vytvořeny obě funkce a načtena datová sada, můžete napsat smyčku pro připojení dat do paměti. Pokud pečlivě zkontrolujete, rozbalený soubor s daty se jmenuje data_batch_ s číslem od 1 do 5. Soubory můžete smyčkovat a připojit k datům.
Po dokončení tohoto kroku převedete data barev do formátu šedé stupnice. Jak vidíte, tvar dat je 50000 a 1024. 32 * 32 pixelů je nyní sloučeno s rokem 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)
Poznámka: Změňte řetězec „./cifar-10-batches-py/data_batch_“ na skutečné umístění souboru. Například pro stroj s Windows může být cesta název souboru = 'E: \ cifar-10-batches-py \ data_batch_' + str (i)
Krok 4) Vytvořte datovou sadu školení
Aby byl trénink rychlejší a jednodušší, trénujete model pouze na obrázcích koně. Koně jsou sedmou třídou v údajích na štítku. Jak je uvedeno v dokumentaci datové sady CIFAR-10, každá třída obsahuje 5 000 obrázků. Můžete vytisknout tvar dat a potvrdit, že existuje 5 000 obrázků s 1024 sloupci, jak je ukázáno v následujícím příkladovém kroku TensorFlow Autoencoder.
horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)
Krok 5) Vytvořte vizualizér obrazu
Nakonec vytvoříte funkci pro vykreslení obrázků. Tuto funkci budete potřebovat k tisku rekonstruovaného obrazu z automatického kodéru.
Snadný způsob tisku obrázků je použití objektu imshow z knihovny matplotlib. Všimněte si, že musíte převést tvar dat z 1024 na 32 * 32 (tj. Formát obrázku).
# 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")
Funkce má 3 argumenty:
- Obrázek: vstup
- Tvar: seznam, rozměr obrázku
- Cmap: vyberte barevnou mapu. Ve výchozím nastavení šedá
Můžete se pokusit vykreslit první obrázek v datové sadě. Měli byste vidět muže na koni.
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
Nastavit odhad datové sady
Dobře, teď, když je datová sada připravena k použití, můžete začít používat Tensorflow. Před sestavením modelu použijeme k napájení sítě odhad datové sady Tensorflow.
Vytvoříte datovou sadu s odhadem TensorFlow. Chcete-li si osvěžit mysl, musíte použít:
- from_tensor_slices
- opakovat
- šarže
Celý kód pro sestavení datové sady je:
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
Všimněte si, že x je zástupný symbol s následujícím tvarem:
- [None, n_inputs]: Nastaveno na None, protože počet podávání obrazu do sítě se rovná velikosti dávky.
Podrobnosti najdete v kurzu lineární regrese.
Poté musíte vytvořit iterátor. Bez tohoto řádku kódu neprojdou potrubí žádná data.
iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()
Nyní, když je potrubí připraveno, můžete zkontrolovat, zda je první obrázek stejný jako dříve (tj. Muž na koni).
Nastavíte velikost dávky na 1, protože chcete datovou sadu krmit pouze jedním obrázkem. Rozměr dat můžete vidět pomocí print (sess.run (features) .shape). Rovná se (1, 1024). 1 znamená, že každý zdroj je pouze jeden obrázek s 1024. Pokud je velikost dávky nastavena na dvě, pak kanálem projdou dva obrázky. (Neměňte velikost dávky. Jinak to vyvolá chybu. K funkci plot_image () může přejít pouze jeden obrázek najednou.
## 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 síť
Je čas vybudovat síť. Budete trénovat skládaný autoencoder, to znamená síť s více skrytými vrstvami.
Vaše síť bude mít jednu vstupní vrstvu s 1024 body, tj. 32x32, ve tvaru obrazu.
Blok kodéru bude mít jednu horní skrytou vrstvu s 300 neurony, centrální vrstvu se 150 neurony. Blok dekodéru je symetrický s kodérem. Síť můžete vizualizovat na obrázku níže. Hodnoty skrytých a středních vrstev můžete změnit.
Budování sítě pro Autoencoder
Budování autoencoderu je velmi podobné jakémukoli jinému modelu hlubokého učení.
Model sestavíte podle těchto kroků:
- Definujte parametry
- Definujte vrstvy
- Definujte architekturu
- Definujte optimalizaci
- Spusťte model
- Vyhodnoťte model
V předchozí části jste se dozvěděli, jak vytvořit kanál pro krmení modelu, takže již není nutné znovu vytvářet datovou sadu. Budete konstruovat autoencoder se čtyřmi vrstvami. Používáte inicializaci Xavier. Toto je technika pro nastavení počátečních vah rovných rozptylu vstupu i výstupu. Nakonec použijete funkci aktivace elu. Funkci ztráty regulujete regulátorem L2.
Krok 1) Definujte parametry
První krok znamená definovat počet neuronů v každé vrstvě, rychlost učení a hyperparametr regulátoru.
Před tím funkci naimportujete částečně. Je to lepší způsob, jak definovat parametry hustých vrstev. Níže uvedený kód definuje hodnoty architektury autoencoderu. Jak je uvedeno výše, autoencoder má dvě vrstvy, s 300 neurony v první vrstvě a 150 v druhé vrstvě. Jejich hodnoty jsou uloženy v n_hidden_1 a n_hidden_2.
Musíte definovat rychlost učení a hyperparametr L2. Hodnoty jsou uloženy 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
Inicializační technika Xavier je volána s objektem xavier_initializer z odhadu contrib. Ve stejném odhadci můžete přidat regularizer pomocí 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šechny parametry hustých vrstev byly nastaveny; můžete vše zabalit do proměnné thick_layer pomocí částečného objektu. thick_layer, který používá aktivaci ELU, inicializaci Xavier a regularizaci 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 architekturu
Pokud se podíváte na obrázek architektury, všimnete si, že síť stohuje tři vrstvy s výstupní vrstvou. V níže uvedeném kódu připojíte příslušné vrstvy. Například první vrstva počítá bodový produkt mezi vstupními maticovými prvky a maticemi obsahujícími 300 vah. Poté, co je tečkovaný produkt vypočítán, výstup přejde do funkce aktivace Elu. Výstup se stane vstupem další vrstvy, proto jej používáte k výpočtu skrytých_2 atd. Násobení matic je pro každou vrstvu stejné, protože používáte stejnou aktivační funkci. Všimněte si, že poslední vrstva, výstupy, neaktivuje aktivační funkci. Dává to smysl, protože se jedná o rekonstruovaný 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 optimalizaci
Posledním krokem je konstrukce optimalizátoru. Jako funkci ztráty použijete střední kvadratickou chybu. Pokud si vzpomenete na tutoriál lineární regrese, víte, že MSE je počítán s rozdílem mezi predikovaným výstupem a skutečným štítkem. Zde je štítek funkcí, protože model se pokusí rekonstruovat vstup. Chcete tedy průměr součtu rozdílu čtverce mezi predikovaným výstupem a vstupem. S TensorFlow můžete kódovat funkci ztráty následovně:
loss = tf.reduce_mean(tf.square(outputs - features))
Poté musíte optimalizovat funkci ztráty. K výpočtu přechodů používáte Adamův optimalizátor. Cílem je minimalizovat ztrátu.
## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Ještě jedno nastavení před trénováním modelu. Chcete použít dávkovou velikost 150, to znamená, poslat kanál 150 obrázky každou iterací. Počet iterací musíte vypočítat ručně. Je to triviální:
Pokud chcete pokaždé předat 150 obrázků a víte, že v datové sadě je 5 000 obrázků, počet iterací se rovná. V pythonu můžete spustit následující kódy a ujistit se, že výstup je 33:
BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33
Krok 5) Spusťte model
V neposlední řadě model trénujte. Trénujete model se 100 epochami. To znamená, že model uvidí stokrát větší obrázky než optimalizované váhy.
S kódy pro trénování modelu v Tensorflow už jste obeznámeni. Mírný rozdíl spočívá v propojení dat před spuštěním školení. Tímto způsobem model trénuje rychleji.
Zajímáte se o tisk ztráty po deseti epochách, abyste zjistili, zda se model něco učí (tj. Ztráta klesá). Výcvik trvá 2 až 5 minut, v závislosti na hardwaru vašeho stroje.
## 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
Nyní, když máte svůj model vyškolený, je čas jej vyhodnotit. Musíte importovat testovací sert ze souboru / 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: U počítače se systémem Windows se kód stane test_data = unfickle (r "E: \ cifar-10-batches-py \ test_batch")
Můžete zkusit vytisknout obrázky 13, což je kůň
plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")
K vyhodnocení modelu použijete hodnotu pixelu tohoto obrázku a zjistíte, zda kodér dokáže po zmenšení 1024 pixelů rekonstruovat stejný obrázek. Všimněte si, že definujete funkci pro vyhodnocení modelu na různých obrázcích. Model by měl fungovat lépe pouze na koních.
Funkce má dva argumenty:
- df: Importujte data testu
- image_number: uveďte, jaký obrázek chcete importovat
Funkce je rozdělena do tří částí:
- Přetvarujte obrázek na správný rozměr, tj. 1 1024
- Nakrmte model neviditelným obrázkem, kódujte / dekódujte obrázek
- Vytiskněte skutečný a rekonstruovaný obraz
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()
Nyní, když je definována vyhodnocovací funkce, můžete se podívat na rekonstruovaný obraz číslo třináct
reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)
souhrn
Primárním účelem autoencoderu je komprimovat vstupní data a poté je dekomprimovat do výstupu, který vypadá velmi podobně jako původní data.
Architektura autoencoderu symetrického s otočnou vrstvou pojmenovanou centrální vrstva.
Autoencoder můžete vytvořit pomocí:
- Částečné: vytvoření hustých vrstev s typickým nastavením:
-
tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
- thick_layer (): aby se násobení matice
můžete definovat funkci ztráty a optimalizaci pomocí:
loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)
Poslední spuštění relace k trénování modelu.