CNN-kuvan luokittelu TensorFlow'ssa vaiheineen ja esimerkein

Mikä on konvoluutiohermoverkko?

Konvoluutiohermoverkko, joka tunnetaan myös nimellä convnets tai CNN, on hyvin tunnettu menetelmä tietokonenäkösovelluksissa. Se on luokka syviä hermoverkkoja, joita käytetään visuaalisen kuvan analysointiin. Tämäntyyppinen arkkitehtuuri on hallitseva tunnistamaan esineitä kuvasta tai videosta. Sitä käytetään sovelluksissa, kuten kuvan tai videon tunnistus, hermokielen käsittely jne.

Archikonvoluutiohermoverkon rakenne

Ajattele Facebookia muutama vuosi sitten, kun olet ladannut kuvan profiiliisi, sinua pyydettiin lisäämään nimi kuvan kasvoille manuaalisesti. Nykyään Facebook merkitsee ystäväsi kuvaan automaattisesti convnetin avulla.

Konvoluutiohermoverkko kuvien luokittelua varten ei ole kovin vaikea ymmärtää. Syöttökuva käsitellään konvoluutiovaiheen aikana ja sille liitetään myöhemmin etiketti.

Tyypillinen convnet-arkkitehtuuri voidaan tiivistää alla olevaan kuvaan. Ensinnäkin kuva työnnetään verkkoon; tätä kutsutaan tulokuvaksi. Sitten syöttökuva 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ä, joilla on korkeus ja leveys. Harmaasävykuvassa on vain yksi kanava, kun taas värikuvassa on kolme kanavaa (jokainen punaiselle, vihreälle ja siniselle). Kanava on pinottu päällekkäin. Tässä opetusohjelmassa käytät harmaasävykuvaa vain yhdellä kanavalla. Jokaisen pikselin arvo on 0 - 255, joka kuvastaa 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 kuvaa, joka on tallennettu MNIST-tietojoukko. Alla oleva kuva näyttää, kuinka vasemmanpuoleinen kuva esitetään matriisimuodossa. Huomaa, että alkuperäinen matriisi on standardoitu 0:n ja 1:n välille. Tummemman värin kohdalla matriisin arvo on noin 0.9, kun taas valkoisten pikselien arvo on 0.

Konvoluutiotoiminta

Mallin kriittisin komponentti on konvoluutiokerros. Tämän osan tarkoituksena on pienentää kuvan kokoa painojen nopeampaa laskemista varten ja parantaa sen yleistämistä.

Konvoluutioosan aikana verkko säilyttää kuvan olennaiset ominaisuudet ja sulkee pois epäolennaisen kohinan. Malli esimerkiksi oppii tunnistamaan norsun kuvasta, jonka taustalla on vuori. Jos käytät perinteistä hermoverkkoa, malli antaa painon kaikille pikseleille, myös vuoren pikseleille, mikä ei ole välttämätöntä ja voi johtaa verkkoa harhaan.

Sen sijaan a Keras konvoluutiohermoverkko käyttää matemaattista tekniikkaa vain tärkeimpien pikselien poimimiseen. Tätä matemaattista operaatiota kutsutaan konvoluutioksi. Tämän tekniikan avulla verkko voi oppia yhä monimutkaisempia ominaisuuksia kullakin tasolla. Konvoluutio jakaa matriisin pieniksi paloiksi oppiakseen kunkin kappaleen tärkeimmät elementit.

Konvoluutiohermoverkon komponentit (ConvNet tai CNN)

Convnetissä on neljä osaa

1. Kierre
2. Ei-lineaarisuus (ReLU)
3. Pooling tai Sub Sampling
4. Luokittelu (täysin yhdistetty kerros)

Kierre

Konvoluution tarkoituksena on poimia kuvassa olevan kohteen piirteet paikallisesti. Se tarkoittaa, että verkko oppii tietyt kuviot kuvan sisällä ja pystyy tunnistamaan sen kaikkialla kuvassa.

Konvoluutio on alkuainekohtainen kertolasku. Konsepti on helppo ymmärtää. Tietokone skannaa osan kuvasta, jonka koko on yleensä 3 × 3, ja kertoo sen suodattimelle. Elementtikohtaisen kertolaskua kutsutaan piirrekartaksi. Tätä vaihetta toistetaan, kunnes koko kuva on skannattu. Huomaa, että konvoluution jälkeen kuvan koko pienenee.

Alla on URL-osoite, josta näet, miten konvoluutio toimii.

Tarjolla on lukuisia kanavia. Alla on lueteltu joitain kanavia. Voit nähdä, että jokaisella suodattimella on tietty tarkoitus. Huomaa, alla olevassa kuvassa; Kernel on suodattimen synonyymi.

Aritmetiikka konvoluution takana

Konvoluutiovaihe soveltaa suodatinta pieneen kuvapisteiden joukkoon. Suodatin liikkuu syötekuvaa pitkin muodoltaan 3×3 tai 5×5. Se tarkoittaa, että verkko liu'uttaa nämä ikkunat koko syöttökuvan yli ja laskee konvoluution. Alla oleva kuva näyttää kuinka konvoluutio toimii. Patch on kooltaan 3×3 ja ulostulomatriisi on tulosta kuvamatriisin ja suodattimen välisestä elementtikohtaisesta toiminnasta.

Huomaat, että tulosteen leveys ja korkeus voivat poiketa tulon leveydestä ja korkeudesta. Se tapahtuu rajaefektin takia.

Rajaefekti

Kuvassa on 5×5 kartta ja 3×3 suodatin. Keskellä on vain yksi ikkuna, jossa suodatin voi seuloa 3 × 3 -ruudukon. Tulostusominaisuuskartta kutistuu kahdella ruudulla 3 × 3 -ulottuvuuden ohella.

Jotta saat saman lähtömitan kuin syöttömitta, sinun on lisättävä täyte. Täyte sisältää oikean määrän rivejä ja sarakkeita lisäämällä matriisin kummallekin puolelle. Se mahdollistaa konvoluution keskittämisen jokaiseen syöteruutuun. Alla olevassa kuvassa tulo/lähtömatriisilla on samat mitat 5×5

Kun määrität verkon, konvoloituneita ominaisuuksia ohjataan kolmella parametrilla:

1. Syvyys: Se määrittää konvoluution aikana käytettävien suodattimien määrän. Edellisessä esimerkissä näit syvyyden 1, mikä tarkoittaa, että käytetään vain yhtä suodatinta. Useimmissa tapauksissa suodattimia on useampi kuin yksi. Alla oleva kuva näyttää toiminnot, jotka on tehty tilanteessa, jossa on kolme suodatinta

2. harppaus: Se määrittää "pikselin hyppyjen" määrän kahden viipaleen välillä. Jos askel on yhtä kuin 1, ikkunat liikkuvat pikselin erolla yksi. Jos askel on kaksi, ikkunat hyppäävät 2 pikseliä. Jos lisäät askelta, saat pienempiä karttakohteita.

Esimerkki askel 1

askel 2

3. Nolla-täyte: Täyte on toimenpide, jolla lisätään vastaava määrä rivejä ja sarakkeita syöttöominaisuuksien karttojen kummallekin puolelle. Tässä tapauksessa lähdöllä on sama mitta kuin tulolla.

Ei-lineaarisuus (ReLU)

Konvoluutiooperaation lopussa lähtöön kohdistuu aktivointitoiminto, joka sallii epälineaarisuuden. Tavallinen convnet-aktivointitoiminto on Relu. Kaikki negatiivisen arvon omaavat pikselit korvataan nollalla.

Pooling OperaTUKSEN

Tämä vaihe on helppo ymmärtää. Poolioinnin tarkoituksena on pienentää syötekuvan dimensioisuutta. Vaiheet tehdään toiminnan laskennallisen monimutkaisuuden vähentämiseksi. Mittasuhteita pienentämällä verkolla on pienemmät laskettavat painot, joten se estää ylisovituksen.

Tässä vaiheessa sinun on määritettävä koko ja askel. Tavallinen tapa yhdistää syötekuva on käyttää piirrekartan enimmäisarvoa. Katso alla olevaa kuvaa. "Pooling" näyttää 4 × 4 -ominaisuuskartan neljän alimatriisin ja palauttaa maksimiarvon. Poolitus ottaa 2 × 2 -taulukon enimmäisarvon ja siirtää sitten tätä ikkunaa kahdella pikselillä. Esimerkiksi ensimmäinen alimatriisi on [3,1,3,2], yhdistäminen palauttaa maksimiarvon, joka on 3.

On olemassa toinen yhdistämistoiminto, kuten keskiarvo.

Tämä toiminto pienentää aggressiivisesti karttakohdekartan kokoa

Täysin yhdistetyt kerrokset

Viimeinen vaihe koostuu perinteisen rakentamisesta keinotekoinen hermoverkko kuten teit edellisessä opetusohjelmassa. Yhdistät kaikki neuronit edellisestä kerroksesta seuraavaan kerrokseen. Käytät softmax-aktivointitoimintoa syöttökuvan numeron luokittelemiseen.

Kertaus:

TensorFlow-konvoluutiohermoverkko kokoaa eri kerroksia ennen ennusteen tekemistä. Neuroverkossa on:

• Konvoluutiokerros
• Relu aktivointitoiminto
• Pooling kerros
• Tiheästi yhdistetty kerros

Konvoluutiokerrokset käyttävät erilaisia ​​suodattimia kuvan alialueelle. Relu-aktivointitoiminto lisää epälineaarisuutta, ja yhdistävät tasot vähentävät piirrekarttojen ulottuvuutta.

Kaikki nämä kerrokset poimivat kuvista olennaisen tiedon. Viimeinkin piirrekartta syötetään ensisijaiseen täysin yhdistettyyn kerrokseen softmax-toiminnolla ennusteen tekemiseksi.

Harjoittele CNN:tä TensorFlow'lla

Nyt kun tunnet convnetsin rakennuspalikka, olet valmis rakentamaan sellaisen TensorFlow. Käytämme MNIST-tietojoukkoa CNN-kuvien luokitukseen.

Tietojen valmistelu on sama kuin edellisessä opetusohjelmassa. Voit suorittaa koodit ja siirtyä suoraan CNN:n arkkitehtuuriin.

Seuraa alla olevia vaiheita kuvien luokittelussa CNN:n avulla:

Vaihe 1: Lataa tietojoukko

Vaihe 2: Syötä kerros

Vaihe 3: Konvoluutiokerros

Vaihe 4: Pooling kerros

Vaihe 5: Toinen konvoluutiokerros ja Pooling Kerros

Vaihe 6: Tiheä kerros

Vaihe 7: Logit Layer

Vaihe 1: Lataa tietojoukko

MNIST-tietojoukko on saatavana scikitillä, jotta voit oppia tästä URL. Lataa se ja tallenna se Lataukset-kansioon. Voit ladata sen komennolla fetch_mldata('MNIST original').

Luo juna/testisarja

Sinun on jaettava tietojoukko komennolla train_test_split

Skaalaa ominaisuuksia

Lopuksi voit skaalata ominaisuuden MinMaxScalerilla alla olevan kuvaluokituksen mukaisesti käyttämällä TensorFlow CNN -esimerkkiä.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_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 )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_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äärittele CNN

CNN käyttää suodattimia kuvan raakapikselissä oppiakseen yksityiskohtia kuviosta verrattuna perinteisen hermoverkon globaaliin kuvioon. CNN:n rakentamiseksi sinun on määritettävä:

1. Konvoluutiotaso: Käytä karttaan n määrää suodattimia. Konvoluution jälkeen sinun on käytettävä Relu-aktivointitoimintoa lisätäksesi verkkoon epälineaarisuutta.
2. Pooling-kerros: Seuraava vaihe konvoluution jälkeen on ominaisuuden max. Tarkoituksena on pienentää piirrekartan ulottuvuutta ylisovituksen estämiseksi ja laskentanopeuden parantamiseksi. Max pooling on perinteinen tekniikka, joka jakaa karttakohdekartat osa-alueisiin (yleensä 2×2-koon) ja säilyttää vain enimmäisarvot.
3. Täysin yhdistetyt kerrokset: Kaikki edellisten kerrosten neuronit on kytketty seuraaviin kerroksiin. CNN luokittelee etiketin konvoluutiokerrosten ominaisuuksien mukaan ja vähennetään yhdistämiskerroksella.

CNN-arkkitehtuuri

• Konvoluutiokerros: Käyttää 14 5×5 suodatinta (poimii 5×5 pikselin alialueita) ReLU-aktivointitoiminnolla
• Pooling Taso: Suorittaa maksimipoolauksen 2×2-suodattimella ja askeleella 2 (mikä määrittää, että yhdistetyt alueet eivät mene päällekkäin)
• Convolution Layer: Käyttää 36 5×5 suodatinta ReLU-aktivointitoiminnolla
• Pooling Kerros #2: Suorittaa jälleen maksimipoolauksen 2 × 2 -suodattimella ja askeleella 2
• 1,764 0.4 hermosolua, pudotuksen säännöstelyaste 0.4 (todennäköisyys XNUMX, että jokin tietty elementti pudotetaan harjoituksen aikana)
• Tiheä kerros (Logits Layer): 10 neuronia, yksi kutakin kohdeluokkaa kohden (0–9).

CNN:n luomiseen on käytettävä kolme tärkeää moduulia:

• conv2d(). Muodostaa kaksiulotteisen konvoluutiokerroksen, jossa on argumenteina suodattimien määrä, suodattimen ydin, täyte ja aktivointifunktio.
• max_pooling2d(). Muodostaa kaksiulotteisen poolauskerroksen käyttämällä max pooling -algoritmia.
• tiheä(). Rakentaa tiheän kerroksen piilotetuilla kerroksilla ja yksiköillä

Määrität funktion CNN:n rakentamiseksi. Katsotaanpa yksityiskohtaisesti, kuinka jokainen rakennuspalikka rakennetaan ennen kuin kääritään kaikki yhteen funktioon.

Vaihe 2: Syötä 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 mukaan. Tätä varten voit käyttää moduulia tf.reshape. Tässä moduulissa sinun on ilmoitettava tensori uudelleen muotoiltavaksi ja tensorin muoto. Ensimmäinen argumentti on datan ominaisuudet, joka määritellään funktion argumentissa.

Kuvalla on korkeus, leveys ja kanava. MNIST-tietojoukko on yksikrooninen kuva, jonka koko on 28 × 28. Asetamme erän kooksi muoto-argumentissa -1, jotta se ottaa piirteiden ["x"] muodon. Etuna on tehdä eräkoon hyperparametreja viritettäväksi. Jos erän kooksi on asetettu 7, tensori syöttää 5,488 28 arvoa (28 * 7 * XNUMX).

Vaihe 3: Konvoluutiokerros

# first Convolutional Layer
  conv1 = 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 ydin on kooltaan 5 × 5 ja samalla täyte. Sama täyte tarkoittaa, että sekä lähtötensorilla että tulotensorilla tulee olla sama korkeus ja leveys. Tensorflow lisää nollia riveihin ja sarakkeisiin varmistaakseen saman koon.

Käytät Relu-aktivointitoimintoa. Tulosteen koko on [28, 28, 14].

Vaihe 4: Pooling kerros

Seuraava vaihe konvoluution jälkeen on poolauslaskenta. Poolilaskenta vähentää tietojen ulottuvuutta. Voit käyttää moduulia max_pooling2d, jonka koko on 2×2 ja stride 2. Käytät syötteenä edellistä kerrosta. Tulostuskoko on [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Vaihe 5: Toinen konvoluutiokerros ja Pooling Kerros

Toisessa konvoluutiokerroksessa on 32 suodatinta, joiden lähtökoko on [batch_size, 14, 14, 32]. Poolauskerros on samankokoinen kuin ennen ja tulosteen muoto on [erän_koko, 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 yhdistetty kerros. Piirrekartta on tasoitettava ennen kuin se yhdistetään tiheään kerrokseen. Voit käyttää moduulin uudelleenmuotoilua koossa 7*7*36.

Tiheä kerros yhdistää 1764 neuronia. Lisäät Relu-aktivointitoiminnon. Lisäksi lisäät keskeyttämisen tasoitustermin 0.3 prosentilla, mikä tarkoittaa, että 30 prosenttia painoista asetetaan nollaan. Huomaa, että keskeyttäminen tapahtuu vain harjoitusvaiheessa. Funktiolla cnn_model_fn on argumenttitila, joka ilmoittaa, tarvitseeko mallia harjoitella tai arvioida, kuten alla olevassa CNN-kuvaluokituksen TensorFlow-esimerkissä on esitetty.

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 TensorFlow-kuvan luokitteluesimerkissä voit määrittää viimeisen kerroksen mallin ennusteella. Tulostusmuoto on yhtä suuri kuin eräkoko ja 10, kuvien kokonaismäärä.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Voit luoda sanakirjan, joka sisältää luokat ja kunkin luokan todennäköisyyden. Moduuli tf.argmax() palauttaa suurimman arvon, jos logit kerrostuu. 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 tilaksi on asetettu ennakointi. Lisäät nämä koodit näyttääksesi ennusteet

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

Seuraava vaihe on mallin häviön laskeminen. Viimeisessä opetusohjelmassa opit, että moniluokkaisen mallin häviöfunktio on ristientropia. Tappio on helppo laskea seuraavalla koodilla:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

TensorFlow CNN -esimerkin viimeinen vaihe on mallin optimointi, eli painojen parhaiden arvojen löytäminen. Tätä varten käytät gradientin laskeutumisoptimointiohjelmaa, jonka oppimisnopeus on 0.001. Tavoitteena on minimoida tappiot

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. Moniluokkaisen mallin suorituskykymittarit ovat tarkkuusmittarit. Tensorflow on varustettu moduulin tarkkuudella kahdella argumentilla, otsikoilla ja ennusteilla.

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:si ja olet valmis käärimään kaiken funktioksi, jotta voit käyttää sitä mallin kouluttamiseen ja arviointiin.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  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)

  # Dense Layer
  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.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = 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 Loss
  loss = 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 mode
  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)

Alla olevat vaiheet ovat samat kuin edellisissä opetusohjelmissa.

Ensinnäkin määrität estimaattorin CNN-mallilla kuvien luokittelua varten.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

CNN:n harjoitteleminen kestää monta kertaa, joten luot kirjauskoukun, joka tallentaa softmax-kerrosten arvot 50 iteroinnin välein.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Olet valmis arvioimaan mallin. Asetat erän kooksi 100 ja sekoitat tiedot. Huomaa, että asetamme harjoitusaskeleiksi 16.000 XNUMX, joten harjoittelu voi viedä paljon aikaa. Ole kärsivällinen.

# Train the model
train_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 koulutettu, voit arvioida sen ja tulostaa tulokset

# Evaluate the model and print results
eval_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:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO: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 %:n tarkkuuden. Voit muuttaa arkkitehtuuria, eräkokoa ja iterointien määrää tarkkuuden parantamiseksi. CNN-hermoverkko on toiminut paljon paremmin kuin ANN tai logistinen regressio. Keinotekoisen hermoverkon opetusohjelmassa sinulla oli 96 %:n tarkkuus, mikä on pienempi kuin CNN. CNN:n esitykset ovat vaikuttavia suuremmalla kuvalla setti, sekä nopeuden laskennan että tarkkuuden suhteen.

Yhteenveto

Konvoluutiohermoverkko toimii erittäin hyvin kuvan arvioinnissa. Tämäntyyppinen arkkitehtuuri on hallitseva tunnistamaan esineitä kuvasta tai videosta.

TensorFlow CNN:n rakentamiseksi sinun on noudatettava seitsemän vaihetta:

Vaihe 1: Lataa tietojoukko:

MNIST-tietojoukko on saatavilla scikitillä oppimista varten. Lataa se ja tallenna se Lataukset-kansioon. Voit ladata sen komennolla fetch_mldata('MNIST original').

Vaihe 2: Syöttötaso:

Tämä vaihe muokkaa tiedot. Muoto on yhtä suuri kuin pikselien lukumäärän neliöjuuri. Esimerkiksi, jos kuvassa on 156 pikseliä, muoto on 26 × 26. Sinun on määritettävä, onko kuva värillinen vai ei. Jos kyllä, sinulla oli 3 muotoon - 3 RGB:lle, muuten 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Vaihe 3: Konvoluutiokerros

Seuraavaksi sinun on luotava konvoluutiokerrokset. Käytät erilaisia ​​suodattimia, jotta verkko oppii tärkeän ominaisuuden. Voit määrittää 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 4: Pooling kerros

Kolmannessa vaiheessa lisäät poolauskerroksen. Tämä kerros pienentää syötteen kokoa. Se tekee sen ottamalla alimatriisin maksimiarvon. Jos alimatriisi on esimerkiksi [3,1,3,2], yhdistäminen palauttaa maksimiarvon, joka on 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Vaihe 5: Lisää konvoluutiokerros ja Pooling Kerros

Tässä vaiheessa voit lisätä niin paljon kuin haluat konv-tasoja ja poolaustasoja. Google käyttää arkkitehtuuria, jossa on yli 20 konversiotasoa.

Vaihe 6: Tiheä kerros

Vaihe 6 tasoittaa edellistä luodaksesi täysin yhdistetyt tasot. Tässä vaiheessa voit käyttää eri aktivointitoimintoja ja lisätä dropout-efektin.

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

Viimeinen vaihe on ennustaminen.

logits = tf.layers.dense(inputs=dropout, units=10)