Autoencoder a TensorFlow-ban példával

Mi az Autoencoder a Deep Learningben?

An Autoencoder egy eszköz az adatkódolás hatékony elsajátításához egy felügyelet nélkül módon. Ez egyfajta mesterséges idegi hálózat amely segít megtanulni az adathalmazok reprezentációját a dimenziócsökkentés érdekében azáltal, hogy a neurális hálózatot a jelzaj figyelmen kívül hagyására tanítja. Nagyszerű eszköz egy bemenet újraalkotásához.

Egyszerűen fogalmazva, a gép vesz, mondjuk, egy képet, és egy szorosan kapcsolódó képet tud előállítani. Az ilyen típusú neurális hálózat bemenete címkézetlen, ami azt jelenti, hogy a hálózat képes felügyelet nélkül tanulni. Pontosabban, a bemenetet a hálózat úgy kódolja, hogy csak a legfontosabb jellemzőre összpontosítson. Ez az egyik oka annak, hogy az autoenkóder népszerű a dimenziócsökkentés szempontjából. Emellett az autoenkóderek generatív tanulási modellek létrehozására is használhatók. Például a neurális hálózat betanítható egy sor felülettel, majd új felületeket hozhat létre.

Hogyan működik a TensorFlow Autoencoder?

Az autoencoder célja, hogy csak a lényeges jellemzőkre összpontosítva közelítse meg a bemenetet. Gondolhatja, miért nem tanulja meg egyszerűen a bemenet másolását és beillesztését a kimenet előállításához. Valójában az automatikus kódoló olyan megszorítások összessége, amelyek arra kényszerítik a hálózatot, hogy új módszereket tanuljon meg az adatok megjelenítésére, eltérve a kimenet puszta másolásától.

Egy tipikus autoenkóder egy bemenettel, egy belső reprezentációval és egy kimenettel (a bemenet közelítésével) van definiálva. A tanulás a belső reprezentációhoz kapcsolódó rétegekben történik. Valójában két fő rétegblokk van, amelyek egy hagyományos neurális hálózatra hasonlítanak. A kis különbség az, hogy a kimenetet tartalmazó rétegnek meg kell egyeznie a bemenettel. Az alábbi ábrán az eredeti bemenet az első blokkba, az úgynevezett kódolóba kerül. Ez a belső reprezentáció tömöríti (csökkenti) a bemenet méretét. A második blokkban történik a bemenet rekonstrukciója. Ez a dekódolási fázis.

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

Konkrétan képzeljünk el egy 50×50-es képet (azaz 2,500 pixelt), és egy olyan neurális hálózatot, amelynek csak egyetlen rejtett rétege van, és száz neuronból áll. A tanulás egy olyan jellemzőtérképen történik, amely huszonötször kisebb, mint a bemenet. Ez azt jelenti, hogy a hálózatnak meg kell találnia a módját 2,500 pixel rekonstruálására, mindössze egy 100 neuronból álló vektorral.

Halmozott automatikus kódoló példa

Ebben az Autoencoder oktatóanyagban megtanulod, hogyan kell használni egy rétegzett autoencodert. Az architektúra hasonló egy hagyományos neurális hálózathoz. A bemenet egy rejtett rétegre kerül tömörítés, vagyis a méretének csökkentése érdekében, majd eléri a rekonstrukciós rétegeket. A cél az eredetihez a lehető legközelebb álló kimeneti kép létrehozása. A modellnek meg kell tanulnia, hogyan érheti el a feladatát egy sor korlátozás mellett, azaz alacsonyabb dimenzióval.

Manapság a mélytanulásban használt autoenkódereket főként képek zajszűrésére használják. Képzeljünk el egy karcolásokat tartalmazó képet; egy ember továbbra is képes felismerni a tartalmat. Az autoenkóder zajszűrésének lényege, hogy zajt adjunk a képhez, és ezzel kényszerítsük a hálózatot az adatok mögött rejlő mintázat megtanulására.

Az Autoencoder másik hasznos családja Deep Learning variációs autoenkóder. Ez a fajta hálózat új képeket képes generálni. Képzeld el, hogy egy hálózatot egy férfi képével tanítasz be; egy ilyen hálózat új arcokat képes létrehozni.

Az alábbi táblázat az ebben az oktatóanyagban létrehozott egymásra helyezett autoenkódert a valószínűleg előforduló többi család mellé helyezi, így az egyes családok által hozzáadott korlátozások könnyen összehasonlíthatók.

Hogyan készítsünk automatikus kódolót a TensorFlow segítségével

Ebből az oktatóanyagból megtudhatja, hogyan kell felépíteni egy halmozott automatikus kódolót a kép rekonstruálásához.

A CIFAR-10 adatkészletet fogod használni, amely 60 000 darab 32×32 színes képet tartalmaz. Az Autoencoder adatkészlet már fel van osztva 50 000 képre a betanításhoz és 10 000 teszteléshez. Legfeljebb tíz osztály létezik:

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

Le kell töltened a képeket a következő helyről: CIFAR-10 adatkészlet oldal és csomagold ki az archívumot. A cifar-10-batches-py mappa öt, véletlenszerű sorrendben elrendezett, egyenként 10 000 képet tartalmazó adatcsomagot tartalmaz.

Mielőtt megépítené és betanítaná a modellt, bizonyos adatfeldolgozást kell alkalmaznia. A következőképpen jár el:

1. Importálja az adatokat
2. Konvertálja az adatokat fekete-fehér formátumba
3. Csatlakoztassa az összes tételt
4. Készítse el a képzési adatkészletet
5. Készítsen képvizualizálót

Verzió megjegyzés: Az ebben az oktatóanyagban található kód a TensorFlow 1.x-et célozza meg. A TensorFlow 2-ben a tf.contrib modul már nem létezik, a helyőrzők, munkamenetek és az inicializálható iterátor a tf.compat.v1 alatt található. A listázások változatlanul futtatásának leggyorsabb módja a tf.compat.v1.disable_v2_behavior() meghívása az importálás után.

Kép előfeldolgozása

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

A hivatalos weboldal szerint a következő kóddal töltheted fel az adatokat. Az Autoencoder kód egy szótárba tölti be az adatokat, beleértve az adatokat és a címkét is. Fontos megjegyezni, hogy a kód egy függvény.

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

2. lépés) Alakítsa át az adatokat fekete-fehér formátumba

Az egyszerűség kedvéért az adatokat szürkeárnyalatossá alakítja. Vagyis csak egy dimenzióval a három színnel szemben. A neurális hálózatok nagy része csak egydimenziós 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) Csatlakoztassa az összes köteget

Most, hogy mindkét függvény létrejött és az adathalmaz betöltődött, írhatsz egy ciklust az adatok memóriába fűzéséhez. Ha alaposan megnézed, a kicsomagolt, adatokat tartalmazó fájl neve data_batch_ lesz, és egy 1-től 5-ig terjedő számot kap. Végigjárhatod a fájlokat, és hozzáfűzheted az adatokat az adathalmazhoz.

Amikor ezzel a lépéssel elkészültél, a színes adatokat szürkeárnyalatos formátumba konvertálod. Amint láthatod, az adatok alakja 50000 és 1024. A 32*32 pixel most 1024-re lapított.

# Load the data into memory
data, labels = [], []
## Loop over the b
for 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)

Jegyzet: Módosítsa a './cifar-10-batches-py/data_batch_' részt a fájl tényleges helyére. Például egy Windows gépen, az elérési út a következő lehet: fájlnév = 'E:\cifar-10-batches-py\data_batch_' + str(i)

4. lépés) Készítse el a betanítási adatkészletet

A betanítás gyorsabbá és egyszerűbbé tétele érdekében a modellt csak a ló képein fogod betanítani. A lovak a címkeadatokban a 7-es címkét viselik. Amint a CIFAR-10 adatkészlet dokumentációjában is szerepel, minden osztály 5000 képet tartalmaz. Az adatok alakját kinyomtatva ellenőrizheted, hogy 5,000 kép van-e 1024 oszloppal, ahogy az az alábbi TensorFlow Autoencoder példalé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 összeállít egy függvényt a képek ábrázolásához. Erre a funkcióra szüksége lesz a rekonstruált kép automatikus kódolóból történő kinyomtatásához.

A képek nyomtatásának egy egyszerű módja a Matplotlib könyvtár imshow() függvényének használata. Fontos megjegyezni, 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 inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

A függvénynek 3 argumentuma van:

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

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

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

A hívás visszaadja az alábbi szürkeárnyalatos miniatűrt, és megerősíti, hogy az 1024 értékről 32×32-es képre való visszaalakítás helyes.

Állítsa be az Adatkészlet-becslőt

Rendben, most, hogy az adathalmaz használatra kész, elkezdheti használni a TensorFlow-t. A modell felépítése előtt használja a TensorFlow adathalmaz-becslőjét a hálózat betáplálásához.

A TensorFlow becslővel egy adatkészletet fog készíteni. Az elméd felfrissítéséhez a következőket kell használni:

• from_tensor_slices
• ismétlés
• batch

Az adatkészlet felépítéséhez szükséges teljes kód:

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

Megjegyzendő, hogy az x egy [None,n_inputs] alakú helykitöltő. Az első dimenzió értéke None, mivel a hálózatra betáplált képek száma megegyezik a köteg méretével, amelyet csak futási időben határoznak meg. Részletekért lásd a következő oktatóanyagot: lineáris regresszió TensorFlow-val.

Ezt követően létre kell hoznia az iterátort. E kódsor nélkül semmilyen adat nem 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 ugyanaz-e, mint korábban (azaz ember lovon).

A köteg méretét 1-re állítod, mert csak egy képpel szeretnéd betáplálni az adathalmazt. Az adatok dimenzióját a print(sess.run(features).shape) paranccsal láthatod. Ez egyenlő (1, 1024). Az 1 azt jelenti, hogy minden alkalommal egyetlen, 1024 értékű kép kerül betáplálásra. Ha a köteg mérete kettőre van állítva, akkor két kép fog végigmenni a folyamaton. Ne változtasd meg a köteg méretét, különben hibát kapsz, mert egyszerre csak egy kép kerülhet a plot_image() függvénybe.

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.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)

A folyamat ugyanazt a ridert adja vissza, amelyet közvetlenül a NumPy mátrixból ábrázoltak, ami bizonyítja, hogy a helyőrző, az iterátor és a köteg mérete helyesen van konfigurálva.

Építsd fel a hálózatot

Ideje kiépíteni a hálózatot. Egy halmozott autoencodert, azaz több rejtett rétegű hálózatot fog tanítani.

A hálózatodnak egy 1024 pontból álló bemeneti rétege lesz, azaz 32×32-es, ami a kép alakját jelenti.

A kódoló blokk egy felső rejtett réteggel rendelkezik 300 neuronnal, és egy központi réteggel 150 neuronnal. A dekódoló blokk szimmetrikus a kódolóra nézve. A hálózatot az alábbi ábrán szemléltetheted. Megjegyzendő, hogy a rejtett és a központi rétegek értékeit módosíthatod.

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

A modellt az alábbi lépések szerint készítheti el:

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 megtanultad, hogyan hozhatsz létre egy folyamatot a modell betáplálásához, így nem kell még egyszer létrehozni az adathalmazt. Egy négyrétegű autoenkódert fogsz létrehozni. A Xavier inicializálást fogod használni. Ez egy olyan technika, amellyel a kezdeti súlyokat a bemenet és a kimenet varianciája alapján állíthatod be. Végül az ELU aktivációs függvényt fogod használni. A veszteségfüggvényt egy L2 regularizátorral regularizálod.

1. lépés) A paraméterek meghatározása

Az első lépésben meg kell határozni a neuronok számát az egyes rétegekben, a tanulási sebességet és a regularizáló hiperparaméterét.

Előtte importálod a parciális függvényt. Ez egy jobb módszer a sűrű rétegek paramétereinek definiálására. Az alábbi kód az autoencoder architektúra értékeit definiálja. Ahogy korábban említettük, a kódolónak két rétege van, 300 neuronnal az első rétegben és 150-nel a második rétegben. Értékeik az n_hidden_1 és n_hidden_2 rétegekben tárolódnak.

Meg kell határoznod a tanulási rátát és az L2 hiperparamétert. Az értékek a learning_rate és az l2_reg paraméterekben tárolódnak.

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

A Xavier inicializálási technikát a contrib becslő xavier_initializer objektumával hívjuk meg. Ugyanebben a becslőben hozzáadhatjuk a regularizátort az l2_regularizer paraméterrel.

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Verzió megjegyzés: A tf.contrib fájlt eltávolították a TensorFlow 2-ben. A közvetlen helyettesítők a tf.keras.initializers.GlorotUniform() a xavier_initializer() helyett és a tf.keras.regularizers.l2() az l2_regularizer() helyett.

2. lépés) A rétegek meghatározása

A sűrű rétegek összes paramétere be van állítva; mindent a dense_layer változóba csomagolhatsz a partial objektum használatával. A dense_layer ezután minden híváskor az ELU aktivációt, a Xavier inicializálást és az L2 regularizációt használja.

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

3. lépés) Az architektúra meghatározása

Ha megnézzük az architektúra diagramját, láthatjuk, hogy a hálózat három réteget és egy kimeneti réteget halmoz fel. Az alábbi kódban összekapcsoljuk a megfelelő rétegeket. Például az első réteg kiszámítja a bemeneti mátrix jellemzői és a 300 súlyt tartalmazó mátrix közötti skaláris szorzatot. A skaláris szorzat kiszámítása után a kimenet az ELU aktivációs függvénybe kerül. A kimenet a következő réteg bemenetévé válik, ezért használjuk a hidden_2 kiszámításához és így tovább. A mátrixszorzás minden réteg esetében azonos, mert ugyanazt az aktivációs függvényt használjuk. Megjegyezzük, hogy az utolsó réteg, a kimenetek, nem alkalmaz aktivációs függvényt. Ez logikus, mert ez a rekonstruált bemenet.

## Make the mat mul
hidden_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) Optimalizálás definiálása

Az utolsó lépés az optimalizáló megalkotása. A négyzetes középértéket veszteségfüggvényként használjuk. Ha emlékszünk a lineáris regresszióról szóló oktatóanyagra, akkor tudjuk, hogy az MSE-t az előrejelzett kimenet és a valós címke közötti különbséggel számítjuk ki. Itt a címke a jellemző, mivel a modell megpróbálja rekonstruálni a bemenetet. Ezért a jósolt kimenet és a bemenet közötti négyzetes különbség összegének átlagát szeretnénk megkapni. A TensorFlow segítségével a veszteségfüggvényt a következőképpen kódolhatjuk:

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

Ezután optimalizálni kell a veszteségfüggvényt. Az Adam optimalizálót használjuk a gradiensek kiszámításához. A célfüggvény a veszteség minimalizálása.

## Optimize
loss = 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 betanítása előtt. 150-es kötegméretet szeretne használni, azaz minden iterációt 150 képpel kell betölteni a folyamatba. Az iterációk számát manuálisan kell kiszámítani. Ezt triviális csinálni:

Ha minden alkalommal 150 képet szeretne átadni, és tudja, hogy 5000 kép van az adathalmazban, akkor az iterációk száma egyenlő 5000 osztva 150-nel. Python A következő kódokat futtathatod, és ellenőrizheted, hogy a kimenet 33-as-e:

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

5. lépés) Futtassa a modellt

Végül, de nem utolsósorban, tanítsd be a modellt. A modellt 100 epoch-szal tanítod. Ez azt jelenti, hogy a modell 100-szor fogja látni a képeket, miközben optimalizálja a súlyokat.

Már ismered a TensorFlow-ban modell betanításához szükséges kódokat. A kis különbség az, hogy az adatokat a betanítás futtatása előtt kell továbbítani. Így a modell gyorsabban betanulható.

Érdekelne, hogy tíz korszak után kinyomtassa a veszteséget, hogy lássa, tanul-e valamit a modell (azaz csökken-e a veszteség). Az edzés a gép hardverétől függően 2-5 percig tart.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.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 shown
            print("\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.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

6. lépés) Értékelje a modellt

Most, hogy betanítottad a modelledet, itt az ideje kiértékelni. Importálnod kell a teszthalmazt 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'])

Jegyzet: Egy Windows gép, a kód a következő lesz: test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)

Megpróbálhatod kinyomtatni a 13. képet, ami egy ló.

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

A diagram megerősíti, hogy a tesztköteg megfelelően betöltődött, és hogy a 13-as kép ahhoz az osztályhoz tartozik, amelyen a modellt betanították.

A modell kiértékeléséhez a kép pixelértékét fogod használni, és megnézed, hogy a kódoló képes-e rekonstruálni ugyanazt a képet 1024 pixelre való zsugorítás után. Figyeld meg, hogy definiálsz egy függvényt a modell különböző képeken történő kiértékeléséhez. A modellnek csak lovakon kellene jobban működnie.

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

• df: Tesztadatok importálása
• image_number: adja meg, hogy melyik képet importálja

A funkció három részre oszlik:

1. Alakítsa át a képet a megfelelő méretre, azaz 1, 1024-re
2. Táplálja a modellt a nem látott képpel, kódolja/dekódolja a képet
3. Nyomtassa ki a valódi és rekonstruált képet

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_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 image
    with 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 image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = fig.add_subplot(122)
        plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
        plt.tight_layout()
        fig = plt.gcf()

Most, hogy a kiértékelő függvény definiálva van, megtekinthetjük a tizenharmadik rekonstruált képet.

reconstruct_image(df =test_x, image_number = 13)

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

Az ábra az eredeti tesztképet balra, az autoenkóder kimenetét pedig jobbra helyezi, így a finom részletek elvesztése az 1024-ről 150-re történő tömörítés után könnyen megítélhető.

GYIK