CNN-i piltide klassifikatsioon TensorFlow's koos sammude ja näidetega

Mis on konvolutsiooniline närvivõrk?

Konvolutsiooniline närvivõrk, tuntud ka kui convnets või CNN, on arvuti nägemise rakendustes hästi tuntud meetod. See on sügavate närvivõrkude klass, mida kasutatakse visuaalsete kujutiste analüüsimiseks. Seda tüüpi arhitektuur on domineeriv objektide tuvastamisel pildilt või videolt. Seda kasutatakse sellistes rakendustes nagu pildi- või videotuvastus, närvikeele töötlemine jne.

Archikonvolutsioonilise närvivõrgu struktuur

Mõelge mõne aasta tagusele Facebookile, kui olete oma profiilile pildi üles laadinud, paluti teil pildil olevale näole nimi käsitsi lisada. Tänapäeval kasutab Facebook teie sõbra automaatseks märgistamiseks pildil convneti.

Kujutiste klassifitseerimiseks mõeldud konvolutsioonilist närvivõrku pole väga raske mõista. Sisendpilti töödeldakse konvolutsioonifaasis ja sellele omistatakse hiljem silt.

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

Pilt koosneb kõrguse ja laiusega pikslite massiivist. Halltoonides pildil on ainult üks kanal, värvilisel pildil aga kolm kanalit (igaüks punaseks, roheliseks ja siniseks). Kanal on üksteise peale virnastatud. Selles õpetuses kasutate ainult ühe kanaliga halltoonides pilti. Igal pikslil on väärtus vahemikus 0 kuni 255, et kajastada värvi intensiivsust. Näiteks piksel, mis on võrdne 0-ga, näitab valget värvi, samas kui piksel väärtusega 255 on tumedam.

Vaatame pilti, mis on salvestatud MNIST-i andmestik. Alloleval pildil on näha, kuidas kujutada vasakpoolset pilti maatriksvormingus. Pange tähele, et algne maatriks on standardiseeritud vahemikku 0 kuni 1. Tumedama värvi puhul on maatriksi väärtus umbes 0.9, valgete pikslite väärtus aga 0.

Konvolutsiooniline operatsioon

Mudeli kõige kriitilisem komponent on konvolutsioonikiht. Selle osa eesmärk on vähendada kujutise suurust, et kiirendada kaalude arvutamist ja parandada selle üldistust.

Konvolutsioonilise osa ajal säilitab võrk pildi olulised omadused ja välistab ebaolulise müra. Näiteks õpib modell elevanti ära tundma pildilt, mille taustal on mägi. Kui kasutate traditsioonilist närvivõrku, määrab mudel kõigile pikslitele, sealhulgas mäest pärit pikslitele, kaalu, mis ei ole oluline ja võib võrku eksitada.

Selle asemel, a Keras konvolutsiooniline närvivõrk kasutab matemaatilist tehnikat, et eraldada ainult kõige asjakohasemad pikslid. Seda matemaatilist operatsiooni nimetatakse konvolutsiooniks. See tehnika võimaldab võrgul õppida igal kihil järjest keerukamaid funktsioone. Konvolutsioon jagab maatriksi väikesteks tükkideks, et õppida tundma igas tükis kõige olulisemaid elemente.

Konvolutsioonilise närvivõrgu komponendid (ConvNet või CNN)

Convnetsil on neli komponenti

1. Convolution
2. Mittelineaarsus (ReLU)
3. Pooling või Sub Sampling
4. Klassifikatsioon (täielikult ühendatud kiht)

Convolution

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

Konvolutsioon on elemendipõhine korrutis. Kontseptsiooni on lihtne mõista. Arvuti skannib osa pildist, tavaliselt mõõtmetega 3 × 3, ja korrutab selle filtriks. Elemendipõhise korrutamise väljundit nimetatakse tunnuskaardiks. Seda sammu korratakse, kuni kogu pilt on skannitud. Pange tähele, et pärast keerdumist pildi suurust vähendatakse.

Allpool on URL, et näha, kuidas konvolusioon töötab.

Saadaval on palju kanaleid. Allpool loetlesime mõned kanalid. Näete, et igal filtril on konkreetne eesmärk. Märkus, alloleval pildil; Kernel on filtri sünonüüm.

Aritmeetika konvolutsiooni taga

Konvolutsioonifaas rakendab filtri pildi väikesele pikslite massiivile. Filter liigub piki sisendpilti üldkujuga 3×3 või 5×5. See tähendab, et võrk libistab need aknad üle kogu sisendpildi ja arvutab konvolutsiooni. Allolev pilt näitab, kuidas konvolutsioon töötab. Plaastri suurus on 3×3 ja väljundmaatriks on pildimaatriksi ja filtri vahelise elemendipõhise toimingu tulemus.

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 5 × 5 funktsioonide kaart ja 3 × 3 filter. Keskel on ainult üks aken, kus filter suudab ekraani 3 × 3 ruudustiku. Väljundfunktsioonide kaart kahaneb kahe paani võrra koos mõõtmetega 3 × 3.

Sisendmõõtmega sama väljundmõõtme saamiseks peate lisama polsterduse. Täitmine seisneb õige arvu ridade ja veergude lisamises maatriksi mõlemale küljele. See võimaldab konvolutsioonil keskele sobitada iga sisendplaadi. Alloleval pildil on sisend-/väljundmaatriksil sama mõõde 5 × 5

Võrgu määratlemisel juhitakse ühendatud funktsioone kolme parameetriga.

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

2. Samm: see määrab kahe lõigu vahelise pikslihüpete arvu. Kui samm on võrdne 1-ga, liiguvad aknad pikslite vahega üks. Kui samm on võrdne kahega, hüppavad aknad 2 piksli võrra. Kui suurendate sammu, on teil väiksemad funktsioonikaardid.

Sammu näide 1

samm 2

3. Nullpolster: täitmine on toiming, mille käigus lisatakse sisendfunktsioonide kaartide mõlemale küljele vastav arv ridu ja veerge. Sel juhul on väljundil sama mõõde kui sisendil.

Mittelineaarsus (ReLU)

Konvolutsioonioperatsiooni lõpus rakendatakse väljundile aktiveerimisfunktsiooni, et võimaldada mittelineaarsust. Tavaline convneti aktiveerimisfunktsioon on Relu. Kõik negatiivse väärtusega pikslid asendatakse nulliga.

Pooling Operamine

Seda sammu on lihtne mõista. Koondamise eesmärk on vähendada sisendpildi mõõtmelisust. Sammud tehakse toimingu arvutusliku keerukuse vähendamiseks. Mõõtmete vähendamisega on võrgul väiksemad kaalud, nii et see hoiab ära ülepaigutamise.

Selles etapis peate määrama suuruse ja sammu. Tavaline viis sisendkujutise koondamiseks on kasutada objektikaardi maksimaalset väärtust. Vaadake allolevat pilti. "Koondamine" kuvab 4 × 4 funktsioonikaardi nelja alammaatriksi ja tagastab maksimaalse väärtuse. Koondamisel võetakse 2 × 2 massiivi maksimaalne väärtus ja seejärel liigutatakse seda akent kahe piksli võrra. Näiteks esimene alammaatriks on [3,1,3,2], ühendamine tagastab maksimumi, mis on 3.

On veel üks koondamisoperatsioon, näiteks keskmine.

See toiming vähendab agressiivselt objektikaardi suurust

Täielikult ühendatud kihid

Viimane samm seisneb traditsioonilise ehitamises kunstlik närvivõrk nagu tegite eelmises õpetuses. Ühendate kõik neuronid eelmisest kihist järgmise kihiga. Sisendpildil oleva numbri klassifitseerimiseks kasutate softmaxi aktiveerimisfunktsiooni.

Kokkuvõte:

TensorFlow konvolutsiooniline närvivõrk koostab enne ennustuse tegemist erinevad kihid. Närvivõrgul on:

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

Konvolutsioonilised kihid rakendavad pildi alampiirkonnale erinevaid filtreid. Relu aktiveerimisfunktsioon lisab mittelineaarsust ja koondamiskihid vähendavad funktsioonide kaartide mõõtmeid.

Kõik need kihid eraldavad piltidelt olulist teavet. Lõpuks suunatakse funktsioonide kaart ennustuse tegemiseks funktsiooniga softmax esmasesse täielikult ühendatud kihti.

Treenige CNN-i TensorFlow'ga

Nüüd, kui olete convneti ehitusplokiga tuttav, olete valmis seda koos looma TensorFlow. CNN-i kujutiste klassifitseerimiseks kasutame MNIST-i andmestikku.

Andmete ettevalmistamine on sama, mis eelmises õpetuses. Saate koode käivitada ja otse CNN-i arhitektuuri juurde hüpata.

Piltide klassifitseerimiseks CNN-i abil järgige allolevaid samme.

1. toiming: laadige üles andmestik

2. samm: sisendkiht

3. samm: keerdkiht

Samm 4: Pooling kiht

5. samm: teine ​​konvolutsioonikiht ja Pooling Kiht

6. samm: tihe kiht

7. samm: Logiti kiht

1. toiming: laadige üles andmestik

MNIST-i andmestik on selle õppimiseks saadaval koos scikitiga URL. Laadige see alla ja salvestage allalaadimiste alla. Saate selle üles laadida funktsiooniga fetch_mldata ('MNIST originaal').

Looge rongi-/katsekomplekt

Peate andmestiku jagama parameetriga train_test_split

Skaalake funktsioone

Lõpuks saate funktsiooni skaleerida MinMaxScaleriga, nagu on näidatud allolevas pildiklassifikatsioonis, kasutades TensorFlow CNN-i näidet.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Määratlege CNN

CNN kasutab kujutise töötlemata pikslitel filtreid, et õppida üksikasjalikku mustrit võrreldes traditsioonilise närvivõrgu globaalse mustriga. CNN-i loomiseks peate määratlema:

1. Konvolutsiooniline kiht: rakendage objektikaardile n arvu filtreid. Pärast keerdumist peate võrgule mittelineaarsuse lisamiseks kasutama Relu aktiveerimisfunktsiooni.
2. Pooling kiht: järgmine samm pärast konvolutsiooni on funktsiooni max diskreitimine. Eesmärk on vähendada objektikaardi mõõtmeid, et vältida ülepaigutamist ja parandada arvutuskiirust. Max pooling on tavapärane tehnika, mis jagab objektide kaardid alampiirkondadeks (tavaliselt suurusega 2 × 2) ja säilitab ainult maksimaalsed väärtused.
3. Täielikult ühendatud kihid: kõik eelmiste kihtide neuronid on ühendatud järgmiste kihtidega. CNN klassifitseerib märgise vastavalt konvolutsioonikihtide omadustele ja vähendab neid koondava kihiga.

CNN arhitektuur

• Konvolutsiooniline kiht: rakendab 14 5 × 5 filtrit (eraldab 5 × 5 piksliseid alampiirkondi) koos ReLU aktiveerimisfunktsiooniga
• Pooling Kiht: teostab maksimaalse koondamise 2 × 2 filtriga ja sammuga 2 (mis täpsustab, et ühendatud piirkonnad ei kattu)
• Konvolutsiooniline kiht: rakendab 36 5 × 5 filtrit koos ReLU aktiveerimisfunktsiooniga
• Pooling Kiht #2: jällegi teostab maksimaalse koondumise 2 × 2 filtriga ja sammuga 2
• 1,764 neuronit, väljalangemise regulaarsuse määraga 0.4 (tõenäosus 0.4, et mõni element kukub treeningu ajal välja)
• Tihe kiht (Logits Layer): 10 neuronit, üks iga numbri sihtklassi kohta (0–9).

CNN-i loomiseks tuleb kasutada kolme olulist moodulit:

• conv2d(). Ehitab kahemõõtmelise konvolutsioonikihi, mille argumentidena on filtrite arv, filtri tuuma suurus, polsterdus ja aktiveerimisfunktsioon.
• max_pooling2d(). Ehitab kahemõõtmelise koondamiskihi, kasutades max-pooling algoritmi.
• tihe(). Ehitab peidetud kihtide ja üksustega tiheda kihi

Määrate CNN-i koostamise funktsiooni. Vaatame üksikasjalikult, kuidas iga ehitusplokk üles ehitada, enne kui kõik funktsioonis kokku pakkida.

2. samm: sisendkiht

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

Peate määratlema tensori andmete kujuga. Selleks saab kasutada moodulit tf.reshape. Selles moodulis peate deklareerima ümberkujundatava tensori ja tensori kuju. Esimene argument on andmete omadused, mis on määratletud funktsiooni argumendis.

Pildil on kõrgus, laius ja kanal. MNIST-i andmestik on monokroonne pilt suurusega 28 × 28. Seadsime kuju argumendis partii suuruseks -1, nii et see võtab funktsioonide kuju ["x"]. Eelis on muuta partii suuruse hüperparameetrid häälestamiseks. Kui partii suuruseks on seatud 7, siis toidab tensor 5,488 väärtust (28*28*7).

3. samm: keerdkiht

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

Esimesel konvolutsioonikihil on 14 filtrit, mille tuuma suurus on 5 × 5 ja sama täidisega. Sama polsterdus tähendab, et nii väljundtensoril kui ka sisendtensoril peaks olema sama kõrgus ja laius. Tensorflow lisab sama suuruse tagamiseks ridadele ja veergudele nullid.

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

Samm 4: Pooling kiht

Järgmine samm pärast konvolutsiooni on koondamise arvutamine. Koondamisarvutus vähendab andmete mõõtmelisust. Kasutada saab moodulit max_pooling2d suurusega 2×2 ja sammuga 2. Sisendina kasutad eelmist kihti. Väljundi suurus on [partii_suurus, 14, 14, 14]

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

5. samm: teine ​​konvolutsioonikiht ja Pooling Kiht

Teisel konvolutsioonikihil on 32 filtrit, väljundi suurus [partii_suurus, 14, 14, 32]. Koondamiskiht on sama suurusega kui varem ja väljundi kuju 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. Objektikaart tuleb enne tiheda kihiga ühendamist tasandada. Saate kasutada mooduli ümberkujundamist suurusega 7*7*36.

Tihe kiht ühendab 1764 neuronit. Lisate Relu aktiveerimisfunktsiooni. Peale selle lisate väljalangemise reguleerimise termini määraga 0.3, mis tähendab, et 30 protsenti kaaludest seatakse väärtusele 0. Pange tähele, et väljalangemine toimub ainult treeningfaasis. Funktsioonil cnn_model_fn on argumendirežiim, et deklareerida, kas mudelit on vaja koolitada või hinnata, nagu on näidatud allolevas CNN-i kujutise klassifikatsiooni TensorFlow näites.

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: Logiti kiht

Lõpuks saate TensorFlow kujutise klassifitseerimise näites määratleda viimase kihi mudeli ennustusega. Väljundi kuju võrdub partii suurusega ja 10, piltide koguarvuga.

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

Saate luua sõnastiku, mis sisaldab klasse ja iga klassi tõenäosust. Moodul tf.argmax() koos logiti kihtidega tagastab suurima väärtuse. 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õnastiku ennustuse soovite tagastada ainult siis, kui režiim on seatud ennustusrežiimile. Lisate need koodid ennustuste kuvamiseks

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

Järgmine samm on mudeli kaotuse arvutamine. Viimases õpetuses õppisite, et mitme klassi mudeli kadufunktsioon on ristentroopia. Kahju on lihtne arvutada järgmise koodiga:

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

TensorFlow CNN-i näite viimane samm on mudeli optimeerimine, st kaalude parimate väärtuste leidmine. Selleks kasutate gradiendi laskumise optimeerijat, mille õppimiskiirus 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())

Olete CNN-iga lõpetanud. Siiski soovite hindamisrežiimi ajal kuvada jõudlusmõõdikuid. Mitme klassi mudeli toimivusmõõdikud on täpsusmõõdikud. Tensorflow on varustatud mooduli täpsusega, millel on kaks argumenti, sildid ja prognoositud 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 on kõik. Lõite oma esimese CNN-i ja olete valmis kõik funktsiooniks pakkima, et kasutada seda mudeli koolitamiseks ja hindamiseks.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

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

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

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

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

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

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

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

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Alltoodud sammud on samad, mis eelmistes õpetustes.

Kõigepealt määrate CNN-i mudeliga piltide klassifitseerimiseks hindaja.

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

CNN-i treenimiseks kulub mitu korda, seetõttu loote logimiskonksu, et salvestada softmaxi kihtide väärtused iga 50 iteratsiooni järel.

# Set up logging for predictions
tensors_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. Pange tähele, et seadsime treeningsammudeks 16.000 XNUMX, treenimiseks võib kuluda palju aega. Ole kannatlik.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Nüüd, kui mudel on koolitatud, saate seda hinnata ja tulemused printida

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Praeguse arhitektuuriga saate 97% täpsuse. Täpsuse parandamiseks saate muuta arhitektuuri, partii suurust ja iteratsioonide arvu. CNN-i närvivõrk on toiminud palju paremini kui ANN või logistiline regressioon. Tehisnärvivõrgu õpetuses oli teie täpsus 96%, mis on madalam kui CNN. CNNi etteasted on suurema pildiga muljetavaldavad komplekt, nii kiiruse arvutamise kui ka täpsuse osas.

kokkuvõte

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

TensorFlow CNN-i loomiseks peate järgima seitset sammu:

Samm 1: Andmestiku üleslaadimine:

MNIST-i andmestik on õppimiseks saadaval koos scikitiga. Laadige see alla ja salvestage allalaadimiste alla. Saate selle üles laadida funktsiooniga fetch_mldata ('MNIST originaal').

Samm 2: sisendkiht:

See samm kujundab andmed ümber. Kuju on võrdne pikslite arvu ruutjuurega. Näiteks kui pildil on 156 pikslit, on kujund 26 × 26. Peate täpsustama, kas pildil on värv või mitte. Kui jah, siis oli teil kujundile 3 – RGB jaoks 3, muidu 1.

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

Samm 3: Konvolutsiooniline kiht

Järgmisena peate looma keerdkihid. Rakendate erinevaid filtreid, et võimaldada võrgul õppida olulisi funktsioone. Saate määrata tuuma suuruse ja filtrite arvu.

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

Samm 4: Pooling kiht

Kolmandas etapis lisate koondamiskihi. See kiht vähendab sisendi suurust. Selleks võetakse alammaatriksi maksimaalne väärtus. Näiteks kui alammaatriks on [3,1,3,2], tagastab ühendamine maksimumi, mis on 3.

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

Samm 5: Lisa konvolutsioonikiht ja Pooling Kiht

Selles etapis saate lisada nii palju konv- ja koondkihte, kui soovite. Google kasutab enam kui 20 konv.kihiga arhitektuuri.

Samm 6: Tihe kiht

6. samm tasandage eelmine, et luua täielikult ühendatud kihid. Selles etapis saate kasutada erinevaid aktiveerimisfunktsioone 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)

Samm 7: Logiti kiht

Viimane samm on ennustamine.

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