Autoenkoder u TensorFlowu s primjerom

Što je Autoenkoder u dubokom učenju?

An Autokoder je alat za učinkovito učenje kodiranja podataka u bez nadzora način. To je vrsta umjetna neuronska mreža koji vam pomaže naučiti reprezentaciju skupova podataka za smanjenje dimenzionalnosti treniranjem neuronske mreže da ignorira šum signala. Izvrstan je alat za ponovno stvaranje ulaza.

Jednostavno rečeno, stroj uzima, recimo, sliku i može stvoriti usko povezanu sliku. Ulaz u ovu vrstu neuronske mreže nije označen, što znači da mreža može učiti bez nadzora. Preciznije, ulaz je kodiran od strane mreže kako bi se usredotočio samo na najkritičniju značajku. To je jedan od razloga zašto je autoenkoder popularan za smanjenje dimenzionalnosti. Osim toga, autoenkoderi se mogu koristiti za stvaranje generativnih modela učenja. Na primjer, neuronska mreža se može trenirati skupom lica, a zatim može stvoriti nova lica.

Kako radi TensorFlow Autoenkoder?

Svrha autoenkodera je proizvesti aproksimaciju ulaza fokusirajući se samo na bitne značajke. Možda mislite zašto jednostavno ne naučite kako kopirati i zalijepiti ulaz da biste dobili izlaz. Zapravo, autokoder je skup ograničenja koja tjeraju mrežu da nauči nove načine predstavljanja podataka, različite od pukog kopiranja izlaza.

Tipični autoenkoder definiran je ulazom, internom reprezentacijom i izlazom (aproksimacija ulaza). Učenje se odvija u slojevima pridruženim internoj reprezentaciji. Zapravo, postoje dva glavna bloka slojeva koji izgledaju poput tradicionalne neuronske mreže. Mala razlika je u tome što sloj koji sadrži izlaz mora biti jednak ulazu. Na donjem dijagramu, izvorni ulaz ide u prvi blok koji se naziva enkoder. Ova interna reprezentacija komprimira (smanjuje) veličinu ulaza. U drugom bloku dolazi do rekonstrukcije ulaza. To je faza dekodiranja.

Model će ažurirati težine minimiziranjem funkcije gubitka. Model se kažnjava ako se izlaz rekonstrukcije razlikuje od ulaza.

Konkretno, zamislite sliku veličine 50 × 50 (tj. 2,500 piksela) i neuronsku mrežu s jednim skrivenim slojem sastavljenim od stotinu neurona. Učenje se provodi na mapi značajki koja je dvadeset pet puta manja od ulaza. To znači da mreža treba pronaći način da rekonstruira 2,500 piksela s vektorom neurona jednakim 100.

Primjer naslaganog autokodera

U ovom tutorijalu o autoenkoderu naučit ćete kako koristiti složeni autoenkoder. Arhitektura je slična tradicionalnoj neuronskoj mreži. Ulaz ide u skriveni sloj kako bi se komprimirao ili smanjio na veličinu, a zatim dolazi do slojeva za rekonstrukciju. Cilj je proizvesti izlaznu sliku što bližu originalu. Model mora naučiti način da postigne svoj zadatak pod skupom ograničenja, odnosno s nižom dimenzijom.

Danas se autoenkoderi u dubokom učenju uglavnom koriste za uklanjanje šuma sa slike. Zamislite sliku s ogrebotinama; čovjek je i dalje u stanju prepoznati sadržaj. Ideja autoenkodera za uklanjanje šuma je dodati šum slici kako bi se mreža prisilila da nauči uzorak iza podataka.

Druga korisna obitelj Autoencodera Duboko učenje je varijacijski autoenkoder. Ova vrsta mreže može generirati nove slike. Zamislite da trenirate mrežu sa slikom čovjeka; takva mreža može stvoriti nova lica.

Donja tablica smješta složeni autoenkoder izgrađen u ovom tutorialu pored ostalih obitelji koje ćete vjerojatno susresti, tako da je ograničenje koje svaki od njih dodaje lako usporediti.

Kako izgraditi autoenkoder s TensorFlowom

U ovom ćete vodiču naučiti kako izraditi naslagani autokoder za rekonstrukciju slike.

Koristit ćete skup podataka CIFAR-10 koji sadrži 60 000 slika u boji veličine 32 × 32. Skup podataka Autoencodera već je podijeljen na 50 000 slika za učenje i 10 000 za testiranje. Postoji do deset klasa:

• Zrakoplov
• Automobil
• Ptica
• Mačka
• Jelen
• Pas
• Žaba
• Konj
• Brod
• Kamion

Slike morate preuzeti s Stranica skupa podataka CIFAR-10 i raspakirajte arhivu. Mapa cifar-10-batches-py sadrži pet serija podataka s po 10000 slika u slučajnom redoslijedu.

Prije nego što izgradite i obučite svoj model, morate primijeniti određenu obradu podataka. Postupit ćete na sljedeći način:

1. Uvezite podatke
2. Pretvorite podatke u crno-bijeli format
3. Dodajte sve serije
4. Konstruirajte skup podataka za obuku
5. Konstruirajte vizualizator slike

Napomena o verziji: Kôd u ovom tutorialu namijenjen je TensorFlowu 1.x. Na TensorFlowu 2 modul tf.contrib više ne postoji, a rezervirana mjesta, sesije i inicijalizirajući iterator nalaze se pod tf.compat.v1. Pozivanje tf.compat.v1.disable_v2_behavior() nakon uvoza najbrži je način za pokretanje nepromijenjenih popisa.

Predobrada slike

Korak 1) Uvezite podatke

Prema službenoj web stranici, podatke možete prenijeti pomoću sljedećeg koda. Autoencoder kod će učitati podatke u rječnik s podacima i oznakom. Imajte na umu da je kod funkcija.

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

Korak 2) Pretvorite podatke u crno-bijeli format

Radi jednostavnosti, podatke ćete pretvoriti u sive tonove. To jest, sa samo jednom dimenzijom u odnosu na tri za sliku boja. Većina neuronskih mreža radi samo s jednom dimenzijom ulaza.

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

Korak 3) Dodajte sve serije

Sada kada su obje funkcije kreirane i skup podataka učitan, možete napisati petlju za dodavanje podataka u memoriju. Ako pažljivo provjerite, raspakirana datoteka s podacima zove se data_batch_ s brojem od 1 do 5. Možete petljom pregledati datoteke i dodati ih podacima.

Kada je ovaj korak završen, pretvarate podatke o boji u format sive skale. Kao što vidite, oblik podataka je 50000 i 1024. 32*32 piksela sada su spljoštena na 1024.

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

Bilješka: Promijenite './cifar-10-batches-py/data_batch_' u stvarnu lokaciju vaše datoteke. Na primjer, za Windows stroj, put može biti naziv datoteke = 'E:\cifar-10-batches-py\data_batch_' + str(i)

Korak 4) Konstruirajte skup podataka za obuku

Kako bi trening bio brži i lakši, trenirat ćete model samo na slikama konja. Konji nose oznaku 7 u podacima oznake. Kao što je spomenuto u dokumentaciji skupa podataka CIFAR-10, svaka klasa sadrži 5000 slika. Možete ispisati oblik podataka kako biste potvrdili da postoji 5,000 slika s 1024 stupca kao što je prikazano u donjem primjeru koraka TensorFlow Autoencodera.

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

Korak 5) Konstruirajte vizualizator slike

Konačno, konstruirate funkciju za iscrtavanje slika. Ova će vam funkcija trebati za ispis rekonstruirane slike iz autokodera.

Jednostavan način ispisa slika je korištenje funkcije imshow() iz Matplotlib biblioteke. Imajte na umu da trebate pretvoriti oblik podataka iz 1024 u 32*32 (tj. format slike).

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

Funkcija prima 3 argumenta:

• Slika: ulaz
• Oblik: popis, dimenzija slike
• Cmap: odaberite kartu boja. Prema zadanim postavkama, siva

Možete pokušati iscrtati prvu sliku u skupu podataka. Trebali biste vidjeti čovjeka na konju.

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

Poziv vraća sličicu u sivim tonovima ispod i potvrđuje da je preoblikovanje s 1024 vrijednosti natrag na sliku veličine 32×32 ispravno.

Postavite procjenitelj skupa podataka

U redu, sada kada je skup podataka spreman za korištenje, možete početi koristiti TensorFlow. Prije izgradnje modela, upotrijebite estimator skupa podataka TensorFlowa za opskrbu mreže.

Izgradit ćete skup podataka s TensorFlow estimatorom. Da biste osvježili svoj um, trebate koristiti:

• iz_odsječaka_tenzora
• ponoviti
• serija

Potpuni kod za izradu skupa podataka je:

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

Imajte na umu da je x rezervirano mjesto u obliku [None,n_inputs]. Prva dimenzija je postavljena na None jer je broj slika koje se šalju mreži jednak veličini serije, koja se određuje tek tijekom izvođenja. Za detalje pogledajte vodič o linearna regresija s TensorFlowom.

Nakon toga morate kreirati iterator. Bez ovog retka koda nikakvi podaci neće proći kroz cjevovod.

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

Sada kada je cjevovod spreman, možete provjeriti je li prva slika ista kao prije (tj. čovjek na konju).

Veličinu serije postavljate na 1 jer želite skupu podataka poslati samo jednu sliku. Dimenziju podataka možete vidjeti pomoću naredbe print(sess.run(features).shape). Jednaka je (1, 1024). Vrijednost 1 znači da se svaki put šalje jedna slika s 1024 vrijednosti. Ako je veličina serije postavljena na dvije, tada će kroz cjevovod proći dvije slike. Nemojte mijenjati veličinu serije, inače će se pojaviti greška jer samo jedna slika odjednom može ići u funkciju plot_image().

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

Cjevovod vraća isti rider koji je iscrtan izravno iz NumPy matrice, što dokazuje da su rezervirano mjesto, iterator i veličina serije ispravno povezani.

Izgradite mrežu

Vrijeme je za izgradnju mreže. Trenirati ćete složeni autokoder, odnosno mrežu s više skrivenih slojeva.

Vaša mreža će imati jedan ulazni sloj s 1024 točke, tj. 32×32, oblik slike.

Blok enkodera imat će jedan gornji skriveni sloj s 300 neurona i središnji sloj sa 150 neurona. Blok dekodera simetričan je enkoderu. Mrežu možete vizualizirati na donjem dijagramu. Imajte na umu da možete promijeniti vrijednosti skrivenih i središnjih slojeva.

Izrada autoenkodera vrlo je slična bilo kojem drugom modelu dubokog učenja.

Model ćete izraditi slijedeći ove korake:

1. Definirajte parametre
2. Definirajte slojeve
3. Definirajte arhitekturu
4. Definirajte optimizaciju
5. Pokrenite model
6. Ocijenite model

U prethodnom odjeljku naučili ste kako stvoriti cjevovod za punjenje modela, tako da nema potrebe za ponovnim stvaranjem skupa podataka. Konstruirat ćete autoenkoder s četiri sloja. Koristite Xavierovu inicijalizaciju. To je tehnika za postavljanje početnih težina prema varijanci ulaza i izlaza. Na kraju, koristite ELU aktivacijsku funkciju. Regularizirate funkciju gubitka pomoću L2 regularizatora.

Korak 1) Definirajte parametre

Prvi korak podrazumijeva definiranje broja neurona u svakom sloju, stopu učenja i hiperparametar regularizatora.

Prije toga, uvozite parcijalnu funkciju. To je bolja metoda za definiranje parametara gustih slojeva. Donji kod definira vrijednosti arhitekture autoenkodera. Kao što je već navedeno, enkoder ima dva sloja, s 300 neurona u prvom sloju i 150 u drugom sloju. Njihove vrijednosti pohranjene su u n_hidden_1 i n_hidden_2.

Morate definirati brzinu učenja i hiperparametar L2. Vrijednosti su pohranjene u learning_rate i l2_reg.

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

Tehnika Xavierove inicijalizacije poziva se s objektom xavier_initializer iz estimatora contrib. U istom estimatoru možete dodati regularizator s l2_regularizer.

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

Napomena o verziji: tf.contrib je uklonjen u TensorFlowu 2. Izravne zamjene su tf.keras.initializers.GlorotUniform() za xavier_initializer() i tf.keras.regularizers.l2() za l2_regularizer().

Korak 2) Definirajte slojeve

Svi parametri gustih slojeva su postavljeni; sve možete spakirati u varijablu dense_layer korištenjem object partial. dense_layer zatim koristi ELU aktivaciju, Xavierovu inicijalizaciju i L2 regularizaciju pri svakom pozivu.

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

Korak 3) Definirajte arhitekturu

Ako pogledate dijagram arhitekture, primijetit ćete da mreža slaže tri sloja s izlaznim slojem. U donjem kodu povezujete odgovarajuće slojeve. Na primjer, prvi sloj izračunava skalarni produkt između ulaznih matrica i matrice koja sadrži 300 težina. Nakon što se izračuna skalarni produkt, izlaz ide u aktivacijsku funkciju ELU. Izlaz postaje ulaz sljedećeg sloja, zato ga koristite za izračunavanje hidden_2 i tako dalje. Množenje matrica je isto za svaki sloj jer koristite istu aktivacijsku funkciju. Imajte na umu da posljednji sloj, outputs, ne primjenjuje aktivacijsku funkciju. To ima smisla jer je ovo rekonstruirani ulaz.

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

Korak 4) Definirajte optimizaciju

Posljednji korak je konstruiranje optimizatora. Koristite srednju kvadratnu pogrešku kao funkciju gubitka. Ako se sjećate tutorijala o linearnoj regresiji, znate da se MSE izračunava s razlikom između predviđenog izlaza i stvarne oznake. Ovdje je oznaka značajka jer model pokušava rekonstruirati ulaz. Stoga želite srednju vrijednost zbroja kvadratne razlike između predviđenog izlaza i ulaza. Pomoću TensorFlowa možete kodirati funkciju gubitka na sljedeći način:

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

Zatim trebate optimizirati funkciju gubitka. Za izračun gradijenta koristite Adam optimizator. Ciljna funkcija je minimizirati gubitak.

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

Još jedna postavka prije treninga modela. Želite upotrijebiti veličinu serije od 150, to jest, unijeti cjevovod sa 150 slika u svakoj iteraciji. Morate ručno izračunati broj ponavljanja. Ovo je trivijalno učiniti:

Ako želite svaki put proslijediti 150 slika i znate da u skupu podataka postoji 5000 slika, broj iteracija jednak je 5000 podijeljeno sa 150. U Python Možete pokrenuti sljedeće kodove i provjeriti je li izlaz 33:

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

Korak 5) Pokrenite model

Na kraju, ali ne i najmanje važno, trenirajte model. Trenirate model sa 100 epoha. To jest, model će vidjeti slike 100 puta dok optimizira težine.

Već ste upoznati s kodovima za treniranje modela u TensorFlowu. Mala razlika je u slanju podataka prije pokretanja treniranja. Na taj način model se brže trenira.

Zanima vas ispis gubitka nakon deset epoha da vidite uči li model nešto (tj. gubici se smanjuju). Obuka traje 2 do 5 minuta, ovisno o hardveru vašeg stroja.

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

Korak 6) Procijenite model

Sada kada ste obučili svoj model, vrijeme je da ga procijenite. Potrebno je uvesti testni skup iz datoteke /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'])

Bilješka: Za Windows stroj, kod postaje test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)

Možete pokušati ispisati sliku 13, koja prikazuje konja.

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

Grafikon potvrđuje da je testna serija ispravno učitana i da slika 13 pripada klasi na kojoj je model treniran.

Za procjenu modela, koristit ćete vrijednost piksela ove slike i vidjeti može li enkoder rekonstruirati istu sliku nakon što je smanji na 1024 piksela. Imajte na umu da definirate funkciju za procjenu modela na različitim slikama. Model bi trebao bolje raditi samo na konjima.

Funkcija prima dva argumenta:

• df: Uvoz testnih podataka
• broj_slike: označava koju sliku treba uvesti

Funkcija je podijeljena u tri dijela:

1. Preoblikujte sliku na ispravnu dimenziju, tj. 1, 1024
2. Nahranite model neviđenom slikom, kodirajte/dekodirajte sliku
3. Ispišite stvarnu i rekonstruiranu sliku

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

Sada kada je funkcija evaluacije definirana, možete pogledati rekonstruiranu sliku broj trinaest.

reconstruct_image(df =test_x, image_number = 13)

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

Slika postavlja originalnu testnu sliku s lijeve strane, a izlaz autoenkodera s desne, tako da je gubitak finih detalja nakon kompresije od 1024 do 150 lako procijeniti.

Pitanja i odgovori