CNN-billedklassificering i TensorFlow med trin og eksempler

Hvad er Convolutional Neural Network?

Konvolutionelt neuralt netværk, også kendt som convnets eller CNN, er en velkendt metode inden for computer vision-applikationer. Det er en klasse af dybe neurale netværk, der bruges til at analysere visuelle billeder. Denne type arkitektur er dominerende til at genkende objekter fra et billede eller en video. Den bruges i applikationer som billed- eller videogenkendelse, behandling af naturligt sprog og anbefalingssystemer.

ArchiTecture of a Convolutional Neural Network

Tænk på Facebook for et par år siden, efter at du uploadede et billede til din profil, blev du bedt om at tilføje et navn til ansigtet på billedet manuelt. I dag bruger Facebook convnet til automatisk at tagge din ven på billedet.

Et konvolutionelt neuralt netværk til billedklassificering er ikke særlig svært at forstå. Et inputbillede behandles under foldningsfasen og tildeles senere en etiket.

En typisk convnet-arkitektur kan opsummeres i billedet nedenfor. Først sendes et billede til netværket; dette kaldes inputbilledet. Derefter gennemgår inputbilledet en række trin; dette er den konvolutionelle del af netværket. Endelig kan det neurale netværk forudsige cifferet på billedet.

Et billede er sammensat af en række pixels med højde og bredde. Et gråtonebillede har kun én kanal, mens farvebilledet har tre kanaler (hver for rød, grøn og blå). Kanalerne er stablet oven på hinanden. I denne vejledning bruger du et gråtonebillede med kun én kanal. Hver pixel har en værdi fra 0 til 255 for at afspejle farvens intensitet. For eksempel vil en pixel lig med 0 vise en hvid farve, mens en pixel med en værdi tæt på 255 vil være mørkere.

Lad os se på et billede, der er gemt i MNIST datasætBilledet nedenfor viser, hvordan billedet til venstre repræsenteres i et matrixformat. Bemærk, at den originale matrix er standardiseret til at være mellem 0 og 1. For mørkere farver er værdien i matrixen omkring 0.9, mens hvide pixels har en værdi på 0.

Konvolutionsdrift

Den mest kritiske komponent i modellen er det konvolutionelle lag. Denne del sigter mod at reducere billedets størrelse for hurtigere beregninger af vægtene og forbedre generaliseringen.

Under foldningsdelen bevarer netværket de væsentlige funktioner i billedet og udelukker irrelevant støj. For eksempel lærer modellen at genkende en elefant fra et billede med et bjerg i baggrunden. Hvis du bruger et traditionelt neuralt netværk, vil modellen tildele en vægt til alle pixels, inklusive dem fra bjerget, som ikke er afgørende og kan vildlede netværket.

I stedet for a Keras et konvolutionelt neuralt netværk vil bruge en matematisk teknik til at illustreretrackun de mest relevante pixels. Denne matematiske operation kaldes konvolution. Denne teknik gør det muligt for netværket at lære stadig mere komplekse funktioner på hvert lag. Konvolutionen opdeler matricen i små stykker for at lære de mest essentielle elementer i hvert stykke.

Komponenter af Convolutional Neural Network (ConvNet eller CNN)

Der er fire komponenter i et convnet:

1. foldning
2. Ikke-linearitet (ReLU)
3. Pooling eller Sub Sampling
4. Klassifikation (fuldt forbundet lag)

foldning

Formålet med konvolutionen er attracgenkende objektets funktioner lokalt på billedet. Det betyder, at netværket vil lære specifikke mønstre i billedet og vil være i stand til at genkende dem overalt i billedet.

Konvolution er en elementvis multiplikation. Konceptet er let at forstå. Computeren scanner en del af billedet, normalt med en dimension på 3×3, og multiplicerer den med et filter. Outputtet af den elementvise multiplikation kaldes et feature map. Dette trin gentages, indtil hele billedet er scannet. Bemærk, at billedets størrelse reduceres efter konvolutionen.

Diagrammet nedenfor viser et område af billedet, der ganges med filteret for at producere en enkelt celle i objektkortet.

Animationen nedenfor viser den samme foldning, der løber over hele billedet.

Der findes adskillige filtre. Nedenfor har vi listet nogle af dem. Du kan se, at hvert filter har et specifikt formål. Bemærk, at kernen på billedet nedenfor er et synonym for filteret.

Aritmetik bag foldningen

Konvolutionsfasen vil anvende filteret på et lille array af pixels i billedet. Filteret vil bevæge sig langs inputbilledet med en generel form på 3×3 eller 5×5. Det betyder, at netværket vil skubbe disse vinduer hen over hele inputbilledet og beregne konvolutionen. Animationen nedenfor viser, hvordan konvolutionen fungerer. Størrelsen af ​​patchen er 3×3, og outputmatricen er resultatet af den elementvise operation mellem billedmatricen og filteret.

Du bemærker, at bredden og højden af ​​output kan være forskellig fra bredden og højden af ​​input. Det sker på grund af grænseeffekten.

Grænseeffekt

Billedet har et 5×5-funktionskort og et 3×3-filter. Der er kun ét vindue i midten, hvor filteret kan screene et 3×3-gitter. Funktionskortet på outputtet krymper med to felter på hver akse, hvilket efterlader en 3×3-dimension.

For at få den samme outputdimension som inputdimensionen skal du tilføje padding. Padding består af at tilføje det rigtige antal rækker og kolonner på hver side af matricen. Det vil tillade foldningen at centrere hver inputfelt. På billedet nedenfor har input- og outputmatricerne den samme dimension, 5×5.

Når du definerer netværket, styres de indviklede funktioner af tre parametre:

Dybde: Den definerer antallet af filtre, der skal anvendes under konvolutionen. I det foregående eksempel så du en dybde på 1, hvilket betyder, at kun ét filter bruges. I de fleste tilfælde er der mere end ét filter. Animationen nedenfor viser de operationer, der udføres i en situation med tre filtre.

Skridt: Den definerer antallet af "pixelspring" mellem to skiver. Hvis skridtlængden er lig med 1, bevæger vinduet sig med en pixelspredning på én. Hvis skridtlængden er lig med to, hopper vinduet med 2 pixels. Hvis du øger skridtlængden, får du mindre featurekort. De to diagrammer nedenfor sammenligner et skridtlængde på 1 med et skridtlængde på 2.

Eksempel skridt 1

skridt 2

Nulpolstring: En padding er en operation, hvor man tilføjer et tilsvarende antal rækker og kolonner på hver side af input-funktionskortene. I dette tilfælde har outputtet samme dimension som inputtet.

Ikke-linearitet (ReLU)

Ved afslutningen af ​​konvolutionsoperationen er outputtet underlagt en aktiveringsfunktion for at tillade ikke-linearitet. Den sædvanlige aktiveringsfunktion for et konvolutionsnet er ReLU. Alle pixels med en negativ værdi vil blive erstattet af nul.

Pooling Operation

Dette trin er let at forstå. Formålet med poolingen er at reducere dimensionaliteten af ​​inputbilledet. Trinnene udføres for at reducere operationens beregningsmæssige kompleksitet. Ved at mindske dimensionaliteten har netværket færre vægte at beregne, hvilket forhindrer overfitting.

I denne fase skal du definere størrelsen og skridtlængden. En standardmåde at samle inputbilledet på er at bruge den maksimale værdi af featurekortet. Se på billedet nedenfor. Poolingen vil screene fire undermatricer af 4×4-featurekortet og returnere den maksimale værdi. Poolingen tager den maksimale værdi af et 2×2-array og flytter derefter dette vindue med to pixels. For eksempel er den første undermatrix [3,1,3,2], så poolingen vil returnere det maksimale, som er 3.

Der er en anden pooling operation, såsom middelværdien.

Denne operation reducerer størrelsen på funktionskortet markant.

Fuldt forbundne lag

Det sidste trin består i at bygge en traditionel kunstigt neuralt netværk som du gjorde i den forrige tutorial. Du forbinder alle neuroner fra det forrige lag til det næste lag. Du bruger en softmax aktiveringsfunktion til at klassificere nummeret på inputbilledet.

resumé:

Et TensorFlow-konvolutionelt neuralt netværk kompilerer forskellige lag, før det foretager en forudsigelse. Et neuralt netværk har:

• Et foldet lag
• ReLU aktiveringsfunktion
• Pooling lag
• Tæt forbundet lag

De konvolutionelle lag anvender forskellige filtre på et delområde af billedet. ReLU-aktiveringsfunktionen tilføjer ikke-linearitet, og poolingslagene reducerer dimensionaliteten af ​​​​featurekortene.

Alle disse lag eks.tracVigtig information fra billederne. Til sidst føres funktionskortene til et fuldt forbundet lag med en softmax-funktion for at lave en forudsigelse.

Træn CNN med TensorFlow

Nu hvor du er bekendt med byggestenene i et convnet, er du klar til at bygge et med TensorFlow. Vi vil bruge MNIST-datasættet til CNN-billedklassificering.

Dataforberedelsen er den samme som den forrige tutorial. Du kan køre koderne og hoppe direkte til CNN's arkitektur.

Du vil følge nedenstående trin for billedklassificering ved hjælp af CNN:

1. Trin 1: Upload datasæt
2. Trin 2: Inputlag
3. Trin 3: Konvolutionslag
4. Trin 4: Pooling lag
5. Trin 5: Andet foldningslag og Pooling lag
6. Trin 6: Tæt lag
7. Trin 7: Logit Layer

Versionsnotat: Listerne nedenfor er rettet mod TensorFlow 1.x. I TensorFlow 2 findes navnerummet tf.layers og tf.estimator.inputs.numpy_input_fn ikke længere; de ​​tilsvarende er tf.keras.layers.Conv2D, MaxPooling2D, Dense og Dropout samlet i en tf.keras.Model og trænet med model.fit(). Læs trinnene for mekanikken i hvert lag, og kortlæg dem derefter til Keras API'en.

Trin 1: Upload datasæt

MNIST-datasættet er tilgængeligt via scikit-learn. Download det og gem det i Downloads. Du kan uploade det med fetch_mldata('MNIST original').

Versionsnotat: mldata.org er lukket ned, og fetch_mldata() blev fjernet i scikit-learn 0.22. Indlæs de samme cifre med i enhver nuværende installation. fetch_openml i stedet bruger man fetch_openml('mnist_784', version=1). Resten af ​​pipelinen er uændret.

Lav et tog/testsæt

Du skal opdele datasættet med train_test_split.

Skaler funktionerne

Endelig kan du skalere funktionerne med MinMaxScaler som vist i nedenstående billedklassificering ved hjælp af 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 bruger filtre på de rå pixels i et billede til at lære detaljemønstre sammenlignet med de globale mønstre, der læres af et traditionelt neuralt netværk. For at konstruere et CNN skal du definere:

1. Et konvolutionelt lag: Anvend n antal filtre på featurekortet. Efter konvolutionen skal du bruge en ReLU-aktiveringsfunktion til at tilføje ikke-linearitet til netværket.
2. Pooling-lag: Det næste trin efter konvolutionen er at nedskalere featurekortet. Formålet er at reducere dimensionaliteten af ​​featurekortet for at forhindre overfitting og forbedre beregningshastigheden. Maksimal pooling er den konventionelle teknik, der opdeler featurekortene i underregioner (normalt med en størrelse på 2×2) og kun beholder de maksimale værdier.
3. Fuldt forbundne lag: Alle neuroner fra de foregående lag er forbundet til de næste lag. CNN vil klassificere etiketten i henhold til funktionerne fra foldningslagene og reduceret med poolinglaget.

CNN arkitektur

• Konvolutionelt lag: Anvender 14 5×5 filtre (f.eks.trac5×5-pixel underregioner), med ReLU-aktiveringsfunktion
• Pooling Layer: Udfører maksimal pooling med et 2×2 filter og skridt på 2 (hvilket specificerer, at poolede områder ikke overlapper)
• Convolutional Layer: Anvender 36 5×5 filtre, med ReLU aktiveringsfunktion
• Pooling Layer #2: Igen, udfører maksimal pooling med et 2×2 filter og et skridt på 2
• 1,764 neuroner med frafaldsregulariseringsrate på 0.4 (sandsynlighed på 0.4 for, at et givet element vil blive droppet under træning)
• Tæt lag (Logits-lag): 10 neuroner, en for hver ciffermålklasse (0–9).

Der er tre vigtige moduler, der skal bruges til at oprette et CNN:

• conv2d(). Konstruerer et todimensionelt foldningslag med antallet af filtre, filterkernestørrelse, udfyldning og aktiveringsfunktion som argumenter.
• max_pooling2d(). Konstruerer et todimensionalt poolinglag ved hjælp af max-pooling-algoritmen.
• tæt(). Konstruerer et tæt lag med de skjulte lag og enheder

Du skal definere en funktion til at bygge CNN'en. Lad os se nærmere på, hvordan man konstruerer hver byggesten før indpakning.ping alt sammen i funktionen.

Trin 2: Inputlag

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

Du skal definere en tensor med formen af ​​dataene. Til det kan du bruge modulet tf.reshape. I dette modul skal du erklære, at tensoren skal omformes, og formen på tensoren. Det første argument er funktionerne i dataene, som er defineret i argumentet for funktionen.

Et billede har en højde, en bredde og en kanal. MNIST-datasættet er et monokromt billede med en størrelse på 28×28. Vi sætter batchstørrelsen til -1 i formargumentet, så det tager formen af ​​features["x"]. Fordelen er at gøre batchstørrelsen til en hyperparameter, der skal justeres. Hvis batchstørrelsen er indstillet til 7, vil tensoren føde 5,488 værdier (28*28*7).

Trin 3: Konvolutionslag

# 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 konvolutionelle lag har 14 filtre med en kernestørrelse på 5×5 med samme padding. Den samme padding betyder, at både outputtensoren og inputtensoren skal have samme højde og bredde. TensorFlow tilføjer nuller til rækkerne og kolonnerne for at sikre samme størrelse.

Du bruger ReLU-aktiveringsfunktionen. Outputstørrelsen vil være [28, 28, 14].

Trin 4: Pooling lag

Det næste trin efter konvolutionen er pooling-beregningen. Pooling-beregningen vil reducere dataenes dimensionalitet. Du kan bruge modulet max_pooling2d med en størrelse på 2×2 og en stride på 2. Du bruger det foregående lag som input. Outputstø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)

Trin 5: Andet foldningslag og Pooling lag

Det andet konvolutionelle lag anvender 36 filtre, hvilket giver en outputstørrelse på [batch_size, 14, 14, 36]. Poolinglaget bruger det samme 2×2-vindue og stride på 2 som før, så det halverer hver rumlig akse, og outputformen bliver [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)

Trin 6: Tæt lag

Derefter skal du definere det fuldt forbundne lag. Featurekortet skal udjævnes, før det forbindes med det tætte lag. Du kan bruge modulet til at omforme med en størrelse på 7*7*36.

Det tætte lag vil forbinde 1,764 neuroner. Du tilføjer en ReLU-aktiveringsfunktion. Derudover tilføjer du et regulariseringsterm for frafald med en rate på 0.3, hvilket betyder, at 30 procent af aktiveringerne vil blive sat til 0. Bemærk, at frafaldet kun finder sted under træningsfasen. Funktionen cnn_model_fn har en argumenttilstand til at deklarere, om modellen skal trænes eller evalueres, som vist i nedenstående eksempel på CNN-billedklassificering med TensorFlow.

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)

Trin 7: Logit Layer

Endelig kan du i eksemplet med TensorFlow-billedklassificeringen definere det sidste lag med modellens forudsigelse. Outputformen er lig med batchstørrelsen, og 10 er det samlede antal målklasser.

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

Du kan oprette en ordbog, der indeholder klasserne og sandsynligheden for hver klasse. Funktionen tf.argmax() returnerer indekset for den højeste værdi i logits-laget. Softmax-funktionen returnerer sandsynligheden for hver klasse.

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

Du ønsker kun at returnere prædiktionsordbogen, når tilstanden er indstillet til prædiktion. Du tilføjer denne kode for at vise forudsigelserne.

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

Det næste trin består i at beregne modellens tab. I den sidste vejledning lærte du, at tabsfunktionen for en multiklassemodel er krydsentropi. Tabet beregnes nemt med følgende kode:

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

Det sidste trin i TensorFlow CNN-eksemplet er at optimere modellen, det vil sige at finde de bedste værdier for vægtene. Til det bruger du en gradient descent optimizer med en læringsrate på 0.001. Målet er at minimere tabet.

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

Du er færdig med CNN. Du vil dog gerne vise præstationsmålingerne under evalueringstilstanden. Præstationsmålingerne for en multiklassemodel er nøjagtighed. TensorFlow er udstyret med et nøjagtighedsmodul, der tager to argumenter, etiketterne og de forudsagte værdier.

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 oprettede dit første CNN, og du er klar til at pakke alt ind i en funktion for at bruge den til at træne 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)

Bemærkning om den samlede funktion: Den indpakkede version ovenfor sætter det første foldningslag til 32 filtre og dropout til 0.4, mens de trinvise snippets bruger 14 filtre og 0.3. Begge kører, men vælg ét par værdier og hold det konsistent, så de udskrevne former matcher lagtabellen.

Trinene nedenfor er de samme som de tidligere selvstudier.

Først og fremmest definerer du en estimator med CNN-modellen til billedklassificering.

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

Et CNN tager lang tid at træne, derfor opretter du en logging hook til at gemme værdierne for softmax-lagene hver 50 iterationer.

# 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 at estimere modellen. Du angiver en batchstørrelse på 100 og blander dataene. Bemærk, at vi har angivet træningstrin på 16,000, hvilket kan tage lang tid at træne. 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])

Nu hvor modellen er trænet, kan du evaluere den og udskrive resultaterne.

# 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 udskriver det gendannede kontrolpunkt, det trin, det stoppede ved, og den endelige metrikordbog.

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 nuværende arkitektur rapporterer evalueringsordbogen en nøjagtighed på 0.9689286, hvilket er cirka 97 %. Du kan ændre arkitekturen, batchstørrelsen og antallet af iterationer for at forbedre nøjagtigheden. CNN har klaret sig langt bedre end en ... kunstigt neuralt netværk eller logistisk regression: i vejledningen om kunstige neurale netværk havde du en nøjagtighed på 96%, hvilket er lavere end CNN's. CNN's ydeevne er imponerende med et større billedsæt, både med hensyn til beregningshastighed og nøjagtighed.

Ofte Stillede Spørgsmål