Clasificarea imaginii TensorFlow: CNN (Convolutional Neural Network)

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

Rețeaua neuronală convoluțională, cunoscută și sub numele de convnets sau CNN, este o metodă bine cunoscută în aplicațiile de viziune computerizată. Acest tip de arhitectură este dominant pentru a recunoaște obiectele dintr-o imagine sau un videoclip.

În acest tutorial, veți afla cum să construiți o convnet și cum să utilizați TensorFlow pentru a rezolva setul de date scris de mână.

În acest tutorial, veți învăța

• Rețea neuronală convoluțională
• Arhitectura unei rețele neuronale convoluționale
• Componentele Convnets
• Antrenează CNN cu TensorFlow
• Pasul 1: încărcați setul de date
• Pasul 2: Stratul de intrare
• Pasul 3: Stratul convoluțional
• Pasul 4: Stratul de punere în comun
• Pasul 5: Al doilea strat convoluțional și stratul comun
• Pasul 6: Stratul dens
• Pasul 7: Logit Layer

Arhitectura unei rețele neuronale convoluționale

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

O rețea neuronală convoluțională nu este foarte dificil 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 serie 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 celălalt. Î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 arăta o culoare albă, în timp ce pixelul cu o valoare apropiată de 255 va fi mai închis.

Să aruncăm o imagine a imaginii stocate în setul de date MNIST. Imaginea de mai jos arată cum să reprezentați imaginea din stânga într-un format matricial. 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 pixeli albi au o valoare de 0.

Operațiune convoluțională

Cea mai critică componentă a modelului este stratul convoluțional. Această parte vizează 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 greutate tuturor pixelilor, inclusiv celor de pe munte, care nu este esențială și poate induce în eroare rețeaua.

În schimb, o rețea neuronală convoluțională va utiliza 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 elementele esențiale din fiecare piesă.

Componentele Convnets

Există patru componente ale unui Convnets

1. Convoluţie
2. Non-liniaritate (ReLU)
3. Pooling sau Sub-eșantionare
4. Clasificare (strat complet conectat)

• Convoluţie

Scopul convoluției este de a extrage local caracteristicile obiectului de pe imagine. Înseamnă că rețeaua va învăța modele specifice în cadrul imaginii și o va putea recunoaște oriunde în imagine.

Convoluția este o multiplicare elementară. Conceptul este ușor de înțeles. Computerul va scana o parte a imaginii, de obicei cu o dimensiune de 3x3 și o va multiplica într-un filtru. Ieșirea multiplicării elementare se numește hartă a caracteristicilor. Acest pas se repetă până când se scanează toată imaginea. Rețineți că, după convoluție, dimensiunea imaginii este redusă.

Mai jos, există un 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 este un sinonim al filtrului.

Sursă

Aritmetica din spatele convoluției

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

Sursă

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 frontieră.

Efect de margine

Imaginea are o hartă a caracteristicilor 5x5 și un filtru 3x3. Există o singură fereastră în centru în care filtrul poate afișa o grilă de 3x3. Harta caracteristicilor de ieșire se va micșora cu două plăci alături de o dimensiune 3x3.

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

Când definiți rețeaua, caracteristicile implicate 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 multe filtre. Imaginea de mai jos prezintă operațiunile efectuate într-o situație cu trei filtre

2. Pasul: definește numărul de "salt pixel" între două felii. Dacă pasul este egal cu 1, ferestrele se vor mișca cu o rată de pixeli a unuia. Dacă pasul este egal cu doi, ferestrele vor sări cu 2 pixeli. Dacă măriți pasul, veți avea hărți de caracteristici mai mici.

Exemplu pas 1

Pasul de imagine 2

3. Zero-padding: O padding este o operație de adăugare a unui număr corespunzător de rânduri și coloane pe fiecare parte a hărților caracteristicilor de intrare. În acest caz, ieșirea are aceeași dimensiune ca și intrarea.
4. Non-liniaritate (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 valoare negativă vor fi înlocuiți cu zero.

• Operațiune de pooling maxim

Acest pas este ușor de înțeles. Scopul punerii în comun este de a reduce dimensionalitatea imaginii de intrare. Pașii sunt realizați pentru a reduce complexitatea de calcul a operației. Prin diminuarea dimensionalității, rețeaua are greutăți mai mici de calculat, deci previne supra-montarea.

În această etapă, trebuie să definiți dimensiunea și pasul. O modalitate standard de a pune în comun imaginea de intrare este de a utiliza valoarea maximă a hărții de caracteristici. Uită-te la poza de mai jos. „Rezervarea” va afișa o submatrixă a patru a hărții caracteristice 4x4 și va returna valoarea maximă. Ponderea ia valoarea maximă a unui tablou 2x2 și apoi mută această fereastră cu doi pixeli. De exemplu, prima sub-matrice este [3,1,3,2], cumularea va returna maximul, care este 3.

Există o altă operațiune de punere în comun, cum ar fi media.

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

• Straturi complet conectate

Ultimul pas constă în construirea unei rețele neuronale artificiale tradiționale așa cum ați făcut în tutorialul anterior. Conectați toți neuronii din stratul anterior la stratul următor. Folosiți o funcție de activare softmax pentru a clasifica numărul de pe imaginea de intrare.

Recapitulare:

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

• Un strat convoluțional
• Funcția de activare a reluării
• Stratul de pooling
• 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 alimentată către un 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 unei convnete, sunteți gata să construiți unul cu TensorFlow. Vom folosi setul de date MNIST pentru clasificarea imaginilor.

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

Veți urma pașii de mai jos:

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

Pasul 2: Stratul de intrare

Pasul 3: Stratul convoluțional

Pasul 4: Stratul de punere în comun

Pasul 5: Al doilea strat convoluțional și stratul comun

Pasul 6: Stratul dens

Pasul 7: Logit Layer

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

Setul de date MNIST este disponibil cu scikit pentru a afla la această adresă URL. Vă rugăm să o descărcați și să o stocați î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

Scăriți caracteristicile

În cele din urmă, puteți scala funcția cu MinMaxScaler

import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_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 )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_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 detaliile modelului comparativ 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 n număr 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. Stratul de punere în comun: următorul pas după convoluție este reducerea probei caracteristicii max. Scopul este de a reduce dimensionalitatea hărții de caracteristici pentru a preveni supra-montarea și pentru a îmbunătăți viteza de calcul. Combinarea maximă este tehnica convențională, care împarte hărțile de caracteristici în subregiuni (de obicei, cu o dimensiune 2x2) ș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 colectare.

Arhitectura CNN

• Strat convoluțional: aplică 14 filtre 5x5 (extragerea subregiunilor de 5x5 pixeli), cu funcție de activare ReLU
• Strat de pooling: efectuează pooling maxim cu un filtru 2x2 și pasul 2 (care specifică faptul că regiunile grupate nu se suprapun)
• Strat convoluțional: aplică 36 de filtre 5x5, cu funcție de activare ReLU
• Stratul de pooling # 2: Din nou, realizează pooling-ul maxim cu un filtru 2x2 ș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)
• Stratul dens (stratul 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 filtrului, umplutura și funcția de activare ca argumente.
• max_pooling2d (). Construiește un strat de pooling bidimensional folosind algoritmul de pooling maxim.
• 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 de construcție înainte de a înfășura 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 aceasta, puteți utiliza 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 28x28. Am setat dimensiunea lotului la -1 în argumentul de formă, astfel încât să ia forma caracteristicilor ["x"]. Avantajul este de a face hiperparametrele de dimensiuni ale lotului să se regleze. Dacă dimensiunea lotului este setată la 7, atunci tensorul va alimenta 5.488 de valori (28 * 28 * 7).

Step 3: Convolutional layer

# first Convolutional Layerconv1 = 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 5x5 cu aceeași căptușeală. Același umplutură înseamnă 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.

Folosiți funcția de activare Relu. Dimensiunea ieșirii va fi [28, 28, 14].

Pasul 4: Stratul de punere în comun

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

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

Pasul 5: Al doilea strat convoluțional și stratul comun

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: Stratul dens

Apoi, trebuie să definiți stratul complet conectat. Harta caracteristicilor trebuie aplatizată înainte de a fi conectată la stratul dens. Puteți utiliza remodelarea modulului 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, ceea ce înseamnă că 30 procente din greutăți vor fi setate la 0. Rețineți că abandonul are loc numai în timpul fazei de antrenament. Funcția cnn_model_fn are un mod argument pentru a declara dacă modelul trebuie instruit sau evaluat.

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: Logit Layer

În cele din urmă, 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 Layerlogits = 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") }

Vrei să returnezi predicția dicționară doar atunci când modul este setat la predicție. Adăugați aceste coduri pentru a dispune 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 ultimul tutorial, ați aflat că funcția de pierdere pentru un model multiclass este entropia încrucișată. Pierderea se calculează cu ușurință cu următorul cod:

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

Ultimul pas 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 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 valorile de performanță în timpul modului de evaluare. Valorile de performanță pentru un model multiclass sunt valorile de precizie. Tensorflow este echipat cu o precizie a modulului 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. Ați creat primul dvs. CNN și sunteți gata să înfășurați totul într-o funcție pentru a o folosi pentru a antrena și evalua modelul.

def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = 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 Layerpool2_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 Layerlogits = 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 Lossloss = 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 modeeval_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 identici cu tutorialele anterioare.

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

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

Un CNN durează de multe ori să se antreneze, 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 predictionstensors_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ă stabilim pași de antrenament de 16.000, poate dura mult timp pentru a vă antrena. Fii răbdător.

# Train the modeltrain_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 imprima rezultatele

# Evaluate the model and print resultseval_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:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO: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 schimba arhitectura, dimensiunea lotului și numărul de iterații pentru a îmbunătăți precizia. Rețeaua neuronală CNN a funcționat mult mai bine decât ANN sau regresia logistică. În tutorialul despre rețeaua neuronală artificială, ați avut o precizie de 96%, ceea ce este mai mic decât CNN. Performanțele CNN sunt impresionante cu un set de imagini mai mare , atât în ​​ceea ce privește calculul vitezei, 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 un videoclip.

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

Pasul 1: Stratul 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 de 26x26. Trebuie să specificați dacă imaginea are culoare sau nu. Dacă da, atunci ați avut 3 la forma - 3 pentru RGB-, altfel 1.

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

Pasul 2: Stratul convoluțional

Apoi, trebuie să creați straturile convoluționale. Aplicați diferite filtre pentru a permite rețelei să învețe caracteristici 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)

Pasul 3: Stratul de punere în comun

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

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

Pasul 4: Adăugați un strat convoluțional și un strat comun

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

Pasul 5: Stratul dens

Pasul 5 îl aplatizează pe cel anterior 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)

Pasul 6: Logit Layer

Ultimul pas este predicția.

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