Klasifikacija CNN slike u TensorFlowu s koracima i primjerima

Što je konvolucijska neuronska mreža?

Konvolucijska neuronska mreža, također poznat kao convnets ili CNN, dobro je poznata metoda u primjenama računalnog vida. To je klasa dubokih neuronskih mreža koje se koriste za analizu vizualnih slika. Ova vrsta arhitekture dominantna je za prepoznavanje objekata sa slike ili videa. Koristi se u aplikacijama poput prepoznavanja slika ili videa, obrade prirodnog jezika i sustava preporuka.

Archistruktura konvolucijske neuronske mreže

Sjetite se Facebooka prije nekoliko godina, nakon što ste prenijeli sliku na svoj profil, od vas se tražilo da ručno dodate ime licu na slici. Danas Facebook koristi convnet za automatsko označavanje vašeg prijatelja na slici.

Konvolucijska neuronska mreža za klasifikaciju slika nije teško razumjeti. Ulazna slika se obrađuje tijekom faze konvolucije i kasnije joj se pripisuje oznaka.

Tipična arhitektura convnet mreže može se sažeti na slici ispod. Prvo se slika šalje mreži; to se naziva ulazna slika. Zatim ulazna slika prolazi kroz niz koraka; to je konvolucijski dio mreže. Konačno, neuronska mreža može predvidjeti znamenku na slici.

Slika se sastoji od niza piksela s visinom i širinom. Slika u sivim tonovima ima samo jedan kanal, dok slika u boji ima tri kanala (svaki za crvenu, zelenu i plavu). Kanali su naslagani jedan preko drugog. U ovom vodiču koristit ćete sliku u sivim tonovima s jednim kanalom. Svaki piksel ima vrijednost od 0 do 255 kako bi odražavao intenzitet boje. Na primjer, piksel jednak 0 prikazivat će bijelu boju, dok će piksel s vrijednošću blizu 255 biti tamniji.

Pogledajmo sliku pohranjenu u MNIST skup podatakaDonja slika prikazuje kako prikazati sliku lijevo u matričnom formatu. Imajte na umu da je izvorna matrica standardizirana da bude između 0 i 1. Za tamnije boje, vrijednost u matrici je oko 0.9, dok bijeli pikseli imaju vrijednost 0.

Konvolucijska operacija

Najkritičnija komponenta u modelu je konvolucijski sloj. Ovaj dio ima za cilj smanjenje veličine slike radi bržeg izračuna težina i poboljšanja generalizacije.

Tijekom konvolucijskog dijela, mreža zadržava bitne značajke slike i isključuje nebitan šum. Na primjer, model uči kako prepoznati slona na slici s planinom u pozadini. Ako koristite tradicionalnu neuronsku mrežu, model će dodijeliti težinu svim pikselima, uključujući one s planine, što nije bitno i može zavarati mrežu.

Umjesto toga, a Keras konvolucijska neuronska mreža koristit će matematičku tehniku ​​za objašnjenjetracsamo najrelevantnije piksele. Ova matematička operacija naziva se konvolucija. Ova tehnika omogućuje mreži da uči sve složenije značajke na svakom sloju. Konvolucija dijeli matricu na male dijelove kako bi se naučili najvažniji elementi unutar svakog dijela.

Komponente konvolucijske neuronske mreže (ConvNet ili CNN)

Konvertibilna mreža ima četiri komponente:

1. saziv
2. Nelinearnost (ReLU)
3. Pooling ili poduzorkovanje
4. Klasifikacija (potpuno povezani sloj)

saziv

Svrha konvolucije je objasnititraclokalno prepoznaje značajke objekta na slici. To znači da će mreža naučiti specifične uzorke unutar slike i moći će ih prepoznati svugdje na slici.

Konvolucija je množenje po elementima. Koncept je lako razumjeti. Računalo će skenirati dio slike, obično dimenzije 3 × 3, i množiti ga filterom. Izlaz množenja po elementima naziva se mapa značajki. Ovaj se korak ponavlja sve dok se ne skenira cijela slika. Imajte na umu da se nakon konvolucije veličina slike smanjuje.

Donji dijagram prikazuje jedan dio slike koji se množi filterom kako bi se dobila jedna ćelija mape značajki.

Animacija ispod prikazuje istu konvoluciju koja se proteže preko cijele slike.

Dostupni su brojni filteri. U nastavku smo naveli neke od njih. Možete vidjeti da svaki filter ima određenu svrhu. Imajte na umu da je na slici ispod jezgra sinonim za filter.

Aritmetika iza konvolucije

Konvolucijska faza će primijeniti filter na mali niz piksela unutar slike. Filter će se pomicati duž ulazne slike općeg oblika 3×3 ili 5×5. To znači da će mreža pomicati ove prozore preko cijele ulazne slike i izračunati konvoluciju. Animacija u nastavku prikazuje kako konvolucija funkcionira. Veličina područja je 3×3, a izlazna matrica je rezultat operacije po elementima između matrice slike i filtera.

Primjećujete da se širina i visina izlaza mogu razlikovati od širine i visine ulaza. To se događa zbog efekta granice.

Efekt granice

Slika ima mapu značajki 5×5 i filter 3×3. U sredini se nalazi samo jedan prozor gdje filter može prikazati mrežu 3×3. Izlazna mapa značajki smanjuje se za dvije pločice na svakoj osi, ostavljajući dimenziju 3×3.

Da biste dobili istu izlaznu dimenziju kao i ulaznu dimenziju, potrebno je dodati popunjavanje. Popunjavanje se sastoji od dodavanja odgovarajućeg broja redaka i stupaca sa svake strane matrice. To će omogućiti konvoluciji da centrira svaku ulaznu pločicu. Na slici ispod, ulazna i izlazna matrica imaju istu dimenziju, 5×5.

Kada definirate mrežu, konvolvirane značajke kontroliraju tri parametra:

Dubina: Definira broj filtera koji će se primijeniti tijekom konvolucije. U prethodnom primjeru vidjeli ste dubinu od 1, što znači da se koristi samo jedan filter. U većini slučajeva postoji više od jednog filtera. Animacija u nastavku prikazuje operacije izvedene u situaciji s tri filtera.

Korak: Definira broj "skokova piksela" između dva sloja. Ako je korak jednak 1, prozor će se pomicati s rasponom piksela od jedan. Ako je korak jednak dva, prozor će skočiti za 2 piksela. Ako povećate korak, imat ćete manje mape značajki. Dva dijagrama u nastavku uspoređuju korak od 1 s korakom od 2.

Primjer koraka 1

korak 2

Nula-popuna: Dopunjavanje je operacija dodavanja odgovarajućeg broja redaka i stupaca sa svake strane ulaznih mapa značajki. U ovom slučaju, izlaz ima istu dimenziju kao i ulaz.

Nelinearnost (ReLU)

Na kraju operacije konvolucije, izlaz je podložan aktivacijskoj funkciji kako bi se omogućila nelinearnost. Uobičajena aktivacijska funkcija za konvoluciju je ReLU. Svi pikseli s negativnom vrijednošću bit će zamijenjeni nulom.

Pooling OperaANJE

Ovaj korak je lako razumjeti. Svrha grupiranja je smanjenje dimenzionalnosti ulazne slike. Koraci se provode kako bi se smanjila računalna složenost operacije. Smanjenjem dimenzionalnosti, mreža ima manje težina za izračunati, pa se sprječava prekomjerno prilagođavanje.

U ovoj fazi morate definirati veličinu i korak. Standardni način objedinjavanja ulazne slike je korištenje maksimalne vrijednosti mape značajki. Pogledajte sliku ispod. Objedinjavanje će prikazati četiri podmatrice mape značajki 4×4 i vratiti maksimalnu vrijednost. Objedinjavanje uzima maksimalnu vrijednost niza 2×2, a zatim pomiče ovaj prozor za dva piksela. Na primjer, prva podmatrica je [3,1,3,2], pa će objedinjavanje vratiti maksimum, koji je 3.

Postoji još jedna operacija udruživanja kao što je srednja vrijednost.

Ova operacija agresivno smanjuje veličinu mape značajki.

Potpuno povezani slojevi

Posljednji korak sastoji se od izgradnje tradicionalnog umjetna neuronska mreža kao što ste učinili u prethodnom vodiču. Povezujete sve neurone iz prethodnog sloja sa sljedećim slojem. Koristite softmax aktivacijsku funkciju za klasificiranje broja na ulaznoj slici.

Rekapitulacija:

TensorFlow konvolucijska neuronska mreža sastavlja različite slojeve prije nego što napravi predviđanje. Neuronska mreža ima:

• Konvolucijski sloj
• ReLU aktivacijska funkcija
• Pooling sloj
• Gusto povezani sloj

Konvolucijski slojevi primjenjuju različite filtere na podregiju slike. ReLU aktivacijska funkcija dodaje nelinearnost, a slojevi združivanja smanjuju dimenzionalnost mapa značajki.

Svi ovi slojevi extracbitne informacije sa slika. Na kraju se mape značajki šalju potpuno povezanom sloju s softmax funkcijom kako bi se napravilo predviđanje.

Uvježbajte CNN uz TensorFlow

Sada kada ste upoznati s gradivnim blokovima convnet mreže, spremni ste je izgraditi pomoću TensorFlow. Koristit ćemo skup podataka MNIST za CNN klasifikaciju slika.

Priprema podataka je ista kao u prethodnom vodiču. Možete pokrenuti kodove i skočiti izravno na arhitekturu CNN-a.

Za klasifikaciju slika pomoću CNN-a slijedit ćete korake u nastavku:

1. Korak 1: Prenesite skup podataka
2. Korak 2: Ulazni sloj
3. Korak 3: Konvolucijski sloj
4. Korak 4: Pooling sloj
5. Korak 5: Drugi konvolucijski sloj i Pooling Sloj
6. Korak 6: Gusti sloj
7. Korak 7: Logit sloj

Napomena o verziji: Donji popisi ciljaju TensorFlow 1.x. U TensorFlowu 2 imenski prostor tf.layers i tf.estimator.inputs.numpy_input_fn više ne postoje; ekvivalenti su tf.keras.layers.Conv2D, MaxPooling2D, Dense i Dropout sastavljeni u tf.keras.Model i trenirani s model.fit(). Pročitajte korake za mehaniku svakog sloja, a zatim ih mapirajte na Keras API.

Korak 1: Prenesite skup podataka

Skup podataka MNIST dostupan je putem scikit-learn. Preuzmite ga i pohranite u Preuzimanja. Možete ga prenijeti pomoću fetch_mldata('MNIST original').

Napomena o verziji: mldata.org je zatvoren i fetch_mldata() je uklonjen u scikit-learn verziji 0.22. Na bilo kojoj trenutnoj instalaciji, učitajte iste znamenke s fetch_openml umjesto toga, koristi se fetch_openml('mnist_784', version=1). Ostatak cjevovoda ostaje nepromijenjen.

Stvorite set vlakova/testiranja

Skup podataka morate podijeliti pomoću train_test_split.

Skalirajte značajke

Konačno, možete skalirati značajke pomoću MinMaxScalera kao što je prikazano na donjoj klasifikaciji slike koristeći primjer TensorFlow CNN-a.

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:]

Definirajte CNN

CNN koristi filtere na sirovim pikselima slike kako bi naučio uzorke detalja u usporedbi s globalnim uzorcima koje je naučila tradicionalna neuronska mreža. Za konstrukciju CNN-a potrebno je definirati:

1. Konvolucijski sloj: Primijenite n filtera na mapu značajki. Nakon konvolucije, potrebno je koristiti ReLU aktivacijsku funkciju za dodavanje nelinearnosti mreži.
2. Pooling sloj: Sljedeći korak nakon konvolucije je smanjenje uzorkovanja karte značajki. Svrha je smanjiti dimenzionalnost karte značajki kako bi se spriječilo prekomjerno prilagođavanje i poboljšala brzina izračuna. Maksimalno grupiranje je konvencionalna tehnika koja dijeli karte značajki u podregije (obično veličine 2×2) i zadržava samo maksimalne vrijednosti.
3. Potpuno povezani slojevi: Svi neuroni iz prethodnih slojeva povezani su sa sljedećim slojevima. CNN će klasificirati oznaku prema značajkama iz konvolucijskih slojeva i reducirati sa slojem udruživanja.

CNN arhitektura

• Konvolucijski sloj: Primjenjuje 14 filtera veličine 5×5 (npr.trac(podregije veličine 5 × 5 piksela), s ReLU aktivacijskom funkcijom
• Pooling Sloj: Izvodi maksimalno udruživanje s filtrom 2×2 i korakom od 2 (što navodi da se objedinjena područja ne preklapaju)
• Konvolucijski sloj: primjenjuje 36 filtara 5×5, s ReLU aktivacijskom funkcijom
• Pooling Sloj #2: Opet, izvodi maksimalno udruživanje s filtrom 2×2 i korakom od 2
• 1,764 neurona, sa stopom regulacije ispadanja od 0.4 (vjerojatnost od 0.4 da će bilo koji element biti odbačen tijekom treninga)
• Gusti sloj (logički sloj): 10 neurona, po jedan za svaku ciljnu klasu znamenki (0–9).

Postoje tri važna modula koja se koriste za stvaranje CNN-a:

• conv2d(). Konstruira dvodimenzionalni konvolucijski sloj s brojem filtara, veličinom jezgre filtra, ispunom i aktivacijskom funkcijom kao argumentima.
• max_udruživanje2d(). Konstruira dvodimenzionalni sloj udruživanja pomoću algoritma maksimalnog udruživanja.
• gust(). Konstruira gusti sloj sa skrivenim slojevima i jedinicama

Definirat ćete funkciju za izgradnju CNN-a. Pogledajmo detaljno kako konstruirati svaki građevni blok prije premotavanja.ping sve zajedno u funkciji.

Korak 2: Ulazni sloj

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Morate definirati tenzor s oblikom podataka. Za to možete koristiti modul tf.reshape. U ovom modulu trebate deklarirati tenzor koji želite preoblikovati i oblik tenzora. Prvi argument je značajka podataka, koja je definirana u argumentu funkcije.

Slika ima visinu, širinu i kanal. Skup podataka MNIST je monokromatska slika veličine 28×28. Veličinu serije postavljamo na -1 u argumentu oblika tako da poprima oblik značajki ["x"]. Prednost je u tome što je veličina serije hiperparametar za podešavanje. Ako je veličina serije postavljena na 7, tenzor će dati 5,488 vrijednosti (28*28*7).

Korak 3: Konvolucijski sloj

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

Prvi konvolucijski sloj ima 14 filtera s veličinom jezgre 5×5 s istim popunjavanjem. Ista popunjavanja znače da i izlazni i ulazni tenzor trebaju imati istu visinu i širinu. TensorFlow će dodati nule u retke i stupce kako bi osigurao istu veličinu.

Koristite ReLU aktivacijsku funkciju. Izlazna veličina bit će [28, 28, 14].

Korak 4: Pooling sloj

Sljedeći korak nakon konvolucije je izračun združivanja. Izračun združivanja smanjit će dimenzionalnost podataka. Možete koristiti modul max_pooling2d s veličinom 2×2 i korakom od 2. Koristite prethodni sloj kao ulaz. Izlazna veličina bit će [batch_size, 14, 14, 14].

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

Korak 5: Drugi konvolucijski sloj i Pooling Sloj

Drugi konvolucijski sloj primjenjuje 36 filtera, dajući izlaznu veličinu [veličina_serije, 14, 14, 36]. Sloj za objedinjavanje koristi isti 2×2 prozor i korak od 2 kao i prije, pa prepolovi svaku prostornu os i izlazni oblik postaje [veličina_serije, 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)

Korak 6: Gusti sloj

Zatim morate definirati potpuno povezani sloj. Karta značajki mora se izravnati prije povezivanja s gustim slojem. Možete koristiti preoblikovanje modula veličine 7*7*36.

Gusti sloj će povezati 1,764 neurona. Dodajete ReLU aktivacijsku funkciju. Osim toga, dodajete član regularizacije ispadanja s brzinom od 0.3, što znači da će 30 posto aktivacija biti postavljeno na 0. Imajte na umu da se ispadanje događa samo tijekom faze treniranja. Funkcija cnn_model_fn ima argument mode za deklariranje treba li model trenirati ili evaluirati, kao što je prikazano u donjem primjeru klasifikacije CNN slike TensorFlow.

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)

Korak 7: Logit sloj

Konačno, u primjeru klasifikacije slika TensorFlow, možete definirati posljednji sloj s predviđanjem modela. Izlazni oblik jednak je veličini serije i 10, ukupnom broju ciljnih klasa.

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

Možete stvoriti rječnik koji sadrži klase i vjerojatnost svake klase. Funkcija tf.argmax() vraća indeks najveće vrijednosti u logit sloju. Funkcija softmax vraća vjerojatnost svake klase.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Želite vratiti rječnik predviđanja samo kada je način rada postavljen na predviđanje. Dodajete ovaj kod za prikaz predviđanja.

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

Sljedeći korak sastoji se od izračunavanja gubitka modela. U prošlom tutorijalu ste naučili da je funkcija gubitka za model s više klasa unakrsna entropija. Gubitak se lako izračunava sljedećim kodom:

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

Posljednji korak primjera TensorFlow CNN-a je optimizacija modela, odnosno pronalaženje najboljih vrijednosti težina. Za to se koristi gradijentni optimizator s brzinom učenja od 0.001. Cilj je minimizirati gubitak.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Završili ste s CNN-om. Međutim, želite prikazati metrike performansi tijekom načina evaluacije. Metrika performansi za model s više klasa je točnost. TensorFlow je opremljen modulom točnosti koji prima dva argumenta, oznake i predviđene vrijednosti.

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)

To je to. Stvorili ste svoj prvi CNN i spremni ste sve zamotati u funkciju kako biste je upotrijebili za obuku i procjenu modela.

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)

Napomena o sastavljenoj funkciji: Gornja omotana verzija postavlja prvi konvolucijski sloj na 32 filtera i ispuštanje na 0.4, dok detaljni isječci koriste 14 filtera i 0.3. Oba se izvode, ali odaberite jedan par vrijednosti i održite ga konzistentnim kako bi ispisani oblici odgovarali tablici slojeva.

Koraci u nastavku su isti kao i prethodni vodiči.

Prije svega, definirate procjenitelj s CNN modelom za klasifikaciju slika.

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

CNN se dugo trenira, stoga se svakih 50 iteracija stvara logging hook za pohranjivanje vrijednosti softmax slojeva.

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

Spremni ste procijeniti model. Postavljate veličinu serije od 100 i miješate podatke. Imajte na umu da smo postavili korake treniranja od 16 000, što može potrajati puno vremena za treniranje. Budite strpljivi.

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

Sada kada je model obučen, možete ga procijeniti i ispisati rezultate.

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

Evaluacija ispisuje obnovljenu kontrolnu točku, korak na kojem je zaustavljeno i konačni rječnik metrika.

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}

S trenutnom arhitekturom, rječnik evaluacije izvještava o točnosti od 0.9689286, što je otprilike 97%. Možete promijeniti arhitekturu, veličinu serije i broj iteracija kako biste poboljšali točnost. CNN je pokazao daleko bolje rezultate od umjetna neuronska mreža ili logistička regresija: u tutorijalu o umjetnim neuronskim mrežama imali ste točnost od 96%, što je niže od CNN-a. Performanse CNN-a su impresivne s većim skupom slika, kako u pogledu brzine izračuna, tako i u pogledu točnosti.

Pitanja i odgovori