„TensorFlow“ vaizdo klasifikacija: CNN (konvoliucinis neuroninis tinklas)

Turinys:

Anonim

Kas yra konvoliucinis neuroninis tinklas?

Konvoliucinis neuroninis tinklas, taip pat žinomas kaip „convnets“ arba CNN, yra gerai žinomas metodas kompiuterinėse regėjimo programose. Šio tipo architektūra dominuoja atpažinti objektus iš paveikslėlio ar vaizdo įrašo.

Šioje pamokoje sužinosite, kaip sukurti „convnet“ ir kaip naudoti „TensorFlow“ norint išspręsti ranka parašytą duomenų rinkinį.

Šioje pamokoje sužinosite

  • Konvoliucinis neuroninis tinklas
  • Konvolucinio neuroninio tinklo architektūra
  • „Convnets“ komponentai
  • Traukite CNN naudodami „TensorFlow“
  • 1 veiksmas: įkelkite duomenų rinkinį
  • 2 žingsnis: įvesties sluoksnis
  • 3 žingsnis: konvoliucinis sluoksnis
  • 4 žingsnis: sluoksnio sujungimas
  • 5 žingsnis: Antrasis konvoliucinis ir sujungimo sluoksnis
  • 6 žingsnis: tankus sluoksnis
  • 7 žingsnis: „Logit Layer“

Konvolucinio neuroninio tinklo architektūra

Pagalvokite apie „Facebook“ prieš kelerius metus, kai įkėlėte paveikslėlį į savo profilį, jūsų paprašė rankiniu būdu pridėti vardą prie paveikslėlio veido. Šiais laikais „Facebook“ naudoja „convnet“, kad automatiškai pažymėtų jūsų draugą paveikslėlyje.

Konvoliucinį neuroninį tinklą suprasti nėra labai sunku. Įvesties vaizdas apdorojamas konvoliucijos fazėje ir vėliau jam priskiriama etiketė.

Tipinę convnet architektūrą galima apibendrinti paveikslėlyje žemiau. Visų pirma vaizdas perkeliamas į tinklą; tai vadinama įvesties vaizdu. Tada įvesties vaizdas eina be galo daug žingsnių; tai konvoliucinė tinklo dalis. Galiausiai neuroninis tinklas gali nuspėti paveikslo skaitmenį.

Vaizdą sudaro pikselių masyvas su aukščiu ir pločiu. Pilkos spalvos vaizde yra tik vienas kanalas, o spalvotame - trys kanalai (kiekvienas skirtas raudonai, žaliai ir mėlynai). Kanalas sukrautas vienas ant kito. Šioje pamokoje naudosite pilkos spalvos vaizdą tik su vienu kanalu. Kiekvieno taško vertė yra nuo 0 iki 255, kad atspindėtų spalvos intensyvumą. Pavyzdžiui, taškas, lygus 0, rodys baltą spalvą, o taškas, kurio vertė artima 255, bus tamsesnė.

Pažvelkime į vaizdą, saugomą MNIST duomenų rinkinyje. Žemiau pateiktame paveikslėlyje parodyta, kaip kairiosios nuotraukos atvaizduoti matricos formatu. Atminkite, kad pradinė matrica buvo standartizuota tarp 0 ir 1. Tamsioms spalvoms matricos vertė yra apie 0,9, o baltų taškų vertė yra 0.

Konvoliucinė operacija

Kritiškiausias komponentas modelyje yra konvoliucinis sluoksnis. Šia dalimi siekiama sumažinti vaizdo dydį, kad būtų galima greičiau apskaičiuoti svorius, ir pagerinti jo apibendrinimą.

Konvoliucinės dalies metu tinklas išlaiko esminius vaizdo bruožus ir pašalina nereikšmingą triukšmą. Pavyzdžiui, modelis mokosi atpažinti dramblį iš paveikslėlio, kurio fone yra kalnas. Jei naudojate tradicinį neuroninį tinklą, modelis priskiria svorį visiems pikseliams, įskaitant kalno taškus, kuris nėra būtinas ir gali klaidinti tinklą.

Vietoj to, konvoliucinis neuroninis tinklas naudos matematinę techniką, kad išgautų tik aktualiausius taškus. Ši matematinė operacija vadinama konvoliucija. Ši technika leidžia tinklui išmokti vis sudėtingesnių funkcijų kiekviename sluoksnyje. Konvoliucija padalija matricą į mažus gabalėlius, kad išmoktų svarbiausius kiekvieno kūrinio elementus.

„Convnets“ komponentai

Yra keturi „Convnets“ komponentai

  1. Konvoliucija
  2. Netiesiškumas (ReLU)
  3. Apibendrinimas arba antrinė atranka
  4. Klasifikacija (visiškai sujungtas sluoksnis)
  • Konvoliucija

Konvoliucijos tikslas yra lokaliai išgauti objekto ypatybes vaizde. Tai reiškia, kad tinklas išmoks konkrečių paveikslėlio modelių ir galės juos atpažinti visur paveikslėlyje.

Konvoliucija yra elementinis dauginimas. Šią koncepciją lengva suprasti. Kompiuteris nuskaitys dalį paveikslėlio, kurio dydis paprastai yra 3x3, ir padaugins jį į filtrą. Elementinio dauginimo išvestis vadinama funkcijų žemėlapiu. Šis veiksmas kartojamas tol, kol bus nuskaitytas visas vaizdas. Atkreipkite dėmesį, kad po konvoliucijos vaizdo dydis sumažėja.

Žemiau yra URL, kuriame galite pamatyti, kaip veikia konvoliucija.

Yra daugybė kanalų. Žemiau išvardijome keletą kanalų. Matote, kad kiekvienas filtras turi tam tikrą tikslą. Atkreipkite dėmesį, paveikslėlyje žemiau; branduolys yra filtro sinonimas.

Šaltinis

Konvoliucijos aritmetika

Konvoliucijos fazėje filtras bus pritaikytas mažam paveikslėlyje esančių taškų rinkiniui. Filtras judės išilgai įvesties vaizdo, kurio bendra forma yra 3x3 arba 5x5. Tai reiškia, kad tinklas slinks šiuos langus per visą įvesties vaizdą ir apskaičiuos konvoliuciją. Žemiau pateiktame paveikslėlyje parodyta, kaip veikia konvoliucija. Pataisos dydis yra 3x3, o išvesties matrica yra elemento operacijos tarp vaizdo matricos ir filtro rezultatas.

Šaltinis

Pastebite, kad išvesties plotis ir aukštis gali skirtis nuo įvesties pločio ir aukščio. Tai atsitinka dėl sienos efekto.

Pasienio efektas

Paveikslėlyje yra 5x5 funkcijų žemėlapis ir 3x3 filtras. Centre yra tik vienas langas, kuriame filtras gali rodyti 3x3 tinklelį. Išvesties funkcijų žemėlapis sumažės dviem plytelėmis kartu su 3x3 matmenimis.

Norėdami gauti tą patį išvesties matmenį kaip ir įvesties aspektas, turite pridėti užpildą. Pildymas susideda iš tinkamo eilučių ir stulpelių skaičiaus pridėjimo kiekvienoje matricos pusėje. Tai leis konvekcijai sutalpinti kiekvieną įvesties plytelę. Žemiau esančiame paveikslėlyje įvesties / išvesties matricos matmenys yra 5x5

Kai apibrėžiate tinklą, sujungtos funkcijos valdomos trimis parametrais:

  1. Gylis: Jis nurodo filtrų, taikomų konvoliucijos metu, skaičių. Ankstesniame pavyzdyje matėte gylį 1, tai reiškia, kad naudojamas tik vienas filtras. Daugeliu atvejų yra daugiau nei vienas filtras. Žemiau esančiame paveikslėlyje parodytos operacijos, atliktos esant trims filtrams

  1. Žingsnis: Jis apibrėžia „pikselio šuolio“ skaičių tarp dviejų riekių. Jei žingsnis yra lygus 1, langai juda pikseliu pasklidę po vieną. Jei žingsnis lygus dviem, langai šoktels 2 taškais. Jei padidinsite žingsnį, turėsite mažesnius funkcijų žemėlapius.

1 žingsnio pavyzdys

Vaizdo žingsnis 2

  1. Nulinis užpildymas: užpildymas yra atitinkamo eilučių ir stulpelių skaičiaus pridėjimo kiekvienoje įvesties funkcijų žemėlapių pusėje operacija. Šiuo atveju išvestis turi tą patį matmenį kaip ir įvestis.
  2. Netiesiškumas (ReLU)

Konvoliucijos operacijos pabaigoje išėjimui taikoma aktyvavimo funkcija, kad būtų galima atlikti netiesiškumą. Įprasta „convnet“ aktyvavimo funkcija yra „Relu“. Visi pikseliai su neigiama reikšme bus pakeisti nuliu.

  • Didžiausio telkimo operacija

Šį žingsnį lengva suprasti. Sujungimo tikslas yra sumažinti įvesties vaizdo matmenis. Veiksmai atliekami siekiant sumažinti operacijos skaičiavimo sudėtingumą. Sumažindamas matmenis, tinklas turi mažesnį svorį, kurį reikia apskaičiuoti, todėl jis neleidžia per daug įrengti.

Šiame etape turite apibrėžti dydį ir žingsnį. Standartinis būdas sujungti įvesties vaizdą yra naudoti maksimalią funkcijų žemėlapio vertę. Pažvelkite į paveikslėlį žemiau. „Sujungimas“ parodys keturias 4x4 funkcijų žemėlapio submatricas ir pateiks maksimalią vertę. Sujungiant nustatoma didžiausia 2x2 masyvo reikšmė ir tada perkelkite šiuos langus dviem pikseliais. Pavyzdžiui, pirmoji matrica yra [3,1,3,2], sujungus grąžinama maksimali vertė, kuri yra 3.

Yra dar viena telkimo operacija, tokia kaip vidurkis.

Ši operacija agresyviai sumažina funkcijų žemėlapio dydį

  • Visiškai sujungti sluoksniai

Paskutinis žingsnis susideda iš tradicinio dirbtinio neuroninio tinklo sukūrimo, kaip jūs darėte ankstesnėje pamokoje. Jūs sujungiate visus ankstesnio sluoksnio neuronus su kitu sluoksniu. Norėdami klasifikuoti skaičių įvesties vaizde, naudojate „softmax“ aktyvinimo funkciją.

Apibendrinimas:

Konvoliucinis neuroninis tinklas, prieš atlikdamas prognozę, kaupia skirtingus sluoksnius. Neuroninis tinklas turi:

  • Konvoliucinis sluoksnis
  • „Relu“ aktyvinimo funkcija
  • Pooling sluoksnis
  • Tankiai sujungtas sluoksnis

Konvoliuciniai sluoksniai paveikslėlio paregionyje taiko skirtingus filtrus. „Relu“ aktyvinimo funkcija prideda netiesiškumą, o kaupiantys sluoksniai sumažina funkcijų žemėlapių matmenį.

Visi šie sluoksniai iš vaizdų išskiria esminę informaciją. Pagaliau funkcijų žemėlapis pateikiamas į pirminį visiškai sujungtą sluoksnį su „softmax“ funkcija, kad būtų galima numatyti.

Traukite CNN naudodami „TensorFlow“

Dabar, kai esate susipažinę su konvekų bloku, esate pasirengę jį sukurti naudodami „TensorFlow“. Vaizdų klasifikavimui naudosime MNIST duomenų rinkinį.

Duomenų paruošimas yra toks pats kaip ankstesnės mokymo programos. Galite paleisti kodus ir pereiti tiesiai prie CNN architektūros.

Atlikite šiuos veiksmus:

1 veiksmas: įkelkite duomenų rinkinį

2 žingsnis: įvesties sluoksnis

3 žingsnis: konvoliucinis sluoksnis

4 žingsnis: sluoksnio sujungimas

5 žingsnis: Antrasis konvoliucinis ir sujungimo sluoksnis

6 žingsnis: tankus sluoksnis

7 žingsnis: „Logit Layer“

1 veiksmas: įkelkite duomenų rinkinį

MNIST duomenų rinkinį galima įsigyti su „scikit“, kad galėtumėte mokytis šiuo URL. Atsisiųskite ir išsaugokite atsisiuntimuose. Galite jį įkelti naudodami „fetch_mldata“ („MNIST originalas“).

Sukurkite traukinių / testų rinkinį

Turite padalyti duomenų rinkinį su train_test_split

Sumažinkite ypatybes

Galiausiai galite išplėsti funkciją naudodami „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:]

Apibrėžkite CNN

CNN naudoja neapdoroto vaizdo taško filtrus, kad sužinotų išsamią modelio palyginimo su visuotiniu modeliu su tradiciniu neuroniniu tinklu modelį. Norėdami sukurti CNN, turite apibrėžti:

  1. Konvoliucinis sluoksnis: pritaikykite n filtrų skaičių funkcijų žemėlapyje. Po konvoliucijos turite naudoti „Relu“ aktyvinimo funkciją, kad tinkle galėtumėte pridėti netiesiškumą.
  2. „Pooling layer“: kitas žingsnis po konvoliucijos yra maksimalus objekto pavyzdys. Tikslas yra sumažinti funkcijų žemėlapio matmenis, kad būtų išvengta per didelio pritaikymo ir pagerintas skaičiavimo greitis. „Max pooling“ yra įprasta technika, pagal kurią objektų žemėlapiai padalijami į subregionus (paprastai 2x2 dydžio) ir išlaikomos tik didžiausios vertės.
  3. Visiškai sujungti sluoksniai: visi ankstesnių sluoksnių neuronai yra prijungti prie kitų sluoksnių. CNN klasifikuos etiketę pagal ypatybes iš konvoliucinių sluoksnių ir sumažino kartu su kaupimo sluoksniu.

CNN architektūra

  • Konvoliucinis sluoksnis: Taiko 14 5x5 filtrų (išskiria 5x5 pikselių subregionus) su „ReLU“ aktyvavimo funkcija
  • „Pooling Layer“: atlieka maksimalų kaupimą naudodamas 2x2 filtrą ir 2 žingsnį (nurodant, kad sutelkti regionai nesutampa)
  • Konvoliucinis sluoksnis: Taikomi 36 5x5 filtrai su „ReLU“ aktyvavimo funkcija
  • 2 sluoksnio sujungimas: Vėlgi, maksimaliai sujungiama su 2x2 filtru ir 2 žingsniu
  • 1764 neuronai, kurių išmetimo reguliavimo greitis yra 0,4 (tikimybė 0,4, kad bet kuris konkretus elementas bus nuleistas treniruotės metu)
  • Tankus sluoksnis („Logits Layer“): 10 neuronų, po vieną kiekvienai skaitmenų tikslinei klasei (0–9).

CNN sukūrimui reikia naudoti tris svarbius modulius:

  • conv2d (). Konstruoja dvimatį konvoliucinį sluoksnį su argumentais kaip filtrų skaičius, filtro branduolio dydis, užpildymas ir aktyvinimo funkcija.
  • max_pooling2d (). Naudodamas „max-pooling“ algoritmą, sukuria dvimatį kaupimo sluoksnį.
  • tankus (). Konstruoja tankų sluoksnį su paslėptais sluoksniais ir vienetais

Apibrėžsite CNN sukūrimo funkciją. Pažiūrėkime išsamiai, kaip sukonstruoti kiekvieną statybinį elementą, kad viskas būtų sujungta į funkciją.

2 žingsnis: įvesties sluoksnis

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

Turite apibrėžti tenzorą su duomenų forma. Tam galite naudoti modulį tf.reshape. Šiame modulyje turite deklaruoti, kad tenoras keičiasi ir tenoro forma. Pirmasis argumentas yra duomenų ypatybės, apibrėžtos funkcijos argumente.

Paveikslėlis turi aukštį, plotį ir kanalą. MNIST duomenų rinkinys yra monochroninis paveikslėlis, kurio dydis yra 28x28. Formos argumente paketo dydį nustatome į -1, kad jis įgytų požymių ["x"] formą. Privalumas yra suderinti partijos dydžio hiperparametrus. Jei nustatomas 7 partijos dydis, tenzorius pateikia 5488 reikšmes (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)

Pirmajame konvoliuciniame sluoksnyje yra 14 filtrų, kurių branduolio dydis yra 5x5, su tuo pačiu užpildu. Tas pats užpildas reiškia, kad tiek išvesties, tiek įvesties įtempiklio aukštis ir plotis turėtų būti vienodi. „Tensorflow“ pridės nulis prie eilučių ir stulpelių, kad būtų užtikrintas tas pats dydis.

Jūs naudojate „Relu“ aktyvavimo funkciją. Išvesties dydis bus [28, 28, 14].

4 žingsnis: sluoksnio sujungimas

Kitas žingsnis po konvoliucijos yra telkimo skaičiavimas. Apskaičiuojant duomenis bus sumažintas duomenų matmuo. Galite naudoti „max_pooling2d“ modulį, kurio dydis yra 2x2 ir žingsnis - 2. Kaip įvestį naudojate ankstesnį sluoksnį. Išvesties dydis bus [batch_size, 14, 14, 14]

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

5 žingsnis: Antrasis konvoliucinis ir sujungimo sluoksnis

Antrasis konvoliucinis sluoksnis turi 32 filtrus, kurių išvesties dydis yra [partijos dydis, 14, 14, 32]. Sujungimo sluoksnio dydis yra toks pat kaip ir anksčiau, o išvesties forma yra [partijos dydis, 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 žingsnis: tankus sluoksnis

Tada turite apibrėžti visiškai prijungtą sluoksnį. Prieš jungiant su tankiu sluoksniu, žemėlapis turi būti išlygintas. Galite naudoti modulio pertvarkymą, kurio dydis yra 7 * 7 * 36.

Tankus sluoksnis sujungs 1764 neuronus. Pridedate „Relu“ aktyvinimo funkciją. Be to, pridedate nubraukimo reguliavimo terminą, kurio norma yra 0,3, o tai reiškia, kad 30 procentų svorių bus nustatyta į 0. Atkreipkite dėmesį, kad atmetimas vyksta tik mokymo etape. Funkcijoje cnn_model_fn yra argumentų režimas, skirtas deklaruoti, ar modelį reikia mokyti, ar įvertinti.

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 žingsnis: „Logit Layer“

Galiausiai galite apibrėžti paskutinį sluoksnį su modelio prognoze. Išvesties forma lygi partijos dydžiui ir 10 - visam vaizdų skaičiui.

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

Galite sukurti žodyną, kuriame būtų pamokos ir kiekvienos klasės tikimybė. Modulis tf.argmax () with grąžina didžiausią vertę, jei logit sluoksniai. Funkcija „softmax“ pateikia kiekvienos klasės tikimybę.

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

Žodyno prognozę norite grąžinti tik tada, kai režimas nustatytas į numatymą. Pridėsite šiuos kodus, kad išsklaidytumėte prognozes

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

Kitas žingsnis - apskaičiuoti modelio nuostolius. Paskutinėje pamokoje sužinojote, kad daugiasluoksnio modelio nuostolių funkcija yra kryžminė entropija. Nuostolis lengvai apskaičiuojamas naudojant šį kodą:

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

Paskutinis žingsnis yra optimizuoti modelį, tai yra rasti geriausias svorių vertes. Tam naudojate gradiento nusileidimo optimizavimo priemonę, kurios mokymosi greitis yra 0,001. Tikslas yra sumažinti nuostolius

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

Jums viskas baigta su CNN. Tačiau vertinimo režimu norite rodyti našumo metriką. Daugiasluoksnio modelio našumo metrika yra tikslumo metrika. „Tensorflow“ yra modulio tikslumas su dviem argumentais - etiketėmis ir numatomomis reikšmėmis.

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)

Viskas. Jūs sukūrėte savo pirmąjį CNN ir esate pasirengęs viską apjungti į funkciją, kad ją panaudotumėte mokyti ir įvertinti modelį.

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)

Toliau nurodyti veiksmai yra tokie patys kaip ankstesnių mokymo programų.

Visų pirma, jūs nustatote įvertintoją naudodami CNN modelį.

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

CNN treniruotis reikia daug kartų, todėl jūs sukursite „Logging“ kablį, kad išsaugotumėte „softmax“ sluoksnių vertes kas 50 kartojimų.

# 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 esate pasirengęs įvertinti modelį. Jūs nustatote 100 paketo dydį ir maišote duomenis. Atkreipkite dėmesį, kad mes nustatėme 16 000 treniruočių žingsnius. Tai gali užtrukti daug laiko treniruotis. Būk kantrus.

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

Dabar, kai modelis yra traukinys, galite jį įvertinti ir atspausdinti rezultatus

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

Naudodami dabartinę architektūrą, jūs gaunate 97% tikslumą. Norėdami pagerinti tikslumą, galite pakeisti architektūrą, paketo dydį ir kartojimo skaičių. CNN neuroninis tinklas pasirodė kur kas geriau nei ANN arba logistinė regresija. Dirbtinio neuroninio tinklo pamokoje jūsų tikslumas buvo 96%, o tai yra mažesnė už CNN. CNN pasirodymai yra įspūdingi dėl didesnio vaizdų rinkinio tiek greičio skaičiavimo, tiek tikslumo požiūriu.

Santrauka

Konvoliucinis neuroninis tinklas labai gerai vertina vaizdą. Šio tipo architektūra dominuoja atpažinti objektus iš paveikslėlio ar vaizdo įrašo.

Norėdami sukurti CNN, turite atlikti šešis veiksmus:

1 veiksmas: įvesties sluoksnis:

Šis žingsnis pertvarko duomenis. Forma lygi taškų skaičiaus kvadratinei šaknies daliai. Pavyzdžiui, jei paveikslėlyje yra 156 pikseliai, forma yra 26x26. Turite nurodyti, ar paveikslėlyje yra spalvos, ar ne. Jei taip, tada jūs turėjote 3 formos 3 - RGB-, kitaip 1.

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

2 žingsnis: konvoliucinis sluoksnis

Tada turite sukurti konvoliucinius sluoksnius. Taikote skirtingus filtrus, kad tinklas galėtų išmokti svarbią funkciją. Nurodote branduolio dydį ir filtrų kiekį.

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

3 žingsnis: sluoksnio sujungimas

Trečiame etape pridedate kaupimo sluoksnį. Šis sluoksnis sumažina įvesties dydį. Tai daro imdama didžiausią submatricos vertę. Pavyzdžiui, jei antrinė matrica yra [3,1,3,2], sujungimas grąžins maksimumą, kuris yra 3.

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

4 žingsnis: pridėkite konvoliucinį ir sujungimo sluoksnį

Atlikdami šį veiksmą, galite pridėti tiek, kiek norite konv. Ir kaupimo sluoksnių. „Google“ naudoja architektūrą su daugiau nei 20 konv. Sluoksnių.

5 žingsnis: tankus sluoksnis

5 veiksmas išlygina ankstesnį, kad būtų sukurti visiškai prijungti sluoksniai. Šiame žingsnyje galite naudoti skirtingą aktyvinimo funkciją ir pridėti atsisakymo efektą.

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 žingsnis: „Logit Layer“

Paskutinis žingsnis yra numatymas.

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