TensorFlow attēlu klasifikācija: CNN (konvolucionālais neironu tīkls)

Kas ir konvolucionālais neironu tīkls?

Konvolucionālais neironu tīkls, kas pazīstams arī kā convnets vai CNN, ir labi pazīstama metode datoru redzes lietojumprogrammās. Šis arhitektūras veids ir dominējošs, lai atpazītu objektus no attēla vai videoklipa.

Šajā apmācībā jūs uzzināsiet, kā izveidot convnet un kā izmantot TensorFlow, lai atrisinātu ar roku rakstīto datu kopu.

Šajā apmācībā jūs uzzināsiet

• Konvolucionālais neironu tīkls
• Konvolucionālā neironu tīkla arhitektūra
• Convnets komponenti
• Vilciens CNN ar TensorFlow
• 1. darbība: augšupielādējiet datu kopu
• 2. solis: ievades slānis
• 3. solis: konvolūcijas slānis
• 4. solis: slāņa apvienošana
• 5. solis: otrais konvolūcijas slānis un apvienošanas slānis
• 6. solis: blīvs slānis
• 7. darbība: Logit Layer

Konvolucionālā neironu tīkla arhitektūra

Padomājiet par Facebook pirms dažiem gadiem, kad esat augšupielādējis attēlu savā profilā, jums tika lūgts manuāli pievienot vārdu sejas attēlam. Mūsdienās Facebook izmanto convnet, lai automātiski atzīmētu jūsu draugu attēlā.

Konvolucionālo neironu tīklu nav ļoti grūti saprast. Ievades attēls tiek apstrādāts konvekcijas fāzē un vēlāk tam tiek piešķirta iezīme.

Tipisku convnet arhitektūru var apkopot zemāk esošajā attēlā. Pirmkārt, attēls tiek ievietots tīklā; to sauc par ievades attēlu. Tad ievades attēls iziet bezgalīgi daudz soļu; šī ir tīkla konvolucionālā daļa. Visbeidzot, neironu tīkls var paredzēt ciparu uz attēla.

Attēlu veido pikseļu masīvs ar augstumu un platumu. Pelēktoņu attēlā ir tikai viens kanāls, savukārt krāsainajā attēlā ir trīs kanāli (katrs sarkanajam, zaļajam un zilajam). Kanāls ir sakrauts viens virs otra. Šajā apmācībā jūs izmantosiet pelēktoņu attēlu tikai ar vienu kanālu. Katra pikseļa vērtība ir no 0 līdz 255, lai atspoguļotu krāsas intensitāti. Piemēram, pikseļa vērtība, kas vienāda ar 0, parādīs baltu krāsu, savukārt pikseļa vērtība ar tuvu 255 būs tumšāka.

Apskatīsim attēlu, kas saglabāts MNIST datu kopā. Zemāk redzamajā attēlā parādīts, kā matricas formātā attēlot kreisās puses attēlu. Ņemiet vērā, ka sākotnējā matrica ir standartizēta starp 0 un 1. Tumšākas krāsas gadījumā matricas vērtība ir aptuveni 0,9, bet balto pikseļu vērtība ir 0.

Konvolucionārā darbība

Modeļa viskritiskākā sastāvdaļa ir konvolīcijas slānis. Šīs daļas mērķis ir samazināt attēla izmēru, lai ātrāk aprēķinātu svaru, un uzlabot tā vispārinājumu.

Konvolucionālās daļas laikā tīkls saglabā būtiskās attēla iezīmes un izslēdz neatbilstošu troksni. Piemēram, modelis mācās atpazīt ziloni no attēla, kura fonā ir kalns. Ja izmantojat tradicionālo neironu tīklu, modelis piešķirs svaru visiem pikseļiem, ieskaitot tos, kas nāk no kalna, kas nav būtiski un var maldināt tīklu.

Tā vietā konvolucionālais neironu tīkls izmantos matemātisko paņēmienu, lai iegūtu tikai visatbilstošākos pikseļus. Šo matemātisko darbību sauc par konvekciju. Šis paņēmiens ļauj tīklam katrā slānī apgūt arvien sarežģītākas funkcijas. Konvolūcija sadala matricu mazos gabalos, lai iemācītos būtiskākos elementus katrā gabalā.

Convnets komponenti

Ir četras Convnets sastāvdaļas

1. Konversija
2. Nelineārā (ReLU)
3. Apvienošana vai apakšparaugu ņemšana
4. Klasifikācija (pilnībā savienots slānis)

• Konversija

Konvolūcijas mērķis ir lokāli iegūt objekta īpašības attēlā. Tas nozīmē, ka tīkls apgūs konkrētus attēla modeļus un varēs tos atpazīt visur attēlā.

Konversija ir reizinājums ar elementiem. Jēdziens ir viegli saprotams. Dators skenēs attēla daļu, parasti ar izmēru 3x3, un to reizinās ar filtru. Elementa reizinājuma izvadi sauc par iezīmju karti. Šo darbību atkārto, līdz tiek skenēts viss attēls. Ņemiet vērā, ka pēc saspiešanas attēla izmērs tiek samazināts.

Zemāk ir URL, lai darbībā redzētu, kā darbojas konvolūcija.

Ir pieejami daudzi kanāli. Zemāk mēs uzskaitījām dažus kanālus. Var redzēt, ka katram filtram ir noteikts mērķis. Piezīme: attēlā zemāk; kodols ir filtra sinonīms.

Avots

Konvolūcijas aiz aritmētika

Konvolūzijas fāzē filtrs tiks piemērots nelielam pikseļu blokam attēlā. Filtrs pārvietosies pa ievades attēlu ar vispārēju formu 3x3 vai 5x5. Tas nozīmē, ka tīkls bīdīs šos logus pa visu ievades attēlu un aprēķinās konvekciju. Zemāk redzamais attēls parāda, kā darbojas konvolūcija. Plākstera izmērs ir 3x3, un izvades matrica ir rezultāts elementa darbībai starp attēla matricu un filtru.

Avots

Jūs ievērojat, ka izvades platums un augstums var atšķirties no ievades platuma un augstuma. Tas notiek robežas efekta dēļ.

Robežu efekts

Attēlam ir 5x5 funkciju karte un 3x3 filtrs. Centrā ir tikai viens logs, kurā filtrs var rādīt 3x3 režģi. Izvades funkciju karte samazināsies par divām flīzēm kopā ar 3x3 izmēru.

Lai iegūtu tādu pašu izvades dimensiju kā ievades dimensija, jums jāpievieno polsterējums. Polsterējums sastāv no pareizā rindu un kolonnu skaita pievienošanas katrā matricas pusē. Tas ļaus konvekcijai centrēt katru ievades elementu. Zemāk redzamajā attēlā ievades / izvades matricai ir vienāda dimensija 5x5

Kad jūs definējat tīklu, ieslēgtās funkcijas tiek kontrolētas ar trim parametriem:

1. Dziļums: tas nosaka filtru skaitu, kas jāpieliek konvolūcijas laikā. Iepriekšējā piemērā jūs redzējāt dziļumu 1, tas nozīmē, ka tiek izmantots tikai viens filtrs. Lielākajā daļā gadījumu ir vairāki filtri. Zemāk redzamajā attēlā redzamas darbības, kas veiktas situācijā ar trim filtriem

2. Stride: Tas nosaka "pikseļa lēciena" skaitu starp divām šķēlītēm. Ja solis ir vienāds ar 1, logi pārvietosies ar pikseļa izplatību vienā. Ja solis ir vienāds ar diviem, logi leks par 2 pikseļiem. Ja palielināsiet soli, jums būs mazākas funkciju kartes.

1. solis

Attēla solis 2

3. Nulles aizpildīšana: polsterējums ir darbība, kurā tiek pievienots atbilstošs rindu un kolonnu skaits katrā ievades funkciju kartes pusē. Šajā gadījumā izejai ir tāda pati dimensija kā ieejai.
4. Nelineārā (ReLU)

Konvolūcijas darbības beigās izejai tiek pakļauta aktivizācijas funkcija, lai atļautu nelinearitāti. Parastā convnet aktivizācijas funkcija ir Relu. Visi pikseļi ar negatīvu vērtību tiks aizstāti ar nulli.

• Maksimālās kopēšanas darbība

Šis solis ir viegli saprotams. Apvienošanas mērķis ir samazināt ievades attēla dimensiju. Tiek veiktas darbības, lai samazinātu operācijas skaitļošanas sarežģītību. Samazinot dimensiju, tīklam ir mazāks svars, lai to aprēķinātu, tāpēc tas novērš pārmērīgu uzstādīšanu.

Šajā posmā jums jānosaka lielums un solis. Standarta veids, kā apkopot ievades attēlu, ir izmantot iezīmju kartes maksimālo vērtību. Apskatiet attēlu zemāk. "Apvienošana" parādīs 4x4 objektu kartes četras apakšmatricas un atgriezīs maksimālo vērtību. Apvienošana ņem 2x2 masīva maksimālo vērtību un pēc tam pārvieto šo logu par diviem pikseļiem. Piemēram, pirmā apakšmatrica ir [3,1,3,2], apvienošana atgriezīs maksimumu, kas ir 3.

Ir vēl viena apvienošanas operācija, piemēram, vidējā.

Šī darbība agresīvi samazina objektu kartes lielumu

• Pilnībā savienoti slāņi

Pēdējais solis sastāv no tradicionālā mākslīgā neironu tīkla izveidošanas, kā jūs to darījāt iepriekšējā apmācībā. Jūs savienojat visus neironus no iepriekšējā slāņa ar nākamo slāni. Lai klasificētu ievades attēla numuru, jūs izmantojat softmax aktivizācijas funkciju.

Atkārtojums:

Konvolucionālais neironu tīkls pirms prognozēšanas apkopo dažādus slāņus. Neironu tīklam ir:

• Konvolucionārs slānis
• Relu aktivizēšanas funkcija
• Pooling slānis
• Blīvi savienots slānis

Konvolīcijas slāņi attēla apakšreģionā pielieto dažādus filtrus. Relu aktivizācijas funkcija papildina nelinearitāti, un apvienojošie slāņi samazina funkciju karšu dimensiju.

Visi šie slāņi no attēliem iegūst būtisku informāciju. Visbeidzot, funkciju karte tiek padota uz primāri pilnībā savienotu slāni ar softmax funkciju, lai veiktu prognozēšanu.

Vilciens CNN ar TensorFlow

Tagad, kad esat iepazinies ar konvetu veidojošo elementu, esat gatavs to izveidot ar TensorFlow. Attēlu klasifikācijai mēs izmantosim datu kopu MNIST.

Datu sagatavošana ir tāda pati kā iepriekšējā apmācībā. Jūs varat palaist kodus un pāriet tieši uz CNN arhitektūru.

Jūs izpildīsit šādas darbības:

1. darbība: augšupielādējiet datu kopu

2. solis: ievades slānis

3. solis: konvolūcijas slānis

4. solis: slāņa apvienošana

5. solis: otrais konvolūcijas slānis un apvienošanas slānis

6. solis: blīvs slānis

7. darbība: Logit Layer

1. darbība: augšupielādējiet datu kopu

MNIST datu kopa ir pieejama ar scikit, lai uzzinātu šajā URL. Lūdzu, lejupielādējiet to un saglabājiet to lejupielādēs. Varat to augšupielādēt, izmantojot fetch_mldata ('MNIST oriģināls').

Izveidojiet vilcienu / testa komplektu

Datu kopa ir jāsadala ar train_test_split

Mērogojiet funkcijas

Visbeidzot, jūs varat mērogot funkciju ar 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:]

Definējiet CNN

CNN izmanto attēla neapstrādātā pikseļa filtrus, lai uzzinātu detalizētu rakstu salīdzinājumu ar globālo modeli ar tradicionālo neironu tīklu. Lai izveidotu CNN, jums jādefinē:

1. Konvolicionāls slānis: iezīmju kartei lietojiet n filtru skaitu. Pēc konvolūcijas jums ir jāizmanto Relu aktivizācijas funkcija, lai tīklam pievienotu nelinearitāti.
2. Pooling layer: Nākamais solis pēc konvolūcijas ir objekta maks. Mērķis ir samazināt objektu kartes dimensiju, lai novērstu pārmērīgu uzstādīšanu un uzlabotu aprēķina ātrumu. Maksimālais apvienošana ir parastā metode, kas iezīmju kartes sadala apakšreģionos (parasti ar izmēru 2x2) un saglabā tikai maksimālās vērtības.
3. Pilnībā savienoti slāņi: Visi iepriekšējo slāņu neironi ir savienoti ar nākamajiem slāņiem. CNN klasificēs etiķeti atbilstoši konvolīcijas slāņu pazīmēm un samazinās ar kopējo slāni.

CNN arhitektūra

• Convolutional Layer: tiek izmantoti 14 5x5 filtri (5x5 pikseļu apakšreģionu izvilkšana) ar ReLU aktivizācijas funkciju
• Pooling Layer: veic maksimālo apvienošanu ar filtru 2x2 un soli 2 (kas norāda, ka apvienotie reģioni nepārklājas)
• Convolutional Layer: tiek izmantoti 36 5x5 filtri ar ReLU aktivizācijas funkciju
• 2. slāņa apvienošana: atkal veic maksimālo apvienošanu ar 2x2 filtru un soli 2
• 1764 neironi ar pārtraukšanas legalizācijas ātrumu 0,4 (varbūtība 0,4, ka jebkurš elements tiks nomests treniņa laikā)
• Blīvs slānis (Logits Layer): 10 neironi, pa vienam katrai ciparu mērķa klasei (0–9).

CNN izveidošanai jāizmanto trīs svarīgi moduļi:

• conv2d (). Konstruē divdimensiju konvolīcijas slāni, kā argumentus izmantojot filtru skaitu, filtra kodola izmēru, polsterējumu un aktivizācijas funkciju.
• max_pooling2d (). Izmantojot max-pooling algoritmu, izveido divdimensiju apvienošanas slāni.
• blīvs (). Konstruē blīvu slāni ar slēptajiem slāņiem un vienībām

Jūs definēsit funkciju CNN izveidei. Apskatīsim detalizēti, kā izveidot katru celtniecības bloku, pirms viss tiek iesaiņots funkcijā.

2. solis: ievades slānis

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

Jums jānosaka tenzors ar datu formu. Lai to izdarītu, varat izmantot moduli tf.reshape. Šajā modulī jums jāpaziņo tenors, lai tas pārveidotu, un tenora forma. Pirmais arguments ir datu pazīmes, kas definētas funkcijas argumentā.

Attēlam ir augstums, platums un kanāls. MNIST datu kopa ir vienkrāsains attēls ar 28x28 izmēru. Formas argumentā partijas lielumu iestatījām uz -1, lai tas iegūtu pazīmju ["x"] formu. Priekšrocība ir padarīt partijas lieluma hiperparametrus pielāgotus. Ja partijas lielums ir iestatīts uz 7, tad tenzors baro 5488 vērtības (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)

Pirmajā konvolīcijas slānī ir 14 filtri ar kodola izmēru 5x5 ar vienādu polsterējumu. Tas pats polsterējums nozīmē, ka gan izejas tenoram, gan ievades tenoram jābūt vienādam augstumam un platumam. Tensorflow pievienos nulles rindām un kolonnām, lai nodrošinātu vienādu izmēru.

Jūs izmantojat Relu aktivizācijas funkciju. Izvades lielums būs [28, 28, 14].

4. solis: slāņa apvienošana

Nākamais solis pēc konvolūcijas ir apvienošanas aprēķins. Apkopošanas aprēķins samazinās datu dimensiju. Varat izmantot moduli max_pooling2d ar izmēru 2x2 un soli 2. Jūs kā ievadi izmantojat iepriekšējo slāni. Izvades lielums būs [batch_size, 14, 14, 14]

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

5. solis: otrais konvolūcijas slānis un apvienošanas slānis

Otrajā konvolīcijas slānī ir 32 filtri, kuru izejas lielums ir [batch_size, 14, 14, 32]. Apvienošanas slānim ir tāds pats izmērs kā iepriekš, un izvades forma ir [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)

6. solis: blīvs slānis

Pēc tam jums jānosaka pilnībā savienotais slānis. Funkciju karte ir jāsaplacina, pirms tā tiek savienota ar blīvu slāni. Jūs varat izmantot moduļa pārveidošanu ar izmēru 7 * 7 * 36.

Blīvs slānis savienos 1764 neironus. Jūs pievienojat Relu aktivizācijas funkciju. Bez tam, jūs pievienojat pametuma legalizācijas terminu ar ātrumu 0,3, kas nozīmē, ka 30 svara procenti tiks iestatīti uz 0. Ņemiet vērā, ka pametums notiek tikai apmācības posmā. Funkcijai cnn_model_fn ir argumentu režīms, lai paziņotu, vai modelis ir jāapmāca vai jānovērtē.

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)

7. darbība: Logit Layer

Visbeidzot, jūs varat definēt pēdējo slāni ar modeļa prognozi. Izejas forma ir vienāda ar partijas lielumu un 10 - kopējo attēlu skaitu.

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

Jūs varat izveidot vārdnīcu, kurā ir klases un katras klases varbūtība. Modulis tf.argmax () ar atgriež lielāko vērtību, ja logit slāņi. Funkcija softmax atgriež katras klases varbūtību.

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

Vārdnīcas prognozi vēlaties atgriezt tikai tad, kad režīms ir iestatīts uz paredzēšanu. Jūs pievienojat šos kodus, lai izkliedētu prognozes

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

Nākamais solis sastāv no modeļa zaudējuma aprēķināšanas. Pēdējā apmācībā jūs uzzinājāt, ka daudzklasīga modeļa zaudēšanas funkcija ir krusteniskā entropija. Zaudējumus var viegli aprēķināt, izmantojot šādu kodu:

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

Pēdējais solis ir modeļa optimizācija, tas ir, atrast labākās svaru vērtības. Tam izmantojat gradienta nolaišanās optimizētāju ar mācīšanās ātrumu 0,001. Mērķis ir samazināt zaudējumus

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

Jūs esat pabeidzis ar CNN. Tomēr novērtēšanas režīmā vēlaties parādīt veiktspējas metriku. Daudzklases modeļa veiktspējas metrika ir precizitātes metrika. Tensorflow ir aprīkots ar moduļa precizitāti ar diviem argumentiem, etiķetēm un paredzētajām vērtībām.

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)

Tieši tā. Jūs izveidojāt savu pirmo CNN un esat gatavs visu ietīt funkcijā, lai to izmantotu modeļa apmācībai un novērtēšanai.

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)

Tālāk norādītās darbības ir tādas pašas kā iepriekšējās apmācības.

Pirmkārt, jūs definējat novērtētāju ar CNN modeli.

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

CNN trenēšanai nepieciešams daudz reižu, tāpēc jūs izveidojat mežizstrādes āķi, lai ik pēc 50 atkārtojumiem saglabātu softmax slāņu vērtības.

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

Jūs esat gatavs novērtēt modeli. Jūs iestatāt partijas lielumu 100 un sajaucat datus. Ņemiet vērā, ka mēs iestatījām apmācības soļus 16.000, tas var aizņemt daudz laika, lai apmācītu. Esi pacietīgs.

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

Tagad, kad modelis ir vilciens, varat to novērtēt un izdrukāt rezultātus

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

Izmantojot pašreizējo arhitektūru, jūs iegūstat 97% precizitāti. Lai uzlabotu precizitāti, varat mainīt arhitektūru, partijas lielumu un atkārtojuma skaitu. CNN neironu tīkls ir darbojies daudz labāk nekā ANN vai loģistiskā regresija. Mākslīgā neironu tīkla apmācībā jums bija 96% precizitāte, kas ir zemāka par CNN. CNN sniegums ir iespaidīgs ar lielāku attēlu kopu gan ātruma aprēķināšanas, gan precizitātes ziņā.

Kopsavilkums

Konvolucionālais neironu tīkls ļoti labi darbojas, lai novērtētu attēlu. Šis arhitektūras veids ir dominējošs, lai atpazītu objektus no attēla vai videoklipa.

Lai izveidotu CNN, jums ir jāveic sešas darbības:

1. darbība: ievades slānis:

Šis solis pārveido datus. Forma ir vienāda ar pikseļu skaita kvadrātsakni. Piemēram, ja attēlam ir 156 pikseļi, forma ir 26x26. Jums jānorāda, vai attēlam ir krāsa vai nav. Ja jā, tad jums bija 3 pēc formas RGB- 3, pretējā gadījumā 1.

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

2. solis: konvolūcijas slānis

Tālāk jums jāizveido konvolucionālie slāņi. Jūs izmantojat dažādus filtrus, lai tīkls varētu apgūt svarīgu funkciju. Jūs norādāt kodola lielumu un filtru daudzumu.

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

3. solis: slāņa apvienošana

Trešajā solī pievienojat apvienošanas slāni. Šis slānis samazina ievades lielumu. Tas tiek darīts, ņemot maksimālo apakšmatricas vērtību. Piemēram, ja apakšmatrica ir [3,1,3,2], apvienošana atgriezīs maksimumu, kas ir 3.

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

4. solis: pievienojiet konvolūcijas slāni un kopējo slāni

Šajā solī varat pievienot tik daudz, cik vēlaties konv. Un apvienojošos slāņus. Google izmanto arhitektūru ar vairāk nekā 20 konv. Slāņiem.

5. solis: blīvs slānis

5. solis izlīdzina iepriekšējo, lai izveidotu pilnībā savienotus slāņus. Šajā solī varat izmantot dažādas aktivizācijas funkcijas un pievienot izstumšanas efektu.

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)

6. darbība: Logit Layer

Pēdējais solis ir pareģošana.

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