TensorFlow Autoencoder: Adatkészlet mély tanulási példával

Tartalomjegyzék:

Anonim

Mi az az Autoencoder?

Az Autoencoder egy eszköz az adatkódolás hatékony, felügyelet nélküli megtanulásához. Ez egyfajta mesterséges neurális hálózat, amely segít megtanulni az adatsorok reprezentációját a dimenziócsökkentés érdekében azáltal, hogy az ideghálózatot megtanítja figyelmen kívül hagyni a jelzajt. Remek eszköz a bemenet újrateremtéséhez.

Egyszerű szavakkal: a gép mondjuk képet készít, és szorosan kapcsolódó képet képes létrehozni. Az ilyen neurális hálózat bemenete nincs feliratozva, vagyis a hálózat felügyelet nélkül képes tanulni. Pontosabban, a bemenetet a hálózat kódolja, hogy csak a legkritikusabb tulajdonságra összpontosítson. Ez az egyik oka annak, hogy az autoencoder népszerű a dimenzió csökkentésében. Ezenkívül az auto-kódolókkal generatív tanulási modellek készíthetők . Például az ideghálózat egy arckészlettel oktatható, majd új arcokat hozhat létre.

Ebben a TensorFlow Autoencoder oktatóanyagban megtudhatja:

  • Mi az az Autoencoder?
  • Hogyan működik az Autoencoder?
  • Halmozott Autoencoder példa
  • Készítsen Autoencodert a TensorFlow segítségével
  • Kép előfeldolgozása
  • Adatkészlet-becslő beállítása
  • Kiépíteni a hálózatot

Hogyan működik az Autoencoder?

Az autoencoder célja, hogy csak a lényeges jellemzőkre összpontosítva hozza létre a bemenet közelítését. Gondolhatja, miért nem pusztán megtanulja, hogyan kell bemásolni és beilleszteni a bemenetet a kimenet előállításához. Valójában az autoencoder olyan korlátok összessége, amelyek arra kényszerítik a hálózatot, hogy megtanulja az adatok megjelenítésének új módjait, a puszta kimenet másolásától eltérően.

A tipikus autokódolót bemenettel, belső ábrázolással és kimenettel (a bemenet közelítésével) határozzák meg. A tanulás a belső reprezentációhoz kapcsolódó rétegekben történik. Valójában két fő rétegblokk van, amely úgy néz ki, mint egy hagyományos neurális hálózat. Az enyhe különbség az, hogy a kimenetet tartalmazó rétegnek meg kell egyeznie a bemenettel. Az alábbi képen az eredeti bemenet az első kódolónak nevezett blokkba kerül . Ez a belső ábrázolás tömöríti (csökkenti) a bemenet méretét. A második blokkban a bemenet rekonstrukciója következik be. Ez a dekódolási szakasz.

Az Autoencoder működése

A modell a veszteségfüggvény minimalizálásával frissíti a súlyokat. A modell büntetést kap, ha a rekonstrukció kimenete eltér a bemenettől.

Konkrétan képzeljünk el egy képet, amelynek mérete 50x50 (azaz 250 képpont), és egy neurális hálózatot, amely csak egy rejtett, száz neuronból álló réteget tartalmaz. A tanulás egy jellemző térképen történik, amely kétszer kisebb, mint a bemenet. Ez azt jelenti, hogy a hálózatnak meg kell találnia a módját 250 pixel rekonstrukciójára, csak 100 neuronvektorral.

Halmozott Autoencoder példa

Ebben az Autoencoder oktatóanyagban megtanulhatja, hogyan kell használni a halmozott AutoCoder-t. Az architektúra hasonló a hagyományos neurális hálózathoz. A bemenet egy rejtett réteghez kerül tömörítés vagy annak méretének csökkentése érdekében, majd eléri a rekonstrukciós rétegeket. A cél az eredetihez közel olyan kimeneti kép készítése, mint az eredeti. A modellnek meg kell tanulnia a feladat teljesítésének módját korlátok alatt, vagyis alacsonyabb dimenzióval.

Manapság a mély tanulás automatikus kódolóit főleg a kép denoise-ására használják. Képzeljen el egy képet karcolásokkal; az ember még mindig képes felismerni a tartalmat. Az automatikus kódoló eltávolításának az az ötlete, hogy zajt adjon a képhez, hogy a hálózatot arra kényszerítse, hogy megtanulja az adatok mögött álló mintát.

Az Autoencoder Deep Learning másik hasznos családja a variációs autoencoder. Ez a típusú hálózat új képeket generálhat. Képzelje el, hogy férfi képével hálózatot képez; egy ilyen hálózat új arcokat produkálhat.

Készítsen Autoencodert a TensorFlow segítségével

Ebben az oktatóanyagban megtanulhatja, hogyan kell egy halmozott autoencodert felépíteni egy kép rekonstrukciójára.

Használja a CIFAR-10 adatkészletet, amely 60000 32x32 színes képet tartalmaz. Az Autoencoder adatkészlet már 50000 kép között van felosztva a képzéshez és 10000 kép a teszteléshez. Legfeljebb tíz osztály létezik:

  • Repülőgép
  • Autó
  • Madár
  • Macska
  • Szarvas
  • Kutya
  • Béka
  • Ló
  • Hajó
  • Kamion

Töltse le a képeket erről az URL-ről: https://www.cs.toronto.edu/~kriz/cifar.html, és csomagolja ki. A-10-batches-py mappa öt adatsort tartalmaz, 10000 képpel, véletlenszerű sorrendben.

Mielőtt elkészítené és betanítaná a modelljét, alkalmaznia kell néhány adatfeldolgozást. Az alábbiak szerint jár el:

  1. Importálja az adatokat
  2. Konvertálja az adatokat fekete-fehér formátumba
  3. Csatolja az összes köteget
  4. Készítse el a képzési adatkészletet
  5. Készítsen képmegjelenítőt

Kép előfeldolgozása

1. lépés: Importálja az adatokat.

A hivatalos honlap szerint az adatokat a következő kóddal töltheti fel. Az Autoencoder kód egy szótárba tölti be az adatokat és a címkét . Vegye figyelembe, hogy a kód egy függvény.

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. lépés: Konvertálja az adatokat fekete-fehér formátumba

Az egyszerűség kedvéért az adatokat szürkeárnyalattá konvertálja. Vagyis csak egy dimenzióval, szemben a három színképpel. A neurális hálózat nagy része csak egy dimenzióbemenettel működik.

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

3. lépés: Csatolja az összes köteget

Most, hogy mindkét funkció létrejött és az adatkészlet betöltődött, írhat egy hurkot az adatok hozzáfűzéséhez a memóriába. Ha alaposan ellenőrzi, az adatokkal ellátott kibontott fájl neve data_batch_, 1-től 5-ig terjedő számmal. Áthúzhatja a fájlokat és hozzáfűzheti az adatokhoz.

Ha ez a lépés megtörtént, a színadatokat szürkeárnyalatos formátumúra konvertálja. Amint láthatja, az adatok alakja 50000 és 1024. A 32 * 32 képpont most 2014-re simul.

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

Megjegyzés: Módosítsa a "./cifar-10-batches-py/data_batch_" fájlt a fájl tényleges helyére. Például Windows gép esetén az elérési út fájlnév lehet: 'E: \ cifar-10-batches-py \ data_batch_' + str (i)

4. lépés) Konstruálja a képzési adatkészletet

Az edzés gyorsabbá és könnyebbé tétele érdekében csak a lovaképeken képez ki egy modellt. A lovak a hetedik osztály a címkézési adatokban. Amint azt a CIFAR-10 adatkészlet dokumentációjában említettük, minden osztály 5000 képet tartalmaz. Az adatok alakját kinyomtathatja, hogy ellenőrizze, hogy 5000 kép van-e 1024 oszloppal, amint az az alábbi TensorFlow Autoencoder példa lépésben látható.

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

5. lépés: Készítsen képmegjelenítőt

Végül elkészít egy függvényt a képek ábrázolásához. Erre a funkcióra lesz szüksége az újjáépített kép kinyomtatásához az automatikus kódolóból.

A képek nyomtatásának egyszerű módja az objektum imshow használata a matplotlib könyvtárból. Ne feledje, hogy az adatok alakját 1024-ről 32 * 32-re (azaz egy kép formátumára) kell konvertálni.

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

A függvény 3 argumentumot tartalmaz:

  • Kép: a bemenet
  • Alak: lista, a kép mérete
  • Cmap: válassza ki a színtérképet. Alapértelmezés szerint szürke

Megpróbálhatja megrajzolni az adatkészlet első képét. Látnod kéne egy embert egy lovon.

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

Adatkészlet-becslő beállítása

Rendben, most, hogy az adatkészlet használatra kész, elkezdheti használni a Tensorflow alkalmazást. A modell elkészítése előtt használjuk a Tensorflow adatkészlet-becslőjét a hálózat táplálására.

Felépít egy adatkészletet a TensorFlow becslővel. Az elméd felfrissítéséhez a következőket kell használnia:

  • from_tensor_slices
  • ismétlés
  • tétel

Az adatkészlet összeállításának teljes kódja:

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

Vegye figyelembe, hogy x a következő alakú helyőrző:

  • [Nincs, n_input]: Nincs értékre állítva, mert a hálózathoz tartozó képadatok száma megegyezik a kötegelt méretével.

A részletekért olvassa el a lineáris regresszióról szóló oktatóanyagot.

Ezt követően létre kell hoznia az iterátort. E kódsor nélkül egyetlen adat sem megy át a folyamaton.

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

Most, hogy a csővezeték készen áll, ellenőrizheti, hogy az első kép megegyezik-e az előző képpel (azaz egy ember lovon).

A kötegelt méretet 1-re állítja, mert csak egy képpel szeretné ellátni az adatkészletet. Az adatok dimenzióját a nyomtatással (sess.run (features) .shape) láthatja. Ez egyenlő (1, 1024). Az 1. azt jelenti, hogy csak egy 1024 képpel ellátott kép van ellátva. Ha a kötegméret kettőre van állítva, akkor két kép megy át a folyamaton. (Ne változtassa meg a kötegelt méretet. Ellenkező esetben hibát okoz. Egyszerre csak egy kép mehet a plot_image () függvénybe.

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

Kiépíteni a hálózatot

Itt az ideje a hálózat kiépítésének. Képezni fog egy halmozott autoencodert, vagyis egy hálózatot, amely több rejtett réteggel rendelkezik.

Hálózatának egyetlen bemeneti rétege lesz 1024 ponttal, azaz 32x32, a kép alakja.

A kódoló blokknak egy felső rejtett rétege lesz 300 neuronnal, egy központi rétege 150 neuronnal. A dekóder blokk szimmetrikus a kódolóval. Az alábbi képen megjelenítheti a hálózatot. Vegye figyelembe, hogy megváltoztathatja a rejtett és a központi rétegek értékeit.

A hálózat kiépítése az Autoencoder számára

Az autoencoder építése nagyon hasonlít bármely más mély tanulási modellhez.

A modellt a következő lépések szerint állítja össze:

  1. Határozza meg a paramétereket
  2. Határozza meg a rétegeket
  3. Határozza meg az architektúrát
  4. Határozza meg az optimalizálást
  5. Futtassa a modellt
  6. Értékelje a modellt

Az előző szakaszban megtanulta, hogyan kell létrehozni egy folyamatot a modell betáplálásához, így nem kell még egyszer létrehozni az adatkészletet. Négy rétegű autókódolót készít. Használja a Xavier inicializálását. Ez egy olyan technika, amellyel a kezdeti súlyokat meg lehet egyezni a bemenet és a kimenet varianciájával. Végül az elu aktiválási funkciót használja. Az veszteségfüggvényt az L2 szabályozóval szabályozza.

1. lépés: Határozza meg a paramétereket

Első lépésként meg kell határozni az egyes rétegekben található idegsejtek számát, a tanulási sebességet és a szabályozó hiperparaméterét.

Előtte részben importálja a függvényt. Jobb módszer a sűrű rétegek paramétereinek meghatározására. Az alábbi kód meghatározza az autoencoder architektúra értékeit. Az előzőekben felsoroltak szerint az autokódolónak két rétege van, az első rétegekben 300, a második rétegekben 150 neuron található. Értékeik az n_hidden_1 és az n_hidden_2 fájlokban vannak tárolva.

Meg kell határoznia a tanulási sebességet és az L2 hiperparamétert. Az értékeket a learning_rate és az l2_reg tárolja

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

A Xavier inicializálási technikát a becslő közreműködésével hívjuk meg az xavier_initializer objektummal. Ugyanebben a becslésben felveheti a szabályozót az l2_szabályozóval

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

2. lépés: Határozza meg a rétegeket

A sűrű rétegek összes paraméterét beállították; mindent bepakolhat a dense_layer változóba a részleges objektum használatával. dense_layer, amely az ELU aktiválását, a Xavier inicializálást és az L2 szabályozást használja.

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

3. lépés: Határozza meg az architektúrát

Ha megnézzük az architektúra képét, akkor megjegyezzük, hogy a hálózat három réteget rak egy kimeneti réteggel. Az alábbi kódban csatlakoztatja a megfelelő rétegeket. Például az első réteg kiszámítja a pontterméket a bemeneti mátrix jellemzői és a 300 súlyt tartalmazó mátrixok között. A ponttermék kiszámítása után a kimenet az Elu aktiválási funkcióba kerül. A kimenet a következő réteg bemenetévé válik, ezért használja a hidden_2 kiszámításához stb. A mátrixok szorzása minden rétegnél megegyezik, mert ugyanazt az aktiválási függvényt használja. Vegye figyelembe, hogy az utolsó réteg, az outputok nem alkalmaznak aktiválási funkciót. Ennek van értelme, mert ez a rekonstruált bemenet

## 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. lépés: Határozza meg az optimalizálást

Az utolsó lépés az optimalizáló elkészítése. A Mean Square Error veszteségfüggvényként használja. Ha felidézi a lineáris regresszióról szóló oktatóanyagot, akkor tudja, hogy az MSE a kiszámított kimenet és a valós címke különbségével kerül kiszámításra. Itt a címke a jellemző, mert a modell megpróbálja rekonstruálni a bemenetet. Ezért az előrejelzett kimenet és az input közötti négyzet különbségének átlagát akarja megadni. A TensorFlow segítségével a következőképpen kódolhatja a veszteségfüggvényt:

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

Ezután optimalizálnia kell a veszteség funkciót. Az Ádám optimalizáló segítségével kiszámítja a színátmeneteket. A cél a veszteség minimalizálása.

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

Még egy beállítás a modell edzése előtt. 150 kötegelt méretet szeretne használni, vagyis minden iterációban 150 képpel töltse fel a folyamatot. Manuálisan kell kiszámítania az iterációk számát. Ezt triviális megtenni:

Ha minden alkalommal 150 képet szeretne átadni, és tudja, hogy 5000 kép van az adatkészletben, akkor az iterációk száma megegyezik. A pythonban a következő kódokat futtathatja, és győződjön meg arról, hogy a kimenet 33:

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

5. lépés: Futtassa a modellt

Végül, de nem utolsósorban, képezze ki a modellt. 100 korszakkal képezed a modellt. Vagyis a modell a képek százszorosát fogja látni optimalizált súlyokig.

Már ismeri a modellek betanításának kódjait a Tensorflow-ban. Az enyhe különbség az adatok átküldése az edzés lefuttatása előtt. Ily módon a modell gyorsabban edz.

Érdekes, hogy tíz korszak után kinyomtatja a veszteséget, hogy lássa, a modell tanul-e valamit (azaz csökken a veszteség). A képzés a gép hardverétől függően 2–5 percet vesz igénybe.

## 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. lépés) Értékelje a modellt

Most, hogy kiképezted a modelledet, ideje értékelni. Importálnia kell a teszt szert a / cifar-10-batches-py / fájlból.

test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])

MEGJEGYZÉS: Windows gép esetén a kód test_data = unpickle lesz (r "E: \ cifar-10-batches-py \ test_batch")

Megpróbálhatja kinyomtatni a 13 képeket, ami egy ló

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

A modell kiértékeléséhez felhasználja ennek a képnek a pixelértékét, és megnézi, hogy a kódoló képes-e rekonstruálni ugyanazt a képet, miután 1024 képpontot csökkent. Ne feledje, hogy meghatároz egy funkciót a modell értékeléséhez különböző képeken. A modellnek csak lovakon kell jobban működnie.

A függvénynek két argumentuma van:

  • df: A tesztadatok importálása
  • image_number: adja meg, milyen képet importáljon

A funkció három részre oszlik:

  1. Alakítsa át a képet a megfelelő méretre, azaz 1, 1024
  2. Táplálja a modellt a láthatatlan képpel, kódolja / dekódolja a képet
  3. Nyomtassa ki a valós és rekonstruált képet
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()

Most, hogy az értékelési funkció definiálva van, megnézheti a rekonstruált tizenhárom képszámot

reconstruct_image(df =test_x, image_number = 13) 
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

Összegzés

Az autoencoder elsődleges célja a bemeneti adatok tömörítése, majd az eredeti adatokhoz hasonló kinézetű tömörítés.

Egy autoencoder architektúrája, amely szimmetrikus a központi rétegnek nevezett forgóréteggel.

Az autoencodert az alábbiak használatával hozhatja létre:

  • Részleges: a sűrű rétegek létrehozása a tipikus beállítással:
  • tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
  • dense_layer (): a mátrix szorzásához

meghatározhatja a veszteségfüggvényt és az optimalizálást:

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

Utoljára futtasson egy munkamenetet a modell kiképzéséhez.