Mikä on konvoluutiohermoverkko?
Konvoluutiohermoverkko, joka tunnetaan myös nimellä convnets tai CNN, on tunnettu menetelmä tietokonenäkösovelluksissa. Tämän tyyppinen arkkitehtuuri on hallitseva esineiden tunnistamiseksi kuvasta tai videosta.
Tässä opetusohjelmassa opit, miten konveti muodostetaan ja kuinka TensorFlow-ohjelmaa käytetään käsinkirjoitetun tietojoukon ratkaisemiseen.
Tässä opetusohjelmassa opit
- Konvoluutioinen hermoverkko
- Konvoluutiohermoverkon arkkitehtuuri
- Convnet-verkkojen komponentit
- Juna CNN TensorFlow: lla
- Vaihe 1: Lataa tietojoukko
- Vaihe 2: Syöttökerros
- Vaihe 3: Konvoluutiokerros
- Vaihe 4: Kerroksen yhdistäminen
- Vaihe 5: Toinen konvoluutiokerros ja yhdistämiskerros
- Vaihe 6: Tiheä kerros
- Vaihe 7: Logit Layer
Konvoluutiohermoverkon arkkitehtuuri
Ajattele Facebookia muutama vuosi sitten, kun olet ladannut kuvan profiiliisi, sinua pyydettiin lisäämään nimi kuvan kasvoihin manuaalisesti. Nykyään Facebook käyttää convnet-koodia ystävällesi kuvassa automaattisesti.
Konvoluutiohermoverkkoa ei ole kovin vaikea ymmärtää. Syötekuva käsitellään konvoluutiovaiheessa ja sille määritetään myöhemmin tarra.
Tyypillinen convnet-arkkitehtuuri voidaan tiivistää alla olevaan kuvaan. Ensinnäkin kuva työnnetään verkkoon; tätä kutsutaan tulokuvaksi. Sitten syötekuva käy läpi äärettömän määrän vaiheita; tämä on verkon konvoluutioosa. Lopuksi hermoverkko voi ennustaa kuvan numeron.
Kuva koostuu joukosta pikseleitä, joiden korkeus ja leveys ovat. Harmaasävykuvassa on vain yksi kanava, kun taas värikuvassa on kolme kanavaa (kukin punaiselle, vihreälle ja siniselle). Kanava on pinottu toistensa päälle. Tässä opetusohjelmassa käytetään harmaasävykuvaa, jossa on vain yksi kanava. Jokaisella pikselillä on arvo 0–255, joka heijastaa värin voimakkuutta. Esimerkiksi pikseli, joka on yhtä suuri kuin 0, näyttää valkoisen värin, kun taas pikseli, jonka arvo on lähellä 255, on tummempi.
Katsotaanpa kuva MNIST-aineistoon tallennetusta kuvasta. Alla oleva kuva osoittaa, miten vasemmanpuoleinen kuva voidaan esittää matriisimuodossa. Huomaa, että alkuperäinen matriisi on standardoitu välille 0–1. Tummemmille väreille matriisin arvo on noin 0,9, kun taas valkoisten pikselien arvo on 0.
Konvoluutiooperaatio
Mallin kriittisin komponentti on konvoluutiokerros. Tämän osan tarkoituksena on pienentää kuvan kokoa painojen nopeampaa laskemista varten ja parantaa sen yleistymistä.
Konvoluutioosan aikana verkko säilyttää kuvan olennaiset piirteet ja sulkee pois merkityksetöntä kohinaa. Esimerkiksi malli oppii tunnistamaan norsun kuvasta, jonka taustalla on vuori. Jos käytät perinteistä hermoverkkoa, malli antaa painon kaikille pikseleille, myös vuorelta tuleville pikseleille, mikä ei ole välttämätöntä ja voi johtaa verkkoa harhaan.
Sen sijaan konvoluutiohermoverkko käyttää matemaattista tekniikkaa vain tärkeimpien pikselien purkamiseen. Tätä matemaattista operaatiota kutsutaan konvoluutioksi. Tämän tekniikan avulla verkko voi oppia yhä monimutkaisempia ominaisuuksia jokaisella kerroksella. Konvoluutio jakaa matriisin pieniksi paloiksi oppimaan tärkeimmät elementit jokaisessa kappaleessa.
Convnet-verkkojen komponentit
Convnetsissä on neljä komponenttia
- Konvoluutio
- Epälineaarisuus (ReLU)
- Yhdistäminen tai alinäytteenotto
- Luokitus (täysin yhdistetty kerros)
- Konvoluutio
Konvoluution tarkoituksena on poimia objektin piirteet kuvasta paikallisesti. Se tarkoittaa, että verkko oppii tietyt kuviot kuvassa ja pystyy tunnistamaan sen kaikkialla kuvassa.
Konvoluutio on elementtikohtainen kertolasku. Käsite on helppo ymmärtää. Tietokone skannaa osan kuvasta, yleensä kooltaan 3x3, ja kertoo sen suodattimeksi. Elementtisen kertolaskun lähtöä kutsutaan ominaisuuskartaksi. Tätä vaihetta toistetaan, kunnes koko kuva skannataan. Huomaa, että kääntämisen jälkeen kuvan kokoa pienennetään.
Alla on URL-osoite, jolla näet toiminnassa miten konvoluutio toimii.
Saatavilla on lukuisia kanavia. Alla luetellaan joitain kanavia. Voit nähdä, että jokaisella suodattimella on tietty tarkoitus. Huomaa, alla olevassa kuvassa; ydin on suodattimen synonyymi.
Lähde
Konvoluution takana oleva aritmeikka
Konvoluutiovaihe käyttää suodatinta pieneen pikseliryhmään kuvan sisällä. Suodatin liikkuu tulokuvaa pitkin yleisen muodon 3x3 tai 5x5. Se tarkoittaa, että verkko liu'uttaa nämä ikkunat koko syötekuvan läpi ja laskee kokoonpanon. Alla oleva kuva osoittaa, miten konvoluutio toimii. Laastarin koko on 3x3, ja lähtömatriisi on seurausta kuvamatriisin ja suodattimen välisestä elementtikohtaisesta toiminnasta.
Lähde
Huomaa, että lähdön leveys ja korkeus voivat poiketa tulon leveydestä ja korkeudesta. Se tapahtuu rajavaikutuksen takia.
Rajavaikutus
Kuvassa on 5x5-ominaisuuskartta ja 3x3-suodatin. Keskellä on vain yksi ikkuna, jossa suodatin voi näyttää 3x3-ruudukon. Tulostuskartta kutistuu kahdella ruudulla 3x3-ulottuvuuden rinnalla.
Jos haluat saada saman ulostulon kuin ulottuvuus, sinun on lisättävä täyte. Täyte koostuu oikean määrän rivien ja sarakkeiden lisäämisestä matriisin kummallekin puolelle. Sen avulla konvoluutio sopii keskitetysti jokaiseen tuloruutuun. Alla olevassa kuvassa tulo- / lähtömatriisilla on sama koko 5x5
Kun määrität verkon, yhdistettyjä ominaisuuksia hallitaan kolmella parametrilla:
- Syvyys: Se määrittää konvoluution aikana käytettävien suodattimien määrän. Edellisessä esimerkissä näet yhden syvyyden, eli vain yhtä suodatinta käytetään. Useimmissa tapauksissa suodattimia on enemmän kuin yksi. Alla olevassa kuvassa esitetään toiminnot, jotka on tehty tilanteessa, jossa on kolme suodatinta
- Stride: Se määrittää kahden pikselin välisen "pikselin hyppyjen" määrän. Jos askel on yhtä suuri kuin 1, ikkunat liikkuvat yhden pikselin levityksen mukaan. Jos askel on yhtä suuri kuin kaksi, ikkunat hyppäävät 2 pikseliä. Jos lisäät askelta, sinulla on pienemmät kartat.
Esimerkki askeleesta 1
Kuvaharppaus 2
- Nolla-täyte: Täyte on toiminto, jolla lisätään vastaava määrä rivejä ja sarakkeita tulo-ominaisuuksien karttojen kummallekin puolelle. Tässä tapauksessa lähdöllä on sama ulottuvuus kuin tulolla.
- Epälineaarisuus (ReLU)
Konvoluutiooperaation lopussa lähtöön kohdistetaan aktivointitoiminto epälineaarisuuden sallimiseksi. Tavallinen convnet-aktivointitoiminto on Relu. Kaikki negatiivisen arvon sisältävät pikselit korvataan nollilla.
- Maksimaalinen yhdistäminen
Tämä vaihe on helppo ymmärtää. Pooloinnin tarkoituksena on vähentää tulokuvan ulottuvuutta. Vaiheet tehdään operaation laskennallisen monimutkaisuuden vähentämiseksi. Pienentämällä mittasuhteita verkolla on pienemmät painot laskea varten, joten se estää yliasennuksen.
Tässä vaiheessa sinun on määritettävä koko ja askel. Tavallinen tapa yhdistää tulokuva on käyttää karttakortin enimmäisarvoa. Katso alla olevaa kuvaa. "Yhdistäminen" näyttää 4x4-ominaisuuskartan neljä alimatriisia ja palauttaa maksimiarvon. Yhdistäminen ottaa 2x2-taulukon maksimiarvon ja siirtää sitten tätä ikkunaa kahdella pikselillä. Esimerkiksi ensimmäinen alamatriisi on [3,1,3,2], poolointi palauttaa maksimin, joka on 3.
On toinenkin yhdistämistoiminto, kuten keskiarvo.
Tämä toiminto pienentää karttakokoa aggressiivisesti
- Täysin yhdistetyt kerrokset
Viimeinen vaihe koostuu perinteisen keinotekoisen hermoverkon rakentamisesta, kuten teit edellisessä opetusohjelmassa. Yhdistät kaikki edellisen kerroksen neuronit seuraavaan kerrokseen. Luokitat syötekuvan numeron softmax-aktivointitoiminnolla.
Kertaus:
Konvoluutio-hermoverkko kokoaa eri kerrokset ennen ennustamista. Neuroverkolla on:
- Konvoluutiokerros
- Relu Activation -toiminto
- Poolikerros
- Tiheästi yhdistetty kerros
Konvoluutiokerrokset käyttävät erilaisia suodattimia kuvan osa-alueelle. Relu-aktivointitoiminto lisää epälineaarisuutta, ja poolikerrokset vähentävät karttojen ominaisuuksia.
Kaikki nämä kerrokset poimivat olennaiset tiedot kuvista. Viimeinkin ominaisuuksien kartta syötetään ensisijaiseen täysin yhdistettyyn kerrokseen, jossa on softmax-toiminto ennusteen tekemistä varten.
Juna CNN TensorFlow: lla
Nyt kun olet perehtynyt konvettien rakennuspalikkaan, olet valmis rakentamaan sen TensorFlow-ohjelmalla. Käytämme MNIST-aineistoa kuvien luokittelussa.
Tietojen valmistelu on sama kuin edellinen opetusohjelma. Voit suorittaa koodit ja siirtyä suoraan CNN: n arkkitehtuuriin.
Noudatat seuraavia vaiheita:
Vaihe 1: Lataa tietojoukko
Vaihe 2: Syöttökerros
Vaihe 3: Konvoluutiokerros
Vaihe 4: Kerroksen yhdistäminen
Vaihe 5: Toinen konvoluutiokerros ja yhdistämiskerros
Vaihe 6: Tiheä kerros
Vaihe 7: Logit Layer
Vaihe 1: Lataa tietojoukko
MNIST-tietojoukko on saatavana scikitillä oppiaksesi tästä URL-osoitteesta. Lataa se ja tallenna se Lataukset-kansioon. Voit ladata sen fetch_mldata-tiedostolla ('MNIST original').
Luo juna / testisarja
Sinun on jaettava tietojoukko train_test_split-tunnuksella
Skaalaa ominaisuudet
Lopuksi voit skaalata ominaisuutta MinMaxScalerilla
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]
Määritä CNN
CNN käyttää kuvan raakapikselissä olevia suodattimia oppiakseen yksityiskohtia kuviosta verrattuna perinteiseen hermoverkkoon. CNN: n muodostamiseksi sinun on määritettävä:
- Konvoluutiotaso: Lisää n määrää suodattimia karttaan. Konvoluution jälkeen sinun on käytettävä Relu-aktivointitoimintoa lisätäksesi epälineaarisuutta verkkoon.
- Poolikerros: Seuraava vaihe kääntymisen jälkeen on vähentää ominaisuuden enimmäismäärää. Tarkoituksena on vähentää karttakoon mittasuhteita estääkseen liiallisen istuvuuden ja parantamalla laskennanopeutta. Max pooling on perinteinen tekniikka, joka jakaa karttakartat osa-alueiksi (yleensä kooltaan 2x2) ja pitää vain maksimiarvot.
- Täysin yhdistetyt kerrokset: Kaikki edellisten kerrosten neuronit on kytketty seuraaviin kerroksiin. CNN luokittelee etiketin konvoluutiokerrosten ominaisuuksien mukaan ja pienennetään poolikerroksen kanssa.
CNN-arkkitehtuuri
- Konvoluutiokerros: Käytetään 14 5x5-suodatinta (puretaan 5x5-pikselin ala-alueet) ReLU-aktivointitoiminnolla
- Pooling Layer: Suorittaa enimmäispooloinnin 2x2-suodattimella ja 2-askeleella (mikä määrittää, että yhdistetyt alueet eivät ole päällekkäisiä)
- Konvoluutiokerros: Käytetään 36 5x5-suodatinta ReLU-aktivointitoiminnolla
- Pooling Layer 2: Jälleen suorittaa enimmäispooloinnin 2x2-suodattimella ja 2-askeleella
- 1764 hermosolua, keskeyttämisen laillistumisnopeudella 0,4 (todennäköisyys 0,4, että jokin tietty elementti putoaa harjoituksen aikana)
- Tiheä kerros (Logits Layer): 10 hermosolua, yksi kutakin numeroluokkaa kohti (0-9).
CNN: n luomiseen on käytettävä kolmea tärkeää moduulia:
- conv2d (). Muodostaa kaksiulotteisen konvoluutiokerroksen, jossa argumentteina on suodattimien määrä, suodattimen ytimen koko, täyte ja aktivointitoiminto.
- max_pooling2d (). Rakentaa kaksiulotteisen poolointikerroksen max-pooling-algoritmilla.
- tiheä(). Rakentaa tiheän kerroksen piilotettujen kerrosten ja yksiköiden kanssa
Määrität toiminnon CNN: n rakentamiseksi. Katsotaanpa yksityiskohtaisesti, kuinka kukin rakennusosa rakennetaan ennen kuin kaikki kääritään toimintoon.
Vaihe 2: Syöttökerros
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Sinun on määritettävä tensori tietojen muodon kanssa. Tätä varten voit käyttää moduulia tf.reshape. Tässä moduulissa sinun on ilmoitettava tensori muokkaavan ja tensorin muoto. Ensimmäinen argumentti on datan ominaisuudet, jotka määritellään funktion argumentissa.
Kuvassa on korkeus, leveys ja kanava. MNIST-tietojoukko on yksivärinen kuva, jonka koko on 28x28. Asetamme erän kooksi -1 muodon argumentissa siten, että se on ominaisuuksien ["x"] muotoinen. Etuna on tehdä eräkoon hyperparametrit viritettäväksi. Jos eräkoko on 7, tensori syöttää 5488 arvoa (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Ensimmäisessä konvoluutiokerroksessa on 14 suodatinta, joiden ytimen koko on 5x5, samalla täytteellä. Sama täyte tarkoittaa, että sekä lähtö- että tulojännitteen tulee olla saman korkeuden ja leveyden kanssa. Tensorflow lisää nollia riveihin ja sarakkeisiin saman koon varmistamiseksi.
Käytät Relu-aktivointitoimintoa. Tulostuskoko on [28, 28, 14].
Vaihe 4: Kerroksen yhdistäminen
Seuraava vaihe konvoluution jälkeen on poolilaskenta. Yhdistelmälaskenta vähentää datan ulottuvuutta. Voit käyttää moduulia max_pooling2d, jonka koko on 2x2 ja askel 2. Syötteenä käytetään edellistä tasoa. Tulostuskoko on [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Vaihe 5: Toinen konvoluutiokerros ja yhdistämiskerros
Toisessa konvoluutiokerroksessa on 32 suodatinta, joiden ulostulokoko on [batch_size, 14, 14, 32]. Poolikerroksen koko on sama kuin aikaisemmin, ja ulostulomuoto on [batch_size, 14, 14, 18].
conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
Vaihe 6: Tiheä kerros
Sitten sinun on määritettävä täysin kytketty kerros. Karttakartta on tasoitettava ennen sen liittämistä tiheään kerrokseen. Voit käyttää moduulin muotoilua kooltaan 7 * 7 * 36.
Tiheä kerros yhdistää 1764 neuronia. Lisät Relu-aktivointitoiminnon. Lisäksi lisäät keskeyttämisen laillistamistermin, jonka nopeus on 0,3, eli 30 prosenttia painoista asetetaan arvoon 0. Huomaa, että keskeyttäminen tapahtuu vain harjoitusvaiheen aikana. Funktiolla cnn_model_fn on argumenttitila ilmoittaakseen, onko mallia tarpeen kouluttaa tai arvioida.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Vaihe 7: Logit Layer
Lopuksi voit määrittää viimeisen kerroksen mallin ennustuksella. Tulostuksen muoto on yhtä suuri kuin eräkoko ja 10, kuvien kokonaismäärä.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Voit luoda sanakirjan, joka sisältää luokat ja kunkin luokan todennäköisyyden. Moduuli tf.argmax () with palauttaa suurimman arvon, jos logit-kerrokset. Softmax-funktio palauttaa kunkin luokan todennäköisyyden.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Haluat palauttaa sanakirjan ennusteen vain, kun tila on asetettu ennustukseksi. Lisäät nämä koodit ennusteiden levittämiseksi
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Seuraava vaihe on laskea mallin menetys. Viimeisessä opetusohjelmassa opit, että moniklassisen mallin menetystoiminto on ristiin entropia. Tappio lasketaan helposti seuraavalla koodilla:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
Viimeinen vaihe on mallin optimointi, eli painojen parhaiden arvojen löytäminen. Tätä varten käytät kaltevuuslaskun optimointia, jonka oppimisnopeus on 0,001. Tavoitteena on minimoida menetys
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Olet valmis CNN: n kanssa. Haluat kuitenkin näyttää suorituskykymittarit arviointitilan aikana. Moniklassisen mallin suorituskykymittarit ovat tarkkuustietoja. Tensorflow on varustettu moduulin tarkkuudella, jossa on kaksi argumenttia, tarrat ja ennustetut arvot.
eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Se siitä. Loit ensimmäisen CNN: n ja olet valmis käärimään kaiken funktioon, jotta voit käyttää sitä mallin kouluttamiseen ja arviointiin.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Seuraavat vaiheet ovat samat kuin edelliset oppaat.
Ensinnäkin määrität estimaattorin CNN-mallilla.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
CNN: n kouluttaminen kestää useita kertoja, joten luot Logging-koukun, joka tallentaa softmax-kerrosten arvot 50 iteraation välein.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Olet valmis arvioimaan mallin. Asetat eräkoon 100 ja sekoitat tietoja. Huomaa, että asetimme 16.000 harjoitteluvaiheen, harjoittelu voi viedä paljon aikaa. Ole kärsivällinen.
# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])
Nyt kun malli on juna, voit arvioida sen ja tulostaa tulokset
# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}
Nykyisellä arkkitehtuurilla saat 97% tarkkuuden. Voit muuttaa arkkitehtuuria, eräkokoa ja iteroinnin määrää tarkkuuden parantamiseksi. CNN-hermoverkko on toiminut paljon paremmin kuin ANN tai logistinen regressio. Keinotekoisen hermoverkon opetusohjelmassa tarkkuus oli 96%, mikä on alhaisempi CNN. Suorituskyky CNN ovat vaikuttavia, jolla on suurempi kuva asetettu , sekä aikavälin nopeuden laskenta ja tarkkuus.
Yhteenveto
Konvoluutioinen hermoverkko toimii erittäin hyvin kuvan arvioimiseksi. Tämän tyyppinen arkkitehtuuri on hallitseva esineiden tunnistamiseksi kuvasta tai videosta.
CNN: n rakentaminen edellyttää kuutta vaihetta:
Vaihe 1: Syöttökerros:
Tämä vaihe muokkaa tietoja uudelleen. Muoto on yhtä suuri kuin pikselien määrän neliöjuuri. Esimerkiksi, jos kuvassa on 156 pikseliä, muoto on 26x26. Sinun on määritettävä, onko kuvassa väriä vai ei. Jos kyllä, niin sinulla oli 3 muotoon 3 RGB-, muuten 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Vaihe 2: Konvoluutiokerros
Seuraavaksi sinun on luotava konvoluutiokerrokset. Voit käyttää erilaisia suodattimia, jotta verkko voi oppia tärkeän ominaisuuden. Määrität ytimen koon ja suodattimien määrän.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Vaihe 3: Kerroksen yhdistäminen
Kolmannessa vaiheessa lisäät yhdistämiskerroksen. Tämä kerros pienentää syötteen kokoa. Se tekee niin ottamalla alimatriisin maksimiarvon. Esimerkiksi, jos alamatriisi on [3,1,3,2], poolointi palauttaa maksimin, joka on 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Vaihe 4: Lisää kääntökerros ja yhdistämiskerros
Tässä vaiheessa voit lisätä niin paljon kuin haluat konv-tasoja ja poolikerroksia. Google käyttää arkkitehtuuria, jossa on yli 20 muunnoskerrosta.
Vaihe 5: Tiheä kerros
Vaihe 5 tasoittaa edellisen luomaan täysin liitetyt kerrokset. Tässä vaiheessa voit käyttää eri aktivointitoimintoa ja lisätä keskeyttämisen.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Vaihe 6: Logit Layer
Viimeinen vaihe on ennuste.
logits = tf.layers.dense(inputs=dropout, units=10)