CNN-kuvan luokittelu TensorFlow'ssa vaiheineen ja esimerkein

Mikä on konvoluutiohermoverkko?

Konvoluutiohermoverkko, joka tunnetaan myös nimellä convnet tai CNN, on tunnettu menetelmä konenäön sovelluksissa. Se on syvien neuroverkkojen luokka, joita käytetään visuaalisten kuvien analysointiin. Tämän tyyppinen arkkitehtuuri on hallitseva kohteiden tunnistamisessa kuvasta tai videosta. Sitä käytetään sovelluksissa, kuten kuvan- tai videontunnistuksessa, luonnollisen kielen käsittelyssä ja suosittelujärjestelmissä.

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 konvnet-arkkitehtuuri voidaan tiivistää alla olevaan kuvaan. Ensinnäkin kuva lähetetään verkkoon; tätä kutsutaan syötekuvaksi. Sitten syötekuva käy läpi sarjan vaiheita; tämä on verkon konvoluutio-osa. Lopuksi neuroverkko voi ennustaa kuvan numeron.

Kuva koostuu pikselimatriisista, joilla on korkeus ja leveys. Harmaasävykuvassa on vain yksi kanava, kun taas värikuvassa on kolme kanavaa (jokainen punaiselle, vihreälle ja siniselle). Kanavat ovat päällekkäin. Tässä opetusohjelmassa käytät harmaasävykuvaa, jossa on vain yksi kanava. Jokaisella pikselillä on arvo 0–255, joka heijastaa värin intensiteettiä. Esimerkiksi pikseli, jonka arvo on 0, näyttää valkoisen värin, kun taas pikseli, jonka arvo on lähellä 255, on tummempi.

Katsotaanpa kuvaa, joka on tallennettu MNIST-tietojoukkoAlla oleva kuva näyttää, miten vasemmalla oleva kuva esitetään matriisimuodossa. Huomaa, että alkuperäinen matriisi on standardoitu arvoksi 0–1. Tummemmilla väreillä matriisin arvo on noin 0.9, kun taas valkoisten pikselien arvo on 0.

Konvoluutiotoiminta

Mallin kriittisin komponentti on konvoluutiokerros. Tämän osan tavoitteena on pienentää kuvan kokoa painojen nopeampaa laskentaa ja yleistyksen parantamista varten.

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 selvittääkseentracvain olennaisimpia pikseleitä. Tätä matemaattista operaatiota kutsutaan konvoluutioksi. Tämä tekniikka mahdollistaa verkon oppia yhä monimutkaisempia ominaisuuksia jokaisella tasolla. Konvoluutio jakaa matriisin pieniin osiin oppiakseen kunkin osan olennaisimmat elementit.

Konvoluutiohermoverkon komponentit (ConvNet tai CNN)

Konvnetissä on neljä osaa:

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

Kierre

Konvoluution tarkoituksena on selvittäätract kuvassa olevan kohteen ominaisuuksia paikallisesti. Tämä tarkoittaa, että verkko oppii kuvan tietyt kuviot ja pystyy tunnistamaan ne kaikkialla kuvassa.

Konvoluutio on elementtikohtainen kertolasku. Käsite on helppo ymmärtää. Tietokone skannaa osan kuvasta, yleensä 3×3-ulotteisen osan, ja kertoo sen suodattimella. Elementtikohtaisen kertolaskun tulosta kutsutaan ominaisuuskartaksi. Tätä vaihetta toistetaan, kunnes koko kuva on skannattu. Huomaa, että konvoluution jälkeen kuvan kokoa pienennetään.

Alla oleva kaavio näyttää, kuinka yksi kuvan osa kerrotaan suodattimella, jolloin saadaan yksi ominaisuuskartan solu.

Alla oleva animaatio näyttää saman konvoluution koko kuvan poikki.

Saatavilla on lukuisia suodattimia. Alla on lueteltu joitakin niistä. Näet, että jokaisella suodattimella on tietty tarkoitus. Huomaa, että alla olevassa kuvassa ydin on suodattimen synonyymi.

Aritmetiikka konvoluution takana

Konvoluutiovaiheessa suodatinta käytetään pieneen kuvassa olevaan pikseliryhmään. Suodatin liikkuu syötekuvaa pitkin yleisessä 3×3- tai 5×5-muodossa. Tämä tarkoittaa, että verkko liu'uttaa näitä ikkunoita koko syötekuvan yli ja laskee konvoluution. Alla oleva animaatio näyttää, miten konvoluutio toimii. Paikan koko on 3×3, ja tulosmatriisi on kuvamatriisin ja suodattimen välisen elementtikohtaisen toiminnan tulos.

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

Rajaefekti

Kuvassa on 5×5-kokoinen ominaisuuskartta ja 3×3-suodin. Keskellä on vain yksi ikkuna, jossa suodin voi seuloa 3×3-ruudukon. Tulosteessa oleva ominaisuuskartta kutistuu kahdella ruudulla kummallakin akselilla, jolloin jäljelle jää 3×3-ulottuvuus.

Saadaksesi saman ulostulomitan kuin syötemitan, sinun on lisättävä täyttöä. Täyttö tarkoittaa oikean määrän rivien ja sarakkeiden lisäämistä matriisin kummallekin puolelle. Se mahdollistaa konvoluution sovittaa jokaisen syötelaatan keskelle. Alla olevassa kuvassa syöte- ja tulosmatriiseilla on sama ulottuvuus, 5×5.

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

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

Askel: Se määrittää kahden viipaleen välisten "pikselihyppyjen" määrän. Jos askel on 1, ikkuna liikkuu yhden pikselin verran. Jos askel on kaksi, ikkuna hyppää 2 pikseliä. Jos askelta lisätään, ominaisuuskartat pienenevät. Alla olevat kaksi kaaviota vertaavat askelta 1 ja askelta 2.

Esimerkki askel 1

askel 2

Nollatäyttö: Täydennys on operaatio, jossa syötekarttojen kummallekin puolelle lisätään vastaava määrä rivejä ja sarakkeita. Tässä tapauksessa tulosteella on sama ulottuvuus kuin syötteellä.

Ei-lineaarisuus (ReLU)

Konvoluutiooperaation lopussa lähtöön sovelletaan aktivointifunktiota epälineaarisuuden mahdollistamiseksi. Tavanomainen konvnetin aktivointifunktio on ReLU. Kaikki negatiivisen arvon omaavat pikselit korvataan nollalla.

Pooling OperaTUKSEN

Tämä vaihe on helppo ymmärtää. Yhdistämisen tarkoituksena on vähentää syötekuvan dimensionaalisuutta. Vaiheet tehdään operaation laskennallisen monimutkaisuuden vähentämiseksi. Dimensionaalisuuden pienentämisen myötä verkossa on vähemmän laskettavia painoja, mikä estää ylisovituksen.

Tässä vaiheessa sinun on määriteltävä koko ja askelmäärä. Yleinen tapa yhdistää syötekuva on käyttää ominaisuuskartan maksimiarvoa. Katso alla olevaa kuvaa. Yhdistäminen seuloo neljä alimatriisia 4×4-ominaisuuskartasta ja palauttaa maksimiarvon. Yhdistäminen ottaa 2×2-taulukon maksimiarvon ja siirtää sitten tätä ikkunaa kahdella pikselillä. Esimerkiksi ensimmäinen alimatriisi on [3,1,3,2], joten yhdistäminen palauttaa maksimiarvon, joka on 3.

On olemassa toinen yhdistämistoiminto, kuten keskiarvo.

Tämä toiminto pienentää ominaisuuskartan kokoa merkittävästi.

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 tasoja ennen ennusteen tekemistä. Hermoverkolla on:

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

Konvoluutiokerrokset käyttävät erilaisia ​​suodattimia kuvan alialueille. ReLU-aktivointifunktio lisää epälineaarisuutta ja yhdistävät kerrokset vähentävät ominaisuuskarttojen dimensionaalisuutta.

Kaikki nämä kerrokset esim.tracKuvista saatavat olennaiset tiedot. Lopuksi ominaisuuskartat syötetään täysin yhdistetylle tasolle, jossa käytetään softmax-funktiota ennusteen tekemiseksi.

Harjoittele CNN:tä TensorFlow'lla

Nyt kun olet perehtynyt convnetin rakennuspalikoihin, 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:

1. Vaihe 1: Lataa tietojoukko
2. Vaihe 2: Syötä kerros
3. Vaihe 3: Konvoluutiokerros
4. Vaihe 4: Pooling kerros
5. Vaihe 5: Toinen konvoluutiokerros ja Pooling Kerros
6. Vaihe 6: Tiheä kerros
7. Vaihe 7: Logit Layer

Versiohuomautus: Alla olevat listaukset koskevat TensorFlow 1.x:ää. TensorFlow 2:ssa tf.layers-nimiavaruutta ja tf.estimator.inputs.numpy_input_fn:ää ei enää ole; vastineet ovat tf.keras.layers.Conv2D, MaxPooling2D, Dense ja Dropout koottu tf.keras.Model-tiedostoon ja koulutettu model.fit()-funktiolla. Lue kunkin tason mekaniikan vaiheet ja yhdistä ne sitten Keras-rajapintaan.

Vaihe 1: Lataa tietojoukko

MNIST-aineisto on saatavilla scikit-learnin kautta. Lataa se ja tallenna se Lataukset-kansioon. Voit ladata sen palvelimelle komennolla fetch_mldata('MNIST original').

Versiohuomautus: mldata.org on suljettu ja fetch_mldata() on poistettu scikit-learn 0.22 -versiosta. Lataa samat numerot missä tahansa nykyisessä asennuksessa seuraavasti: hae_openml sen sijaan käytetään fetch_openml('mnist_784', version=1). Loput prosessista pysyvät muuttumattomina.

Luo juna/testisarja

Sinun täytyy jakaa tietojoukko train_test_split-metodilla.

Skaalaa ominaisuuksia

Lopuksi voit skaalata ominaisuuksia MinMaxScalerilla, kuten alla olevassa kuvaluokittelussa on esitetty TensorFlow CNN -esimerkin avulla.

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 raakapikseleissä oppiakseen yksityiskohtien kuvioita verrattuna perinteisen neuroverkon oppimiin globaaleihin kuvioihin. CNN:n rakentamiseksi sinun on määriteltävä:

1. Konvoluutiokerros: Käytä n suodatinta ominaisuuskartassa. Konvoluution jälkeen sinun on käytettävä ReLU-aktivointifunktiota lisätäksesi verkkoon epälineaarisuuden.
2. Pooling-kerros: Konvoluution jälkeen seuraava vaihe on ominaisuuskartan alasnäytteistäminen. Tarkoituksena on pienentää ominaisuuskartan dimensionaalisuutta ylisovituksen estämiseksi ja laskentanopeuden parantamiseksi. Maksimaalinen yhdistäminen on perinteinen tekniikka, jossa ominaisuuskartat jaetaan alialueisiin (yleensä 2×2-koolla) ja säilytetään vain maksimiarvot.
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 (esim.trac5×5 pikselin alialueiden muodostaminen), 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äärittelet funktion CNN:n rakentamiseksi. Katsotaanpa yksityiskohtaisesti, miten kukin rakennuspalikka rakennetaan ennen rivitystä.ping kaikki yhdessä funktiossa.

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-datajoukko on yksivärinen kuva, jonka koko on 28 × 28. Asetamme erän kooksi muoto-argumentissa -1, jotta se ottaa ominaisuuksien muodon ["x"]. Etuna on, että erän koosta tulee viritettävä hyperparametri. Jos erän kooksi asetetaan 7, tensori syöttää 5 488 arvoa (28 * 28 * 7).

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 ytimen koko on 5×5 ja täyttö on sama. Sama täyttö tarkoittaa, että sekä lähtö- että syöttötensorilla tulee olla sama korkeus ja leveys. TensorFlow lisää riveille ja sarakkeille nollia varmistaakseen saman koon.

Käytät ReLU-aktivointifunktiota. Tulosteen koko on [28, 28, 14].

Vaihe 4: Pooling kerros

Konvoluution jälkeen seuraava vaihe on yhdistämislaskenta. Yhdistämislaskenta vähentää datan dimensionaalisuutta. Voit käyttää moduulia max_pooling2d, jonka koko on 2×2 ja stride-arvo 2. Käytät edellistä tasoa syötteenä. Tulosteen koko 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

Toinen konvoluutiokerros käyttää 36 suodatinta, jolloin tulostekooksi saadaan [batch_size, 14, 14, 36]. Yhdistämiskerros käyttää samaa 2×2-ikkunaa ja 2:n askelta kuin aiemmin, joten se puolittaa jokaisen spatiaalisen akselin ja tulostemuodosta tulee [batch_size, 7, 7, 36].

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ääriteltävä täysin yhdistetty taso. Ominaisuuskartta on litistettävä ennen sen yhdistämistä tiheään tasoon. Voit käyttää moduulin uudelleenmuotoilua koossa 7*7*36.

Tiheä kerros yhdistää 1 764 neuronia. Lisäät ReLU-aktivointifunktion. Lisäksi lisäät keskeyttämisregularisointitermin, jonka arvo on 0.3, mikä tarkoittaa, että 30 prosenttia aktivoinneista asetetaan arvoon 0. Huomaa, että keskeyttäminen tapahtuu vain koulutusvaiheen aikana. Funktiolla cnn_model_fn on argumenttitila, jolla määritetään, tarvitseeko mallia kouluttaa vai arvioida, kuten alla olevassa CNN-kuvien luokittelun 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-kuvanluokitteluesimerkissä voit määrittää viimeisen tason mallin ennusteella. Tulosteen muoto on yhtä suuri kuin erän koko ja 10, kohdeluokkien 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. Funktio tf.argmax() palauttaa logits-kerroksen suurimman arvon indeksin. 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 ennustesanakirjan vain, kun tilaksi on asetettu ennustus. Lisää tämä koodi ennusteiden näyttämiseksi.

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

Seuraava vaihe koostuu mallin häviön laskemisesta. Edellisessä tutoriaalissa opit, että moniluokkaisen mallin häviöfunktio on ristientropia. Häviö lasketaan helposti 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äytetään gradienttilaskeutumisoptimointia, jonka oppimisnopeus on 0.001. Tavoitteena on minimoida hävikki.

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 arviointitilassa. Moniluokkaisen mallin suorituskykymittari on tarkkuus. TensorFlow on varustettu tarkkuusmoduulilla, joka ottaa vastaan ​​kaksi argumenttia: otsikot 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: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)

Huomautus kootusta toiminnosta: Yllä oleva kääritty versio asettaa ensimmäisen konvoluutiokerroksen arvoon 32 suodatinta ja pudotuksen arvoon 0.4, kun taas vaiheittaiset koodinpätkät käyttävät 14 suodatinta ja 0.3. Molemmat toimivat, mutta valitse yksi arvopari ja pidä se yhtenäisenä, jotta tulostetut muodot vastaavat kerrostaulukkoa.

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 kouluttaminen vie kauan, joten luot lokikirjauskoukun, joka tallentaa softmax-kerrosten arvot 50 iteraation 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 mallia. Asetat erän kooksi 100 ja sekoitat tiedot. Huomaa, että asetamme koulutusaskeleiden määräksi 16 000, minkä kouluttaminen 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 sitä 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)

Arviointi tulostaa palautetun tarkistuspisteen, vaiheen, johon se pysähtyi, ja lopullisen mittariluettelon.

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 arviointisanakirja raportoi tarkkuudeksi 0.9689286 eli noin 97 %. Voit muuttaa arkkitehtuuria, erän kokoa ja iteraatioiden määrää tarkkuuden parantamiseksi. CNN on suoriutunut paljon paremmin kuin keinotekoinen hermoverkko tai logistinen regressio: tekoälyverkkoja käsittelevässä tutoriaalissa tarkkuus oli 96 %, mikä on alhaisempi kuin CNN:llä. CNN:n suorituskyky on vaikuttava suuremmalla kuvajoukolla sekä laskentanopeuden että tarkkuuden suhteen.

UKK