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 care sunt utilizate pentru a analiza imaginile vizuale. Acest tip de arhitectură este dominant pentru a recunoaște obiectele dintr-o imagine sau videoclip. Este folosit în aplicații precum recunoașterea imaginilor sau video, procesarea limbajului neuronal etc.

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ă convnet poate fi rezumată în imaginea de mai jos. În primul rând, o imagine este împinsă în rețea; aceasta se numește imaginea de intrare. Apoi, imaginea de intrare trece printr-un număr infinit de pași; aceasta este partea convoluțională a rețelei. În cele din urmă, rețeaua neuronală poate prezice cifra de pe 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). Un canal este stivuit unul peste altul. În acest tutorial, veți folosi 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 arăta o culoare albă, în timp ce pixelul cu o valoare apropiată de 255 va fi mai întunecat.

Să aruncăm o privire la o imagine stocată în Setul de date MNIST. Imaginea de mai jos arată cum să reprezentați imaginea din stânga într-un format de matrice. Rețineți că, matricea originală a fost standardizată pentru a fi între 0 și 1. Pentru o culoare mai închisă, valoarea din matrice este de aproximativ 0.9, în timp ce pixelii albi au o valoare de 0.

Operație convoluțională

Cea mai critică componentă a modelului este stratul convoluțional. Această parte are ca scop reducerea dimensiunii imaginii pentru calcule mai rapide ale greutăților și îmbunătățirea generalizării acesteia.

Î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 extrage doar 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 multe elemente esențiale din fiecare piesă.

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

Există patru componente ale unui Convnets

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

Convoluţie

Scopul convoluției este extragerea locală a caracteristicilor obiectului de pe imagine. Î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 în funcție de elemente. Conceptul este ușor de înțeles. Computerul va scana o parte a imaginii, de obicei cu o dimensiune de 3×3 și o va multiplica la un filtru. Ieșirea înmulțirii pe elemente se numește o hartă de caracteristici. Acest pas se repetă până când toată imaginea este scanată. Rețineți că, după convoluție, dimensiunea imaginii este redusă.

Mai jos, există o adresă URL pentru a vedea în acțiune cum funcționează convoluția.

Există numeroase canale disponibile. Mai jos, am enumerat câteva dintre canale. Puteți vedea că fiecare filtru are un scop specific. Rețineți, în imaginea de mai jos; Kernel-ul este un sinonim al filtrului.

Aritmetica din spatele convoluției

Faza convoluțională va aplica filtrul pe o matrice mică de pixeli din imagine. Filtrul se va deplasa de-a lungul imaginii de intrare cu o formă generală de 3×3 sau 5×5. Înseamnă că rețeaua va glisa aceste ferestre pe toată imaginea de intrare și va calcula convoluția. Imaginea de mai jos arată cum funcționează convoluția. Dimensiunea patch-ului este de 3×3, iar matricea de ieșire este rezultatul operațiunii 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ă cu caracteristici 5×5 și un filtru 3×3. Există o singură fereastră în centru unde filtrul poate ecrana o grilă 3×3. Harta caracteristicilor de ieșire se va micșora cu două plăci împreună cu o dimensiune 3×3.

Pentru a obține aceeași dimensiune de ieșire ca dimensiunea de intrare, trebuie să adăugați umplutură. Umplutura constă în adăugarea numărului corect de rânduri și coloane pe fiecare parte a matricei. Acesta va permite ca convoluția să se potrivească în centru fiecărei plăci de intrare. În imaginea de mai jos, matricea de intrare/ieșire are aceeași dimensiune 5×5

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

1. Adâncime: definește numărul de filtre de aplicat în timpul convoluției. În exemplul anterior, ați văzut o adâncime de 1, ceea ce înseamnă că este utilizat un singur filtru. În majoritatea cazurilor, există mai mult de un filtru. Imaginea de mai jos prezintă operațiunile efectuate într-o situație cu trei filtre

2. Pas: definește numărul de „sărituri de pixeli” dintre două felii. Dacă pasul este egal cu 1, ferestrele se vor mișca cu o întindere a pixelului de unu. Dacă pasul este egal cu doi, ferestrele vor sări cu 2 pixeli. Dacă creșteți pasul, veți avea hărți de caracteristici mai mici.

Exemplu de pas 1

pasul 2

3. Zero-căptușeală: O umplutură este o operațiune de adăugare a unui număr corespunzător de rânduri și coloane de 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 obișnuită de activare pentru convnet 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 punerii în comun este de a reduce dimensionalitatea imaginii de intrare. Pașii sunt făcuți pentru a reduce complexitatea de calcul a operației. Prin diminuarea dimensionalității, rețeaua are greutăți mai mici de calculat, astfel încât împiedică supraadaptarea.

În această etapă, trebuie să definiți dimensiunea și pasul. O modalitate standard de a pune în comun imaginea de intrare este utilizarea valorii maxime a hărții caracteristicilor. Uită-te la poza de mai jos. „Regruparea” va ecraniza o submatrice de patru a hărții caracteristicilor 4×4 și va returna valoarea maximă. Regruparea ia valoarea maximă a unei matrice 2×2 și apoi mișcă această fereastră cu doi pixeli. De exemplu, prima sub-matrice este [3,1,3,2], gruparea va returna maximul, care este 3.

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

Această operațiune reduce agresiv dimensiunea hărții caracteristicilor

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:

Rețeaua 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ă diferite filtre pe o subregiune a imaginii. Funcția de activare Relu adaugă neliniaritate, iar straturile de grupare reduc dimensionalitatea hărților de caracteristici.

Toate aceste straturi extrag informații esențiale din imagini. În cele din urmă, harta caracteristicilor este transmisă unui strat primar complet conectat cu o funcție softmax pentru a face o predicție.

Antrenează CNN cu TensorFlow

Acum că sunteți familiarizat cu blocul de construcție al unui convnet, sunteți gata să construiți unul 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:

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

Pasul 2: Stratul de intrare

Pasul 3: Stratul convoluțional

Pasul 4: Pooling strat

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

Pasul 6: Strat dens

Pasul 7: Stratul Logit

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

Setul de date MNIST este disponibil cu scikit pentru a învăța despre asta URL-ul. Descărcați-l și stocați-l în Descărcări. Îl puteți încărca cu fetch_mldata('MNIST original').

Creați un tren/set de testare

Trebuie să împărțiți setul de date cu train_test_split

Scalați caracteristicile

În cele din urmă, puteți scala caracteristica cu MinMaxScaler, așa cum se arată în clasificarea imaginii 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

Un CNN folosește filtre pe pixelul brut al unei imagini pentru a afla modelul de detalii în comparație cu modelul global cu o rețea neuronală tradițională. Pentru a construi un CNN, trebuie să definiți:

1. Un strat convoluțional: Aplicați un număr n de filtre pe harta caracteristicilor. După convoluție, trebuie să utilizați o funcție de activare Relu pentru a adăuga neliniaritate rețelei.
2. Pooling layer: Următorul pas după convoluție este reducerea eșantionării caracteristicii max. Scopul este de a reduce dimensionalitatea hărții caracteristicilor pentru a preveni supraadaptarea și pentru a îmbunătăți viteza de calcul. Max pooling este tehnica convențională, care împarte hărțile caracteristicilor în subregiuni (de obicei cu o dimensiune 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 5×5 (extrăgând subregiuni de 5×5 pixeli), cu funcție 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

Veți defini o funcție pentru a construi CNN. Să vedem în detaliu cum să construim fiecare bloc înainte de a încheia 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 monocronică cu o dimensiune de 28×28. Setăm dimensiunea lotului la -1 în argumentul formei, astfel încât să ia forma caracteristicilor [“x”]. Avantajul este de a ajusta hiperparametrii dimensiunii lotului. Dacă dimensiunea lotului este setată la 7, atunci tensorul va alimenta 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 dimensiunea 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.

Utilizați funcția de activare Relu. Dimensiunea de ieșire 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 pas 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 are 32 de filtre, cu o dimensiune de ieșire de [batch_size, 14, 14, 32]. Stratul de grupare are aceeași dimensiune ca înainte și forma de ieșire este [batch_size, 14, 14, 18].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

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 1764 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, adică 30 de procente din ponderi vor fi setate la 0. Rețineți că abandonul are loc doar în faza de antrenament. Funcția cnn_model_fn are un mod argument pentru a declara dacă modelul trebuie antrenat sau pentru a evalua, așa cum se arată în exemplul de mai jos de clasificare a imaginii CNN 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)

Pasul 7: Stratul Logit

În cele din urmă, în exemplul de clasificare a imaginii 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 imagini.

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

Puteți crea un dicționar care să conțină clasele și probabilitatea fiecărei clase. Modulul tf.argmax() cu returnează cea mai mare valoare dacă straturile logit. 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 predicția dicționarului numai atunci când modul este setat la predicție. Adăugați aceste coduri pentru a afișa previziunile

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

Următorul pas constă în calcularea pierderii modelului. În ultimul tutorial, ați învățat că funcția de pierdere pentru un model multiclasă este entropia încrucișată. Pierderea este ușor de calculat 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 greutăților. Pentru aceasta, utilizați un optimizator de coborâre Gradient cu o rată de învățare de 0.001. Obiectivul este de a minimiza pierderea

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

Ai terminat cu CNN. Cu toate acestea, doriți să afișați valorile de performanță în timpul modului de evaluare. Valorile de performanță pentru un model multiclasă sunt valorile de precizie. Tensorflow este echipat cu un modul de precizie cu 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)

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

Un CNN are nevoie de multe ori pentru a se antrena, prin urmare, creați un cârlig de înregistrare 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)

Sunteți gata să estimați modelul. Setați o dimensiune a lotului de 100 și amestecați datele. Rețineți că am stabilit pași de antrenament de 16.000, poate dura mult timp pentru a antrena. Fii răbdător.

# 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 tren, îl puteți evalua și imprima 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)

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ă, obțineți o precizie de 97%. Puteți modifica arhitectura, dimensiunea lotului și numărul de iterații pentru a îmbunătăți acuratețea. Rețeaua neuronală CNN a funcționat mult mai bine decât ANN sau regresia logistică. În tutorialul despre rețeaua neuronală artificială, ai avut o precizie de 96%, ceea ce este mai mic decât CNN. Performanțele CNN sunt impresionante cu o imagine mai mare set, atât în ​​ceea ce privește viteza de calcul, cât și precizia.

Rezumat

O rețea neuronală convoluțională funcționează foarte bine pentru a evalua imaginea. Acest tip de arhitectură este dominant pentru a recunoaște obiectele dintr-o imagine sau videoclip.

Pentru a construi un CNN TensorFlow, trebuie să urmați șapte pași:

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

Setul de date MNIST este disponibil cu scikit pentru a învăța. Descărcați-l și stocați-l în Descărcări. Îl puteți încărca cu fetch_mldata('MNIST original').

Etapa 2: Strat de intrare:

Acest pas remodelează datele. Forma este egală cu rădăcina pătrată a numărului de pixeli. De exemplu, dacă o imagine are 156 de pixeli, atunci forma este 26×26. Trebuie să specificați dacă imaginea are culoare sau nu. Dacă da, atunci aveai 3 la formă - 3 pentru RGB-, în caz contrar 1.

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

Etapa 3: Strat convoluțional

Apoi, trebuie să creați straturile convoluționale. Aplicați diferite filtre pentru a permite rețelei să învețe caracteristicile importante. Specificați dimensiunea nucleului și cantitatea de filtre.

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

Etapa 4: Pooling strat

În al treilea pas, adăugați un strat de pooling. Acest strat scade dimensiunea intrării. O face luând valoarea maximă a sub-matricei a. De exemplu, dacă sub-matricea este [3,1,3,2], gruparea va returna maximul, care este 3.

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

Etapa 5: Adăugați Stratul Convoluțional și Pooling Strat

În acest pas, puteți adăuga atât cât doriți straturi de conversie și straturi de grupare. Google folosește arhitectura cu mai mult de 20 de straturi conv.

Etapa 6: Strat dens

Pasul 6 aplatizează precedentul pentru a crea straturi complet conectate. În acest pas, puteți utiliza diferite funcții de activare și puteți adăuga un efect de abandon.

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)

Etapa 7: Stratul Logit

Pasul final este predicția.

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