CNN bildeklassifisering i TensorFlow med trinn og eksempler

Hva er Convolutional Neural Network?

Konvolusjonelt nevralt nettverk, også kjent som convnets eller CNN, er en velkjent metode innen datasynsapplikasjoner. Det er en klasse dype nevrale nettverk som brukes til å analysere visuelle bilder. Denne typen arkitektur er dominerende for å gjenkjenne objekter fra et bilde eller en video. Den brukes i applikasjoner som bilde- eller videogjenkjenning, naturlig språkbehandling og anbefalingssystemer.

ArchiTecture of a Convolutional Neural Network

Tenk på Facebook for noen år siden, etter at du lastet opp et bilde til profilen din, ble du bedt om å legge til et navn til ansiktet på bildet manuelt. I dag bruker Facebook convnet for å tagge vennen din i bildet automatisk.

Et konvolusjonelt nevralt nettverk for bildeklassifisering er ikke veldig vanskelig å forstå. Et inngangsbilde behandles under konvolusjonsfasen og tilskrives senere en etikett.

En typisk convnet-arkitektur kan oppsummeres i bildet nedenfor. Først sendes et bilde til nettverket; dette kalles inngangsbildet. Deretter går inngangsbildet gjennom en rekke trinn; dette er den konvolusjonelle delen av nettverket. Til slutt kan det nevrale nettverket forutsi sifferet på bildet.

Et bilde er satt sammen av en rekke piksler med høyde og bredde. Et gråtonebilde har bare én kanal, mens fargebildet har tre kanaler (hver for rød, grønn og blå). Kanalene er stablet oppå hverandre. I denne veiledningen skal du bruke et gråtonebilde med bare én kanal. Hver piksel har en verdi fra 0 til 255 for å gjenspeile fargens intensitet. For eksempel vil en piksel lik 0 vise en hvit farge, mens en piksel med en verdi nær 255 vil være mørkere.

La oss ta en titt på et bilde som er lagret i MNIST datasettBildet nedenfor viser hvordan man representerer bildet til venstre i et matriseformat. Merk at den opprinnelige matrisen er standardisert til å være mellom 0 og 1. For mørkere farger er verdien i matrisen omtrent 0.9, mens hvite piksler har en verdi på 0.

Konvolusjonsoperasjon

Den viktigste komponenten i modellen er konvolusjonslaget. Denne delen tar sikte på å redusere størrelsen på bildet for raskere beregninger av vektene og forbedre generalisering.

Under konvolusjonsdelen beholder nettverket de essensielle egenskapene til bildet og utelukker irrelevant støy. For eksempel lærer modellen å gjenkjenne en elefant fra et bilde med et fjell i bakgrunnen. Hvis du bruker et tradisjonelt nevralt nettverk, vil modellen tildele en vekt til alle pikslene, inkludert de fra fjellet som ikke er avgjørende og kan villede nettverket.

I stedet for a Keras et konvolusjonelt nevralt nettverk vil bruke en matematisk teknikk for åtracbare de mest relevante pikslene. Denne matematiske operasjonen kalles konvolusjon. Denne teknikken lar nettverket lære stadig mer komplekse funksjoner på hvert lag. Konvolusjonen deler matrisen inn i små biter for å lære de viktigste elementene i hver del.

Komponenter i Convolutional Neural Network (ConvNet eller CNN)

Det er fire komponenter i et konvnett:

1. Konvolusjon
2. Ikke-linearitet (ReLU)
3. Pooling eller Sub Sampling
4. Klassifisering (fullt tilkoblet lag)

Konvolusjon

Hensikten med konvolusjonen er å eks.tracgjenkjenne objektets egenskaper lokalt på bildet. Det betyr at nettverket vil lære spesifikke mønstre i bildet og vil kunne gjenkjenne dem overalt i bildet.

Konvolusjon er en elementvis multiplikasjon. Konseptet er lett å forstå. Datamaskinen skanner en del av bildet, vanligvis med en dimensjon på 3 × 3, og multipliserer den med et filter. Resultatet av den elementvise multiplikasjonen kalles et funksjonskart. Dette trinnet gjentas til hele bildet er skannet. Merk at størrelsen på bildet reduseres etter konvolusjonen.

Diagrammet nedenfor viser én del av bildet som multipliseres med filteret for å produsere én celle i funksjonskartet.

Animasjonen nedenfor viser den samme konvolusjonen som går over hele bildet.

Det finnes en rekke filtre tilgjengelig. Nedenfor har vi listet opp noen av dem. Du kan se at hvert filter har et spesifikt formål. Merk at kjernen på bildet nedenfor er et synonym for filteret.

Aritmetikk bak konvolusjonen

Konvolusjonsfasen vil bruke filteret på en liten gruppe piksler i bildet. Filteret vil bevege seg langs inngangsbildet med en generell form på 3×3 eller 5×5. Det betyr at nettverket vil skyve disse vinduene over hele inngangsbildet og beregne konvolusjonen. Animasjonen nedenfor viser hvordan konvolusjonen fungerer. Størrelsen på lappen er 3×3, og utgangsmatrisen er resultatet av den elementvise operasjonen mellom bildematrisen og filteret.

Du legger merke til at bredden og høyden på utgangen kan være forskjellig fra bredden og høyden på inngangen. Det skjer på grunn av grenseeffekten.

Grenseeffekt

Bildet har et 5×5-funksjonskart og et 3×3-filter. Det er bare ett vindu i midten der filteret kan skjerme et 3×3-rutenett. Funksjonskartet som vises krymper med to fliser på hver akse, slik at det blir en 3×3-dimensjon.

For å få samme utdatadimensjon som inndatadimensjonen, må du legge til padding. Padding består av å legge til riktig antall rader og kolonner på hver side av matrisen. Dette vil tillate at konvolusjonen sentrerer hver inndataflis. I bildet nedenfor har inndata- og utdatamatrisene samme dimensjon, 5×5.

Når du definerer nettverket, styres de konvolverte funksjonene av tre parametere:

Dybde: Den definerer antall filtre som skal brukes under konvolusjonen. I det forrige eksemplet så du en dybde på 1, som betyr at bare ett filter brukes. I de fleste tilfeller er det mer enn ett filter. Animasjonen nedenfor viser operasjonene som utføres i en situasjon med tre filtre.

Skritt: Den definerer antall «pikselhopp» mellom to skiver. Hvis skrittet er lik 1, vil vinduet bevege seg med en pikselspredning på én. Hvis skrittet er lik to, vil vinduet hoppe med 2 piksler. Hvis du øker skrittet, vil du ha mindre funksjonskart. De to diagrammene nedenfor sammenligner et skritt på 1 med et skritt på 2.

Eksempel skritt 1

skritt 2

Nullpolstring: Padding er en operasjon der man legger til et tilsvarende antall rader og kolonner på hver side av input-funksjonskartene. I dette tilfellet har utdataene samme dimensjon som input.

Ikke-linearitet (ReLU)

På slutten av konvolusjonsoperasjonen er utgangen underlagt en aktiveringsfunksjon for å tillate ikke-linearitet. Den vanlige aktiveringsfunksjonen for et konvolusjonsnett er ReLU. Alle piksler med en negativ verdi vil bli erstattet av null.

Pooling Operasjon

Dette trinnet er lett å forstå. Formålet med poolingen er å redusere dimensjonaliteten til inngangsbildet. Trinnene utføres for å redusere operasjonens beregningsmessige kompleksitet. Ved å redusere dimensjonaliteten har nettverket færre vekter å beregne, slik at det forhindrer overtilpasning.

I dette stadiet må du definere størrelsen og steglengden. En standard måte å samle inndatabildet på er å bruke maksimumsverdien til funksjonskartet. Se på bildet nedenfor. Samlingen vil screene fire delmatriser av 4×4-funksjonskartet og returnere maksimumsverdien. Samlingen tar maksimumsverdien til en 2×2-matrise og flytter deretter dette vinduet med to piksler. For eksempel er den første delmatrisen [3,1,3,2], så samlingen vil returnere maksimumsverdien, som er 3.

Det er en annen sammenslåingsoperasjon som for eksempel gjennomsnittet.

Denne operasjonen reduserer størrelsen på funksjonskartet betraktelig.

Fullt tilkoblede lag

Det siste trinnet består i å bygge en tradisjonell kunstig nevrale nettverk som du gjorde i forrige veiledning. Du kobler alle nevroner fra forrige lag til neste lag. Du bruker en softmax-aktiveringsfunksjon for å klassifisere nummeret på inndatabildet.

Oppsummering:

Et TensorFlow-konvolusjonelt nevralt nettverk kompilerer forskjellige lag før det foretar en prediksjon. Et nevralt nettverk har:

• Et konvolusjonslag
• ReLU aktiveringsfunksjon
• Pooling lag
• Tett forbundet lag

Konvolusjonslagene bruker forskjellige filtre på et delområde av bildet. ReLU-aktiveringsfunksjonen legger til ikke-linearitet, og samlingslagene reduserer dimensjonaliteten til funksjonskartene.

Alle disse lagene eks.tracviktig informasjon fra bildene. Til slutt mates funksjonskartene til et fullstendig tilkoblet lag med en softmax-funksjon for å lage en prediksjon.

Tren CNN med TensorFlow

Nå som du er kjent med byggesteinene i et convnet, er du klar til å bygge et med tensorflow. Vi vil bruke MNIST-datasettet for CNN-bildeklassifisering.

Dataforberedelsen er den samme som den forrige opplæringen. Du kan kjøre kodene og hoppe direkte til arkitekturen til CNN.

Du følger trinnene nedenfor for bildeklassifisering ved å bruke CNN:

1. Trinn 1: Last opp datasett
2. Trinn 2: Inndatalag
3. Trinn 3: Konvolusjonslag
4. Trinn 4: Pooling lag
5. Trinn 5: Andre konvolusjonslag og Pooling Lag
6. Trinn 6: Tett lag
7. Trinn 7: Logit Layer

Versjonsmerknad: Listene nedenfor er rettet mot TensorFlow 1.x. I TensorFlow 2 finnes ikke lenger navnerommet tf.layers og tf.estimator.inputs.numpy_input_fn; ekvivalentene er tf.keras.layers.Conv2D, MaxPooling2D, Dense og Dropout satt sammen i en tf.keras.Model og trent med model.fit(). Les trinnene for mekanikken til hvert lag, og kartlegg dem deretter til Keras API.

Trinn 1: Last opp datasett

MNIST-datasettet er tilgjengelig via scikit-learn. Vennligst last det ned og lagre det i Nedlastinger. Du kan laste det opp med fetch_mldata('MNIST original').

Versjonsmerknad: mldata.org har stengt ned og fetch_mldata() ble fjernet i scikit-learn 0.22. Last inn de samme sifrene med fetch_openml i stedet bruker man fetch_openml('mnist_784', versjon=1). Resten av pipelinen er uendret.

Lag et tog/testsett

Du må dele datasettet med train_test_split.

Skaler funksjonene

Til slutt kan du skalere funksjonene med MinMaxScaler som vist i bildeklassifiseringen nedenfor ved hjelp av TensorFlow CNN-eksemplet.

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

Definer CNN

Et CNN bruker filtre på de rå pikslene i et bilde for å lære detaljmønstre sammenlignet med de globale mønstrene som læres av et tradisjonelt nevralt nettverk. For å konstruere et CNN må du definere:

1. Et konvolusjonslag: Bruk n antall filtre på funksjonskartet. Etter konvolusjonen må du bruke en ReLU-aktiveringsfunksjon for å legge til ikke-linearitet i nettverket.
2. Pooling-laget: Neste trinn etter konvolusjonen er å nedsample funksjonskartet. Hensikten er å redusere dimensjonaliteten til funksjonskartet for å forhindre overtilpasning og forbedre beregningshastigheten. Maksimal pooling er den konvensjonelle teknikken, som deler funksjonskartene inn i underregioner (vanligvis med en 2×2-størrelse) og bare beholder maksimumsverdiene.
3. Fullt koblede lag: Alle nevroner fra de forrige lagene er koblet til de neste lagene. CNN vil klassifisere etiketten i henhold til funksjonene fra konvolusjonslagene og reduseres med sammenslåingslaget.

CNN arkitektur

• Konvolusjonslag: Bruker 14 5×5-filtre (f.eks.trac(5×5-piksel underregioner), med ReLU-aktiveringsfunksjon
• Pooling Lag: Utfører maksimal pooling med et 2×2-filter og skritt på 2 (som spesifiserer at sammenslåtte områder ikke overlapper hverandre)
• Convolutional Layer: Bruker 36 5×5-filtre, med ReLU-aktiveringsfunksjon
• Pooling Layer #2: Igjen, utfører maksimal pooling med et 2×2-filter og et skritt på 2
• 1,764 0.4 nevroner, med frafallsregulariseringsrate på 0.4 (sannsynlighet på XNUMX for at et gitt element vil bli droppet under trening)
• Tett lag (Logits-lag): 10 nevroner, en for hver siffermålklasse (0–9).

Det er tre viktige moduler å bruke for å lage en CNN:

• conv2d(). Konstruerer et todimensjonalt konvolusjonslag med antall filtre, filterkjernestørrelse, utfylling og aktiveringsfunksjon som argumenter.
• max_pooling2d(). Konstruerer et todimensjonalt sammenslåingslag ved hjelp av maks-pooling-algoritmen.
• tett(). Konstruerer et tett lag med de skjulte lagene og enhetene

Du skal definere en funksjon for å bygge CNN-en. La oss se nærmere på hvordan du konstruerer hver byggekloss før innpakning.ping alt sammen i funksjonen.

Trinn 2: Inndatalag

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

Du må definere en tensor med formen på dataene. Til det kan du bruke modulen tf.reshape. I denne modulen må du erklære at tensoren skal omformes og formen på tensoren. Det første argumentet er egenskapene til dataene, som er definert i argumentet til funksjonen.

Et bilde har en høyde, en bredde og en kanal. MNIST-datasettet er et monokromt bilde med en størrelse på 28×28. Vi setter batchstørrelsen til -1 i formargumentet slik at den tar formen til funksjonene["x"]. Fordelen er å gjøre batchstørrelsen til en hyperparameter som skal justeres. Hvis batchstørrelsen er satt til 7, vil tensoren mate 5,488 verdier (28*28*7).

Trinn 3: Konvolusjonslag

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

Det første konvolusjonslaget har 14 filtre med en kjernestørrelse på 5×5 og samme polstring. Samme polstring betyr at både utgangstensoren og inngangstensoren skal ha samme høyde og bredde. TensorFlow vil legge til nuller i radene og kolonnene for å sikre samme størrelse.

Du bruker ReLU-aktiveringsfunksjonen. Utdatastørrelsen vil være [28, 28, 14].

Trinn 4: Pooling lag

Det neste trinnet etter konvolusjonen er pooling-beregningen. Pooling-beregningen vil redusere dimensjonaliteten til dataene. Du kan bruke modulen max_pooling2d med en størrelse på 2×2 og en stride på 2. Du bruker det forrige laget som input. Utdatastørrelsen vil være [batch_size, 14, 14, 14].

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

Trinn 5: Andre konvolusjonslag og Pooling Lag

Det andre konvolusjonslaget bruker 36 filtre, noe som gir en utdatastørrelse på [batch_size, 14, 14, 36]. Poolingslaget bruker det samme 2×2-vinduet og striden på 2 som før, så det halverer hver romlige akse og utdataformen blir [batch_size, 7, 7, 36].

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)

Trinn 6: Tett lag

Deretter må du definere det fullstendig tilkoblede laget. Funksjonskartet må flates ut før det kobles til det tette laget. Du kan bruke modulen for omforming med en størrelse på 7*7*36.

Det tette laget vil koble sammen 1,764 nevroner. Du legger til en ReLU-aktiveringsfunksjon. I tillegg legger du til et regulariseringsterm for frafall med en rate på 0.3, som betyr at 30 prosent av aktiveringene vil bli satt til 0. Merk at frafallet bare skjer i løpet av treningsfasen. Funksjonen cnn_model_fn har en argumentmodus for å deklarere om modellen må trenes eller evalueres, som vist i eksemplet med CNN-bildeklassifiseringen TensorFlow nedenfor.

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)

Trinn 7: Logit Layer

Til slutt, i eksemplet med TensorFlow-bildeklassifisering, kan du definere det siste laget med modellens prediksjon. Utdataformen er lik batchstørrelsen og 10 er det totale antallet målklasser.

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

Du kan opprette en ordbok som inneholder klassene og sannsynligheten for hver klasse. Funksjonen tf.argmax() returnerer indeksen for den høyeste verdien i logits-laget. softmax-funksjonen returnerer sannsynligheten for hver klasse.

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

Du vil bare returnere prediksjonsordboken når modus er satt til prediksjon. Du legger til denne koden for å vise prediksjonene.

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

Det neste trinnet består i å beregne tapet av modellen. I den siste veiledningen lærte du at tapsfunksjonen for en flerklassemodell er kryssentropi. Tapet beregnes enkelt med følgende kode:

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

Det siste trinnet i TensorFlow CNN-eksemplet er å optimalisere modellen, det vil si å finne de beste verdiene for vektene. Til det bruker du en gradient descent optimizer med en læringsrate på 0.001. Målet er å minimere tapet.

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

Du er ferdig med CNN. Du vil imidlertid vise ytelsesmålingene i evalueringsmodus. Ytelsesmålingen for en flerklassemodell er nøyaktighet. TensorFlow er utstyrt med en nøyaktighetsmodul som tar to argumenter, etikettene og de predikerte verdiene.

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)

Det er det. Du opprettet ditt første CNN, og du er klar til å pakke alt inn i en funksjon for å bruke den til å trene og evaluere modellen.

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)

Merknad om den monterte funksjonen: Den innpakkede versjonen ovenfor setter det første konvolusjonslaget til 32 filtre og dropout til 0.4, mens trinnvise snippets bruker 14 filtre og 0.3. Begge kjører, men velg ett verdipar og hold det konsistent slik at de utskrevne figurene samsvarer med lagtabellen.

Trinnene nedenfor er de samme som de tidligere veiledningene.

Først og fremst definerer du en estimator med CNN-modellen for bildeklassifisering.

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

Et CNN tar lang tid å trene, derfor oppretter du en loggingskrok for å lagre verdiene til softmax-lagene hver 50. iterasjon.

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

Du er klar til å estimere modellen. Du setter en batchstørrelse på 100 og blander dataene. Merk at vi setter treningstrinn på 16 000, noe som kan ta mye tid å trene. Vær tålmodig.

# 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å som modellen er trent, kan du evaluere den og skrive ut resultatene.

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

Evalueringen skriver ut det gjenopprettede kontrollpunktet, trinnet det stoppet ved og den endelige metrikkordboken.

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}

Med den nåværende arkitekturen rapporterer evalueringsordboken en nøyaktighet på 0.9689286, omtrent 97 %. Du kan endre arkitekturen, batchstørrelsen og antall iterasjoner for å forbedre nøyaktigheten. CNN har prestert langt bedre enn en kunstig nevrale nettverk eller logistisk regresjon: i veiledningen om kunstige nevrale nettverk hadde du en nøyaktighet på 96 %, som er lavere enn CNN. Ytelsen til CNN er imponerende med et større bildesett, både når det gjelder beregningshastighet og nøyaktighet.

Spørsmål og svar