Clasificarea imaginilor CNN în TensorFlow cu pași și exemple

Ce este rețeaua neuronală convoluțională?

Rețeaua neuronală convoluțională, cunoscută și sub numele de convnets sau CNN, este o metodă binecunoscută în aplicațiile de viziune computerizată. Este o clasă de rețele neuronale profunde utilizate pentru a analiza imagini vizuale. Acest tip de arhitectură este dominant pentru recunoașterea obiectelor dintr-o imagine sau un videoclip. Este utilizată în aplicații precum recunoașterea imaginilor sau videoclipurilor, procesarea limbajului natural și sistemele de recomandare.

Architectura unei rețele neuronale convoluționale

Gândiți-vă la Facebook acum câțiva ani, după ce ați încărcat o poză în profilul dvs., vi s-a cerut să adăugați manual un nume chipului de pe imagine. În zilele noastre, Facebook folosește convnet pentru a-ți eticheta automat prietenul din imagine.

O rețea neuronală convoluțională pentru clasificarea imaginilor nu este foarte greu de înțeles. O imagine de intrare este procesată în timpul fazei de convoluție și ulterior i se atribuie o etichetă.

O arhitectură tipică de rețea convoluțională poate fi rezumată în imaginea de mai jos. Mai întâi, o imagine este trimisă către rețea; aceasta se numește imagine de intrare. Apoi, imaginea de intrare trece printr-o serie de pași; aceasta este partea convoluțională a rețelei. În cele din urmă, rețeaua neuronală poate prezice cifra din imagine.

O imagine este compusă dintr-o matrice de pixeli cu înălțime și lățime. O imagine în tonuri de gri are un singur canal, în timp ce imaginea color are trei canale (fiecare pentru Roșu, Verde și Albastru). Canalele sunt suprapuse. În acest tutorial, veți utiliza o imagine în tonuri de gri cu un singur canal. Fiecare pixel are o valoare de la 0 la 255 pentru a reflecta intensitatea culorii. De exemplu, un pixel egal cu 0 va afișa o culoare albă, în timp ce un pixel cu o valoare apropiată de 255 va fi mai închis la culoare.

Să aruncăm o privire la o imagine stocată în Setul de date MNISTImaginea de mai jos arată cum se reprezintă imaginea din stânga într-un format matriceal. Rețineți că matricea originală a fost standardizată să fie între 0 și 1. Pentru culorile mai închise, valoarea din matrice este de aproximativ 0.9, în timp ce pixelii albi au valoarea 0.

Operație convoluțională

Cea mai importantă componentă a modelului este stratul convoluțional. Această parte își propune să reducă dimensiunea imaginii pentru calcule mai rapide ale ponderilor și să îmbunătățească generalizarea.

În timpul părții convoluționale, rețeaua păstrează caracteristicile esențiale ale imaginii și exclude zgomotul irelevant. De exemplu, modelul învață cum să recunoască un elefant dintr-o imagine cu un munte în fundal. Dacă utilizați o rețea neuronală tradițională, modelul va atribui o pondere tuturor pixelilor, inclusiv celor de la munte, ceea ce nu este esențial și poate induce în eroare rețeaua.

În schimb, a Keras Rețeaua neuronală convoluțională va folosi o tehnică matematică pentru a extracdoar cei mai relevanți pixeli. Această operație matematică se numește convoluție. Această tehnică permite rețelei să învețe caracteristici din ce în ce mai complexe la fiecare strat. Convoluția împarte matricea în bucăți mici pentru a învăța cele mai esențiale elemente din fiecare bucată.

Componentele rețelei neuronale convoluționale (ConvNet sau CNN)

Există patru componente ale unei convnet-uri:

1. Convoluţie
2. Neliniaritate (ReLU)
3. Pooling sau Sub Sampling
4. Clasificare (strat complet conectat)

Convoluţie

Scopul convoluției este de a extraccaracteristicile obiectului din imagine la nivel local. Aceasta înseamnă că rețeaua va învăța modele specifice din imagine și le va putea recunoaște peste tot în imagine.

Convoluția este o înmulțire pe elemente. Conceptul este ușor de înțeles. Calculatorul va scana o parte a imaginii, de obicei cu dimensiunea de 3×3, și o va înmulți cu un filtru. Rezultatul înmulțirii pe elemente se numește hartă a caracteristicilor. Acest pas se repetă până când întreaga imagine este scanată. Rețineți că, după convoluție, dimensiunea imaginii este redusă.

Diagrama de mai jos arată o porțiune a imaginii înmulțită cu filtrul pentru a produce o singură celulă a hărții de caracteristici.

Animația de mai jos arată aceeași convoluție care se desfășoară pe întreaga imagine.

Există numeroase filtre disponibile. Mai jos, am enumerat câteva dintre ele. Puteți vedea că fiecare filtru are un scop specific. Rețineți că în imaginea de mai jos, kernelul este sinonim cu filtrul.

Aritmetica din spatele convoluției

Faza convoluțională va aplica filtrul pe o mică matrice de pixeli din imagine. Filtrul se va deplasa de-a lungul imaginii de intrare cu o formă generală de 3×3 sau 5×5. Aceasta înseamnă că rețeaua va glisa aceste ferestre pe toată imaginea de intrare și va calcula convoluția. Animația de mai jos arată cum funcționează convoluția. Dimensiunea patch-ului este de 3×3, iar matricea de ieșire este rezultatul operației elementare dintre matricea imaginii și filtru.

Observați că lățimea și înălțimea ieșirii pot fi diferite de lățimea și înălțimea intrării. Se întâmplă din cauza efectului de graniță.

Efect de frontieră

Imaginea are o hartă a caracteristicilor de 5×5 și un filtru de 3×3. Există o singură fereastră în centru unde filtrul poate afișa o grilă de 3×3. Harta caracteristicilor de ieșire se micșorează cu două plăci pe fiecare axă, lăsând o dimensiune de 3×3.

Pentru a obține aceeași dimensiune de ieșire ca dimensiunea de intrare, trebuie să adăugați padding. Padding-ul constă în adăugarea numărului corect de rânduri și coloane pe fiecare parte a matricei. Aceasta va permite convoluției să se potrivească central fiecărei plăci de intrare. În imaginea de mai jos, matricile de intrare și de ieșire au aceeași dimensiune, 5×5.

Când definiți rețeaua, caracteristicile convoluate sunt controlate de trei parametri:

Adâncime: Definește numărul de filtre care se aplică în timpul convoluției. În exemplul anterior, ați văzut o adâncime de 1, ceea ce înseamnă că se folosește un singur filtru. În majoritatea cazurilor, există mai multe filtre. Animația de mai jos arată operațiunile efectuate într-o situație cu trei filtre.

Pas: Definește numărul de „salturi de pixeli” între două felii. Dacă pasul este egal cu 1, fereastra se va mișca cu o diferență de un pixel. Dacă pasul este egal cu doi, fereastra va sări cu 2 pixeli. Dacă măriți pasul, veți avea hărți de caracteristici mai mici. Cele două diagrame de mai jos compară un pas de 1 cu un pas de 2.

Exemplu de pas 1

pasul 2

Zero umplutură: O umplutură este o operațiune de adăugare a unui număr corespunzător de rânduri și coloane pe fiecare parte a hărților de caracteristici de intrare. În acest caz, ieșirea are aceeași dimensiune ca și intrarea.

Neliniaritate (ReLU)

La sfârșitul operației de convoluție, ieșirea este supusă unei funcții de activare pentru a permite neliniaritatea. Funcția de activare obișnuită pentru o convoluție este ReLU. Toți pixelii cu o valoare negativă vor fi înlocuiți cu zero.

Pooling OperaTION

Acest pas este ușor de înțeles. Scopul grupării (pooling) este de a reduce dimensionalitatea imaginii de intrare. Pașii sunt realizați pentru a reduce complexitatea computațională a operației. Prin diminuarea dimensionalității, rețeaua are mai puține ponderi de calculat, astfel încât se previne supraadaptarea.

În această etapă, trebuie să definiți dimensiunea și pasul. O modalitate standard de a grupa imaginea de intrare este de a utiliza valoarea maximă a hărții de caracteristici. Priviți imaginea de mai jos. Gruparea va analiza patru submatrici ale hărții de caracteristici 4×4 și va returna valoarea maximă. Gruparea preia valoarea maximă a unei matrice 2×2 și apoi mută această fereastră cu doi pixeli. De exemplu, prima submatrice este [3,1,3,2], deci gruparea va returna valoarea maximă, care este 3.

Există o altă operațiune de pooling, cum ar fi media.

Această operațiune reduce agresiv dimensiunea hărții de caracteristici.

Straturi complet conectate

Ultimul pas constă în construirea unui tradițional retele neuronale artificiale asa cum ai facut in tutorialul anterior. Conectați toți neuronii din stratul anterior la stratul următor. Utilizați o funcție de activare softmax pentru a clasifica numărul de pe imaginea de intrare.

Recapitulare:

O rețea neuronală convoluțională TensorFlow compilează diferite straturi înainte de a face o predicție. O rețea neuronală are:

• Un strat convoluțional
• Funcția de activare ReLU
• Pooling strat
• Strat dens conectat

Straturile convoluționale aplică filtre diferite pe o subregiune a imaginii. Funcția de activare ReLU adaugă neliniaritate, iar straturile de pooling reduc dimensionalitatea hărților de caracteristici.

Toate aceste straturi extracinformații esențiale din imagini. În cele din urmă, hărțile caracteristicilor sunt introduse într-un strat complet conectat cu o funcție softmax pentru a face o predicție.

Antrenează CNN cu TensorFlow

Acum că ești familiarizat cu elementele constitutive ale unei convnet-uri, ești gata să construiești una cu TensorFlow. Vom folosi setul de date MNIST pentru clasificarea imaginilor CNN.

Pregătirea datelor este aceeași cu tutorialul anterior. Puteți rula codurile și puteți sări direct la arhitectura CNN.

Veți urma pașii de mai jos pentru clasificarea imaginilor folosind CNN:

1. Pasul 1: Încărcați setul de date
2. Pasul 2: Stratul de intrare
3. Pasul 3: Stratul convoluțional
4. Pasul 4: Pooling strat
5. Pasul 5: Al doilea strat convoluțional și Pooling Strat
6. Pasul 6: Strat dens
7. Pasul 7: Stratul Logit

Notă privind versiunea: Listările de mai jos vizează TensorFlow 1.x. În TensorFlow 2, spațiul de nume tf.layers și tf.estimator.inputs.numpy_input_fn nu mai există; echivalentele sunt tf.keras.layers.Conv2D, MaxPooling2D, Dense și Dropout asamblate într-un tf.keras.Model și antrenate cu model.fit(). Citiți pașii pentru mecanica fiecărui strat, apoi mapați-i pe API-ul Keras.

Pasul 1: Încărcați setul de date

Setul de date MNIST este disponibil prin scikit-learn. Vă rugăm să îl descărcați și să îl salvați în Descărcări. Îl puteți încărca cu fetch_mldata('MNIST original').

Notă privind versiunea: mldata.org s-a închis și fetch_mldata() a fost eliminată în scikit-learn 0.22. La orice instalare curentă, încărcați aceleași cifre cu fetch_openml în schimb, se folosește fetch_openml('mnist_784', version=1). Restul pipeline-ului rămâne neschimbat.

Creați un tren/set de testare

Trebuie să divizați setul de date cu train_test_split.

Scalați caracteristicile

În cele din urmă, puteți scala entitățile cu MinMaxScaler, așa cum se arată în clasificarea imaginilor de mai jos, folosind exemplul TensorFlow CNN.

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

Definiți CNN

O rețea neuronală (CNN) folosește filtre pe pixelii bruti ai unei imagini pentru a învăța modele de detalii în comparație cu modelele globale învățate de o rețea neuronală tradițională. Pentru a construi o CNN, trebuie să definiți:

1. Un strat convoluțional: Aplicați un număr n de filtre pe harta de caracteristici. După convoluție, trebuie să utilizați o funcție de activare ReLU pentru a adăuga neliniaritate rețelei.
2. PoolinStratul g: Următorul pas după convoluție este subeșantionarea hărții de caracteristici. Scopul este de a reduce dimensionalitatea hărții de caracteristici pentru a preveni supraadaptarea și a îmbunătăți viteza de calcul. Max pooling este tehnica convențională, care împarte hărțile de caracteristici în subregiuni (de obicei cu o dimensiune de 2×2) și păstrează doar valorile maxime.
3. Straturi complet conectate: toți neuronii din straturile anterioare sunt conectați la straturile următoare. CNN va clasifica eticheta în funcție de caracteristicile din straturile convoluționale și reduse cu stratul de pooling.

Arhitectura CNN

• Strat convoluțional: Aplică 14 filtre de 5×5 (de exemplu,trac(subregiuni de 5×5 pixeli), cu funcția de activare ReLU
• Pooling Strat: Efectuează o grupare maximă cu un filtru 2×2 și un pas de 2 (care specifică faptul că regiunile grupate nu se suprapun)
• Strat convoluțional: aplică 36 de filtre 5×5, cu funcție de activare ReLU
• Pooling Stratul #2: Din nou, efectuează o grupare maximă cu un filtru 2×2 și un pas de 2
• 1,764 de neuroni, cu o rată de regularizare a abandonului de 0.4 (probabilitatea de 0.4 ca orice element dat să fie abandonat în timpul antrenamentului)
• Strat dens (Strat Logits): 10 neuroni, câte unul pentru fiecare clasă țintă de cifre (0–9).

Există trei module importante de utilizat pentru a crea un CNN:

• conv2d(). Construiește un strat convoluțional bidimensional cu numărul de filtre, dimensiunea nucleului de filtru, umplutura și funcția de activare ca argumente.
• max_pooling2d(). Construiește un strat de pooling bidimensional utilizând algoritmul max-pooling.
• dens(). Construiește un strat dens cu straturile și unitățile ascunse

Vei defini o funcție pentru a construi CNN. Să vedem în detaliu cum se construiește fiecare element constitutiv înainte de finalizare.ping totul împreună în funcție.

Pasul 2: Stratul de intrare

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

Trebuie să definiți un tensor cu forma datelor. Pentru asta, poți folosi modulul tf.reshape. În acest modul, trebuie să declarați tensorul de remodelat și forma tensorului. Primul argument este caracteristicile datelor, care sunt definite în argumentul funcției.

O imagine are o înălțime, o lățime și un canal. Setul de date MNIST este o imagine monocromă cu o dimensiune de 28×28. Am setat dimensiunea lotului la -1 în argumentul formă, astfel încât să ia forma caracteristicilor [„x”]. Avantajul este de a face din dimensiunea lotului un hiperparametru de reglat. Dacă dimensiunea lotului este setată la 7, atunci tensorul va furniza 5,488 de valori (28*28*7).

Pasul 3: Stratul convoluțional

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

Primul strat convoluțional are 14 filtre cu o dimensiune a nucleului de 5×5, cu aceeași umplutură. Aceeași umplutură înseamnă că atât tensorul de ieșire, cât și tensorul de intrare ar trebui să aibă aceeași înălțime și lățime. TensorFlow va adăuga zerouri la rânduri și coloane pentru a asigura aceeași dimensiune.

Folosești funcția de activare ReLU. Dimensiunea ieșirii va fi [28, 28, 14].

Pasul 4: Pooling strat

Următorul pas după convoluție este calculul de pooling. Calculul de pooling va reduce dimensionalitatea datelor. Puteți utiliza modulul max_pooling2d cu o dimensiune de 2×2 și un stride de 2. Folosiți stratul anterior ca intrare. Dimensiunea de ieșire va fi [batch_size, 14, 14, 14].

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

Pasul 5: Al doilea strat convoluțional și Pooling Strat

Al doilea strat convoluțional aplică 36 de filtre, rezultând o dimensiune de ieșire de [batch_size, 14, 14, 36]. Stratul de pooling folosește aceeași fereastră 2×2 și un stride de 2 ca înainte, astfel încât înjumătățește fiecare axă spațială, iar forma de ieșire devine [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)

Pasul 6: Strat dens

Apoi, trebuie să definiți stratul complet conectat. Harta caracteristicilor trebuie aplatizată înainte de a fi conectată cu stratul dens. Puteți utiliza modulul de remodelare cu o dimensiune de 7*7*36.

Stratul dens va conecta 1,764 de neuroni. Adăugați o funcție de activare ReLU. În plus, adăugați un termen de regularizare a abandonului cu o rată de 0.3, ceea ce înseamnă că 30% din activări vor fi setate la 0. Rețineți că abandonul are loc doar în timpul fazei de antrenament. Funcția cnn_model_fn are un mod de argument pentru a declara dacă modelul trebuie antrenat sau evaluat, așa cum se arată în exemplul TensorFlow de clasificare a imaginilor CNN de mai jos.

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)

Pasul 7: Stratul Logit

În cele din urmă, în exemplul de clasificare a imaginilor TensorFlow, puteți defini ultimul strat cu predicția modelului. Forma de ieșire este egală cu dimensiunea lotului și 10, numărul total de clase țintă.

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

Puteți crea un dicționar care conține clasele și probabilitatea fiecărei clase. Funcția tf.argmax() returnează indicele celei mai mari valori din stratul logits. Funcția softmax returnează probabilitatea fiecărei clase.

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

Doriți să returnați dicționarul de predicții doar atunci când modul este setat la predicție. Adăugați acest cod pentru a afișa predicțiile.

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

Următorul pas constă în calcularea pierderii modelului. În tutorialul precedent, ați învățat că funcția de pierdere pentru un model multiclasă este entropia încrucișată. Pierderea se calculează ușor cu următorul cod:

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

Pasul final al exemplului TensorFlow CNN este optimizarea modelului, adică găsirea celor mai bune valori ale ponderilor. Pentru aceasta, se utilizează un optimizator de tip gradient descent cu o rată de învățare de 0.001. Obiectivul este de a minimiza pierderile.

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

Ați terminat cu CNN. Cu toate acestea, doriți să afișați indicatorii de performanță în timpul modului de evaluare. Indicatorul de performanță pentru un model multiclasă este precizia. TensorFlow este echipat cu un modul de precizie care primește două argumente, etichetele și valorile prezise.

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)

Asta este. Ai creat primul tău CNN și ești gata să împachetezi totul într-o funcție pentru a o folosi pentru a antrena și a evalua modelul.

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)

Notă despre funcția asamblată: Versiunea wrapată de mai sus setează primul strat convoluțional la 32 de filtre și dropout la 0.4, în timp ce fragmentele pas cu pas utilizează 14 filtre și 0.3. Ambele rulează, dar aleg o pereche de valori și o mențin consecventă, astfel încât formele imprimate să se potrivească cu tabelul de straturi.

Pașii de mai jos sunt aceiași cu tutorialele anterioare.

În primul rând, definiți un estimator cu modelul CNN pentru clasificarea imaginilor.

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

Antrenarea unui CNN durează mult timp, prin urmare, creați un hook de logging pentru a stoca valorile straturilor softmax la fiecare 50 de iterații.

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

Ești gata să estimezi modelul. Setezi o dimensiune a lotului de 100 și amesteci datele. Reține că am setat pași de antrenament de 16,000, ceea ce poate dura mult timp pentru antrenament. Ai răbdare.

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

Acum că modelul este antrenat, îl puteți evalua și puteți afișa rezultatele.

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

Evaluarea afișează punctul de control restaurat, pasul la care s-a oprit și dicționarul final de metrici.

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}

Cu arhitectura actuală, dicționarul de evaluare raportează o precizie de 0.9689286, aproximativ 97%. Puteți modifica arhitectura, dimensiunea lotului și numărul de iterații pentru a îmbunătăți precizia. CNN a avut performanțe mult mai bune decât un retele neuronale artificiale sau regresie logistică: în tutorialul despre rețele neuronale artificiale, ați avut o precizie de 96%, care este mai mică decât CNN. Performanța CNN este impresionantă, cu un set de imagini mai mare, atât în ​​ceea ce privește viteza de calcul, cât și precizia.

Întrebări frecvente