TensorFlow pildiklassifikatsioon: CNN (konvolutsiooniline närvivõrk)

Mis on konvolutsiooniline närvivõrk?

Konvolutsiooniline närvivõrk, tuntud ka kui convnets või CNN, on arvutinägemisrakendustes tuntud meetod. Seda tüüpi arhitektuur on domineeriv objektide tuvastamiseks pildilt või videolt.

Selles õpetuses saate teada, kuidas konveti koostada ja kuidas kasutada käsikirjalise andmekogumi lahendamiseks rakendust TensorFlow.

Selles õpetuses saate teada

• Konvolutsiooniline närvivõrk
• Konvolutsioonilise närvivõrgu arhitektuur
• Convnetide komponendid
• Rongige CNN-i TensorFlow abil
• 1. samm: laadige üles andmekogum
• 2. samm: sisendkiht
• 3. samm: konvolutsiooniline kiht
• 4. samm: kihi ühendamine
• 5. samm: teine ​​konvolutsiooniline kiht ja ühendamise kiht
• 6. samm: tihe kiht
• 7. samm: Logit Layer

Konvolutsioonilise närvivõrgu arhitektuur

Mõelge paar aastat tagasi Facebookile, kui teil oli pilt oma profiilile üles laaditud, paluti teil pildil olevale näole käsitsi nimi lisada. Tänapäeval kasutab Facebook convnetit, et sildistada teie sõber pildil automaatselt.

Konvolutsioonilist närvivõrku pole eriti raske mõista. Sisendkujutist töödeldakse konvolutsioonifaasis ja sellele omistatakse hiljem silt.

Tüüpilise convnet-arhitektuuri võib kokku võtta alloleval pildil. Kõigepealt lükatakse pilt võrku; seda nimetatakse sisendkujutiseks. Seejärel läbib sisendkujutis lõpmatu arvu samme; see on võrgu konvolutsiooniline osa. Lõpuks saab närvivõrk ennustada pildil olevat numbrit.

Pilt koosneb kõrguse ja laiusega pikslitest. Halltoonis pildil on ainult üks kanal, värvilisel pildil aga kolm kanalit (igaühel punane, roheline ja sinine). Kanal on virnastatud üksteise kohal. Selles õpetuses kasutate ainult ühe kanaliga halltoonipilti. Igal pikslil on väärtus vahemikus 0 kuni 255, et kajastada värvi intensiivsust. Näiteks 0-ga võrdne piksel näitab valget värvi, samas kui piksel väärtusega 255 on tumedam.

Vaatame MNIST-i andmekogumisse salvestatud pilti. Alloleval pildil on näha, kuidas vasakpoolset pilti maatriksvormingus kujutada. Pange tähele, et algne maatriks on standarditud vahemikku 0 kuni 1. Tumedama värvi korral on maatriksi väärtus umbes 0,9, valgetel pikslitel aga 0.

Konvolutsiooniline operatsioon

Mudeli kõige kriitilisem komponent on konvolutsiooniline kiht. Selle osa eesmärk on vähendada pildi suurust raskuste kiiremaks arvutamiseks ja parandada selle üldistust.

Konvolutsioonilise osa ajal hoiab võrk pildi põhijooni ja välistab ebaolulise müra. Näiteks õpib mudel elevandi tuvastamist pildilt, mille taustal on mägi. Kui kasutate traditsioonilist närvivõrku, määrab mudel kõigile pikslitele kaalu, sealhulgas mäest pärit pikslitele, mis pole hädavajalik ja võib võrku eksitada.

Selle asemel kasutab konvolutsiooniline närvivõrk matemaatilist tehnikat ainult kõige asjakohasemate pikslite eraldamiseks. Seda matemaatilist operatsiooni nimetatakse konvolutsiooniks. See tehnika võimaldab võrgul õppida igas kihis üha keerukamaid funktsioone. Konvolutsioon jagab maatriksi väikesteks tükkideks, et õppida iga tüki kõige olulisemaid elemente.

Convnetide komponendid

Convnetsi komponente on neli

1. Pöördumine
2. Mittelineaarsus (ReLU)
3. Koondamine või alamvalim
4. Klassifikatsioon (täielikult ühendatud kiht)

• Pöördumine

Konvolutsiooni eesmärk on eraldada pildil olevad objekti tunnused lokaalselt. See tähendab, et võrk õpib pildil spetsiifilisi mustreid ja suudab selle kõikjal pildil ära tunda.

Konvolutsioon on elementide kaupa korrutamine. Kontseptsiooni on lihtne mõista. Arvuti skannib osa pildist, tavaliselt mõõtmetega 3x3, ja korrutab selle filtriks. Elementide kaupa korrutamise väljundit nimetatakse funktsioonikaardiks. Seda sammu korratakse, kuni kogu pilt on skannitud. Pange tähele, et pärast konvolutsiooni vähendatakse pildi suurust.

Allpool on URL, et näha, kuidas konvolutsioon toimib.

Saadaval on arvukalt kanaleid. Allpool loetlesime mõned kanalid. Näete, et igal filtril on kindel eesmärk. Pange tähele, alloleval pildil; Kernel on filtri sünonüüm.

Allikas

Konvolutsiooni taga olev aritmeetika

Konvolutsioonifaas rakendab filtrit pildil olevale väikesele pikslite kogumile. Filter liigub mööda sisendkujutist üldise kujuga 3x3 või 5x5. See tähendab, et võrk libistab need aknad kogu sisendpildil ja arvutab konvolutsiooni. Alloleval pildil on näha, kuidas konvolutsioon toimib. Plaastri suurus on 3x3 ja väljundmaatriks on pildimaatriksi ja filtri vahelise elemendipõhise tegevuse tulemus.

Allikas

Märkate, et väljundi laius ja kõrgus võivad erineda sisendi laiusest ja kõrgusest. See juhtub piiriefekti tõttu.

Piiriefekt

Pildil on 5x5 funktsioonikaart ja 3x3 filter. Keskel on ainult üks aken, kus filter saab kuvada 3x3 ruudustiku. Väljundi funktsioonikaart kahaneb kahe paani võrra koos mõõtmetega 3x3.

Sisendmõõtmega sama väljunddimensiooni saamiseks peate lisama polsterduse. Polsterdus koosneb maatriksi mõlemale küljele õige arvu ridade ja veergude lisamisest. See võimaldab konvolutsioonil iga sisendplaadi keskele sobida. Alloleval pildil on sisendi / väljundi maatriksil sama suurus 5x5

Võrgu määratlemisel juhitakse keeratud funktsioone kolme parameetri abil:

1. Sügavus: see määrab konvolutsiooni ajal rakendatavate filtrite arvu. Eelmises näites nägite sügavust 1, see tähendab, et kasutatakse ainult ühte filtrit. Enamasti on filtreid rohkem kui üks. Alloleval pildil on näha kolme filtriga olukorras tehtud toimingud

2. Samm: see määratleb kahe viilu vahelise "piksli hüppe" arvu. Kui samm on võrdne 1-ga, liiguvad aknad piksli ühe laiusega. Kui samm on võrdne kahega, hüppavad aknad 2 piksli võrra. Kui suurendate sammu, on teil väiksemad funktsioonikaardid.

Näide samm 1

Pildi samm 2

3. Nullpolster: polsterdus on toiming, mille abil sisestatakse sisendfunktsioonide kaartide mõlemale küljele vastav arv ridu ja veergu. Sel juhul on väljundil sisendiga sama mõõde.
4. Mittelineaarsus (ReLU)

Konvolutsioonitoimingu lõpus rakendatakse väljundit mittelineaarsuse võimaldamiseks aktiveerimisfunktsiooniga. Convneti tavapärane aktiveerimisfunktsioon on Relu. Kogu negatiivse väärtusega piksel asendatakse nulliga.

• Maksimaalne koondamine

Seda sammu on lihtne mõista. Liitmise eesmärk on vähendada sisendpildi mõõtmeid. Toimingud tehakse operatsiooni arvutusliku keerukuse vähendamiseks. Mõõtmete vähendamise kaudu on võrgul arvutamiseks väiksem kaal, nii et see takistab üleliigset paigaldamist.

Selles etapis peate määratlema suuruse ja sammu. Tavaline viis sisendpildi ühendamiseks on funktsioonikaardi maksimaalse väärtuse kasutamine. Vaata allolevat pilti. "Poolimine" kuvab 4x4 funktsioonikaardi neli alamaatriksit ja tagastab maksimaalse väärtuse. Ühendamine võtab maksimaalse 2x2 massiivi väärtuse ja seejärel liigutab seda akent kahe piksli võrra. Näiteks on esimene alammaatriks [3,1,3,2], ühendamisel tagastatakse maksimaalne väärtus, mis on 3.

On veel üks ühisoperatsioon, näiteks keskmine.

See toiming vähendab funktsioonikaardi suurust agressiivselt

• Täielikult ühendatud kihid

Viimane samm seisneb traditsioonilise kunstliku närvivõrgu ülesehitamises, nagu tegite eelmises õpetuses. Ühendate kõik eelmise kihi neuronid järgmise kihiga. Sisestuspildil oleva numbri klassifitseerimiseks kasutate softmaxi aktiveerimisfunktsiooni.

Kokkuvõte:

Konvolutsiooniline närvivõrk koostab enne ennustamist erinevad kihid. Närvivõrgul on:

• Konvolutsiooniline kiht
• Relu aktiveerimise funktsioon
• Poolikiht
• Tihedalt ühendatud kiht

Konvolutsioonilised kihid rakendavad pildi allpiirkonnas erinevaid filtreid. Relu aktiveerimisfunktsioon lisab mittelineaarsust ja koondamiskihid vähendavad funktsioonikaartide mõõtmeid.

Kõik need kihid eraldavad piltidelt olulist teavet. Lõpuks edastatakse funktsioonikaart prognoosi tegemiseks esmase täielikult ühendatud kihiga, millel on softmax-funktsioon.

Rongige CNN-i TensorFlow abil

Nüüd, kui olete tuttav konnettide ehitusplokiga, olete valmis selle ka TensorFlow abil üles ehitama. Piltide klassifitseerimisel kasutame andmekogumit MNIST.

Andmete ettevalmistamine on sama mis eelmises õpetuses. Võite käivitada koodid ja hüpata otse CNN-i arhitektuuri juurde.

Järgite järgmisi samme:

1. samm: laadige üles andmekogum

2. samm: sisendkiht

3. samm: konvolutsiooniline kiht

4. samm: kihi ühendamine

5. samm: teine ​​konvolutsiooniline kiht ja ühendamise kiht

6. samm: tihe kiht

7. samm: Logit Layer

1. samm: laadige üles andmekogum

Selle URL-i jaoks on MNIST-i andmekogum koos scikitiga saadaval. Laadige see alla ja salvestage see rakendusse Allalaadimised. Saate selle üles laadida saidiga fetch_mldata ('MNIST original').

Looge rong / katsekomplekt

Peate andmekogumi jaotama train_test_split

Funktsioonide skaleerimine

Lõpuks saate funktsiooni MinMaxScaleriga skaleerida

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

Määratlege CNN

CNN kasutab pildi toorel pikslil olevaid filtreid, et õppida üksikasjade mustrit võrreldes traditsioonilise närvivõrguga globaalse mustriga. CNN-i koostamiseks peate määratlema:

1. Konvolutsiooniline kiht: rakendage funktsioonide kaardile n filtrite arvu. Pärast pöördumist peate võrku mittelineaarsuse lisamiseks kasutama Relu aktiveerimisfunktsiooni.
2. Kihtide liitmine: järgmine samm pärast konvolutsiooni on funktsiooni max alamvalimine. Selle eesmärk on vähendada funktsioonikaardi mõõtmeid, et vältida ülereguleerimist ja parandada arvutuskiirust. Max pooling on tavapärane tehnika, mis jagab funktsioonikaardid alampiirkondadeks (tavaliselt suurusega 2x2) ja hoiab ainult maksimaalseid väärtusi.
3. Täielikult ühendatud kihid: kõik eelmiste kihtide neuronid on ühendatud järgmiste kihtidega. CNN klassifitseerib märgise vastavalt konvolutsiooniliste kihtide omadustele ja vähendatakse koos liitekihiga.

CNN-i arhitektuur

• Konvolutsiooniline kiht: Rakendab 14 5x5 filtrit (eraldades 5x5 pikslit alampiirkondi) koos ReLU aktiveerimisfunktsiooniga
• Poolimise kiht: teostab maksimaalse liitmise 2x2 filtri ja sammuga 2 (mis määrab, et ühendatud piirkonnad ei kattuks)
• Konvolutsiooniline kiht: Rakendab 36 5x5 filtrit koos ReLU aktiveerimisfunktsiooniga
• 2. kihi koondamine: jällegi teostab maksimaalse liitmise 2x2 filtri ja 2 sammuga
• 1764 neuronit, väljalangemise korrigeerimise määr on 0,4 (tõenäosus 0,4, et mõni konkreetne element kukub treeningu ajal)
• Tihe kiht (Logits Layer): 10 neuronit, üks iga numbri sihtklassis (0–9).

CNN-i loomiseks on kolm olulist moodulit:

• conv2d (). Ehitab kahemõõtmelise konvolutsioonilise kihi, mille argumentidena on filtrite arv, filtrituuma suurus, polster ja aktiveerimisfunktsioon.
• max_pooling2d (). Konstrueerib kahemõõtmelise ühenduskihi, kasutades max-poolingu algoritmi.
• tihe (). Konstrueerib tiheda kihi koos peidetud kihtide ja üksustega

CNN-i loomiseks määrate funktsiooni. Vaatame üksikasjalikult, kuidas iga ehitusplokk enne üles ehitada, et kõik funktsioonis kokku panna.

2. samm: sisendkiht

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

Andmete kujuga peate määrama tenori. Selleks saate kasutada moodulit tf.reshape. Selles moodulis peate deklareerima, et tensor kujundab tensori kuju ja kuju. Esimene argument on andmete tunnused, mis on määratletud funktsiooni argumendis.

Pildil on kõrgus, laius ja kanal. MNIST-andmekogum on monokrooniline pilt, mille suurus on 28x28. Määrasime argumenti kuju partii suuruseks -1, nii et see omandaks tunnuste kuju "" x "]. Eeliseks on partii suuruse hüperparameetrite häälestamine. Kui partii suuruseks on seatud 7, siis toidab tensor 5488 väärtust (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)

Esimesel konvolutsioonilisel kihil on 14 sama polsterdusega filtrit, mille tuuma suurus on 5x5. Sama polster tähendab, et nii väljund- kui ka sisendsensoril peaks olema sama kõrgus ja laius. Tensorflow lisab ridadele ja veergudele sama suuruse tagamiseks nullid.

Kasutate Relu aktiveerimisfunktsiooni. Väljundi suurus on [28, 28, 14].

4. samm: kihi ühendamine

Järgmine samm pärast konvolutsiooni on koondarvutamine. Koondarvutamine vähendab andmete mõõtmeid. Võite kasutada moodulit max_pooling2d suurusega 2x2 ja sammuga 2. Sisendina kasutate eelmist kihti. Väljundi suurus on [partii_suurus, 14, 14, 14]

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

5. samm: teine ​​konvolutsiooniline kiht ja ühendamise kiht

Teisel konvolutsioonilisel kihil on 32 filtrit, väljundsuurus on [batch_size, 14, 14, 32]. Liitekihi suurus on sama kui varem ja väljundkuju on [partii_suurus, 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. samm: tihe kiht

Seejärel peate määratlema täielikult ühendatud kihi. Funktsioonikaart tuleb enne tiheda kihiga ühendamist tasandada. Võite kasutada mooduli ümberkujundamist suurusega 7 * 7 * 36.

Tihe kiht ühendab 1764 neuronit. Lisate Relu aktiveerimisfunktsiooni. Lisaks lisate väljalangemise seadustamistermini kiirusega 0,3, mis tähendab, et 30 protsenti raskustest seatakse väärtusele 0. Pange tähele, et väljalangemine toimub ainult treeningfaasis. Funktsioonil cnn_model_fn on argumendirežiim, et deklareerida, kas mudelit tuleb koolitada või hinnata.

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

Lõpuks saate mudeli ennustusega määratleda viimase kihi. Väljundkuju võrdub partii suurusega ja 10, piltide koguarv.

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

Saate luua sõnastiku, mis sisaldab klasse ja iga klassi tõenäosust. Moodul tf.argmax () tagastab suurima väärtuse, kui logit kihistab. Funktsioon Softmax tagastab iga klassi tõenäosuse.

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

Sõnaraamatu ennustus tagastatakse ainult siis, kui režiim on seatud ennustuseks. Lisate need koodid ennustuste levitamiseks

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

Järgmine samm seisneb mudeli kaotuse arvutamises. Viimases õpetuses õppisite, et mitmeklassi mudeli kadumisfunktsioon on rist-entroopia. Kahju saab hõlpsasti arvutada järgmise koodiga:

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

Viimane samm on mudeli optimeerimine, see tähendab kaalude parimate väärtuste leidmine. Selleks kasutate gradientide laskumise optimeerijat, mille õppemäär on 0,001. Eesmärk on minimeerida kahju

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

CNN-iga olete valmis. Siiski soovite hindamisrežiimis kuvada toimivusmõõdikud. Mitmeklassi mudeli toimivusmõõdikud on täpsusmõõdikud. Tensorflow on varustatud mooduli täpsusega, millel on kaks argumenti, sildid ja ennustatud väärtused.

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)

See selleks. Lõite oma esimese CNN-i ja olete valmis kõik funktsiooniks pakkima, et seda mudeli koolitamiseks ja hindamiseks kasutada.

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)

Allpool olevad toimingud on samad kui eelmised õpetused.

Kõigepealt määrate CNN-mudeliga hinnangu.

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

CNN-i treenimiseks kulub mitu korda, seetõttu loote logimiskonks Softmax-kihtide väärtuste salvestamiseks iga 50 iteratsiooni järel.

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

Olete valmis mudelit hindama. Määrate partii suuruseks 100 ja segate andmed kokku. Pange tähele, et määrasime treeningusammudeks 16.000, treenimiseks võib kuluda palju aega. Ole kannatlik.

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

Nüüd, kui mudel on rongis, saate seda hinnata ja tulemused välja printida

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

Praeguse arhitektuuri abil saate täpsuse 97%. Täpsuse parandamiseks saate muuta arhitektuuri, partii suurust ja korduste arvu. CNN-i närvivõrk on toiminud palju paremini kui ANN või logistiline regressioon. Kunstnärvivõrgu õpetuses oli täpsus 96%, mis on madalam CNN-st. Etendused CNN on muljetavaldav suurema pildi komplekt , nii mõiste kiirus arvutamise ja täpsust.

Kokkuvõte

Konvolutsiooniline närvivõrk töötab pildi hindamiseks väga hästi. Seda tüüpi arhitektuur on domineeriv objektide tuvastamiseks pildilt või videolt.

CNN-i loomiseks peate järgima kuut sammu:

1. samm: sisendkiht:

See samm kujundab andmed ümber. Kuju on võrdne pikslite arvu ruutjuurega. Näiteks kui pildil on 156 pikslit, on kuju 26x26. Peate määrama, kas pildil on värvi või mitte. Kui jah, siis oli teil RGB jaoks 3 kuju - 3, muidu 1.

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

2. samm: konvolutsiooniline kiht

Järgmisena peate looma konvolutsioonilised kihid. Rakendate erinevaid filtreid, et võrk saaks olulisi funktsioone õppida. Määrate kerneli suuruse ja filtrite hulga.

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

3. samm: kihi ühendamine

Kolmandas etapis lisate ühenduskihi. See kiht vähendab sisendi suurust. Ta teeb seda, võttes alammaatriksi maksimaalse väärtuse. Näiteks kui alammaatriks on [3,1,3,2], tagastab koondamine maksimumi, mis on 3.

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

4. samm: lisage konvolutsiooniline kiht ja ühenduskiht

Selles etapis saate lisada nii palju kui soovite konv-kihte ja kihtide liitmist. Google kasutab arhitektuuri, millel on üle 20 konv-kihi.

5. samm: tihe kiht

5. samm tasandab eelmise täielikult ühendatud kihtide loomiseks. Selles etapis saate kasutada erinevat aktiveerimisfunktsiooni ja lisada väljalangemise efekti.

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

Viimane samm on ennustus.

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