CNN-bildklassificering i TensorFlow med steg och exempel

Vad är Convolutional Neural Network?

Konvolutionellt neuralt nätverk, även känt som convnets eller CNN, är en välkänd metod inom datorseendetillämpningar. Det är en klass av djupa neurala nätverk som används för att analysera visuella bilder. Denna typ av arkitektur är dominerande för att känna igen objekt från en bild eller video. Den används i tillämpningar som bild- eller videoigenkänning, naturlig språkbehandling och rekommendationssystem.

ArchiTecture of a Convolutional Neural Network

Tänk på Facebook för några år sedan, efter att du laddat upp en bild till din profil blev du ombedd att lägga till ett namn till ansiktet på bilden manuellt. Nuförtiden använder Facebook convnet för att tagga din vän i bilden automatiskt.

Ett konvolutionellt neuralt nätverk för bildklassificering är inte särskilt svårt att förstå. En ingångsbild bearbetas under faltningsfasen och tilldelas senare en etikett.

En typisk convnet-arkitektur kan sammanfattas i bilden nedan. Först skickas en bild till nätverket; detta kallas inmatningsbilden. Sedan går inmatningsbilden igenom en serie steg; detta är den faltningsmässiga delen av nätverket. Slutligen kan det neurala nätverket förutsäga siffran på bilden.

En bild består av en matris med pixlar med höjd och bredd. En gråskalig bild har bara en kanal medan färgbilden har tre kanaler (var och en för röd, grön och blå). Kanalerna är staplade ovanpå varandra. I den här handledningen kommer du att använda en gråskalig bild med bara en kanal. Varje pixel har ett värde från 0 till 255 för att återspegla färgens intensitet. Till exempel kommer en pixel lika med 0 att visa en vit färg medan en pixel med ett värde nära 255 kommer att vara mörkare.

Låt oss ta en titt på en bild lagrad i MNIST-datauppsättningBilden nedan visar hur man representerar bilden till vänster i ett matrisformat. Observera att den ursprungliga matrisen har standardiserats till att vara mellan 0 och 1. För mörkare färger är värdet i matrisen cirka 0.9 medan vita pixlar har ett värde på 0.

Konvolutionell drift

Den viktigaste komponenten i modellen är faltningsskiktet. Denna del syftar till att minska bildens storlek för snabbare beräkningar av vikterna och förbättra generaliseringen.

Under faltningsdelen behåller nätverket de väsentliga egenskaperna i bilden och utesluter irrelevant brus. Modellen lär sig till exempel att känna igen en elefant från en bild med ett berg i bakgrunden. Om du använder ett traditionellt neuralt nätverk kommer modellen att tilldela alla pixlar en vikt, inklusive de från berget, vilket inte är nödvändigt och kan vilseleda nätverket.

Istället a Keras ett faltningsneuralt nätverk kommer att använda en matematisk teknik för att extracbara de mest relevanta pixlarna. Denna matematiska operation kallas faltning. Denna teknik gör det möjligt för nätverket att lära sig alltmer komplexa funktioner i varje lager. Faltningen delar upp matrisen i små bitar för att lära sig de viktigaste elementen i varje del.

Komponenter i Convolutional Neural Network (ConvNet eller CNN)

Det finns fyra komponenter i ett convnet:

1. Faltning
2. Icke linjäritet (ReLU)
3. Pooling eller Subsampling
4. Klassificering (Fullständigt anslutet lager)

Faltning

Syftet med konvolutionen är att extracobjektets egenskaper lokalt på bilden. Det betyder att nätverket kommer att lära sig specifika mönster i bilden och kommer att kunna känna igen dem överallt i bilden.

Konvolution är en elementvis multiplikation. Konceptet är lätt att förstå. Datorn skannar en del av bilden, vanligtvis med en dimension på 3×3, och multiplicerar den med ett filter. Utdata från den elementvisa multiplikationen kallas en feature map (funktionskarta). Detta steg upprepas tills hela bilden är skannad. Observera att bildens storlek minskas efter konvolutionen.

Diagrammet nedan visar en del av bilden som multipliceras med filtret för att producera en enda cell i objektkartan.

Animationen nedan visar samma faltning som löper över hela bilden.

Det finns många filter tillgängliga. Nedan listar vi några av dem. Du kan se att varje filter har ett specifikt syfte. Observera att kärnan i bilden nedan är en synonym till filtret.

Aritmetik bakom faltningen

Faltningsfasen applicerar filtret på en liten uppsättning pixlar i bilden. Filtret rör sig längs inmatningsbilden med en generell form av 3×3 eller 5×5. Det betyder att nätverket skjuter dessa fönster över hela inmatningsbilden och beräknar faltningen. Animationen nedan visar hur faltningen fungerar. Patchens storlek är 3×3, och utmatningsmatrisen är resultatet av den elementvisa operationen mellan bildmatrisen och filtret.

Du märker att utmatningens bredd och höjd kan skilja sig från ingångens bredd och höjd. Det händer på grund av gränseffekten.

Gränseffekt

Bilden har en 5×5-funktionskarta och ett 3×3-filter. Det finns bara ett fönster i mitten där filtret kan visa ett 3×3-rutnät. Funktionskartan som visas krymper med två rutor på varje axel, vilket ger en 3×3-dimension.

För att få samma utgångsdimension som ingångsdimension måste du lägga till utfyllnad. Utfyllnad består av att lägga till rätt antal rader och kolumner på varje sida av matrisen. Det gör att faltningen centreras och passar varje ingångsruta. I bilden nedan har ingångs- och utgångsmatriserna samma dimension, 5×5.

När du definierar nätverket styrs de invecklade funktionerna av tre parametrar:

Djup: Den definierar antalet filter som ska tillämpas under faltningen. I föregående exempel såg du ett djup på 1, vilket innebär att endast ett filter används. I de flesta fall finns det mer än ett filter. Animationen nedan visar de operationer som utförs i en situation med tre filter.

Kliva: Den definierar antalet "pixelhopp" mellan två skivor. Om steglängden är lika med 1, kommer fönstret att röra sig med en pixelspridning på ett. Om steglängden är lika med två, kommer fönstret att hoppa med 2 pixlar. Om du ökar steglängden får du mindre funktionskartor. De två diagrammen nedan jämför ett steg på 1 med ett steg på 2.

Exempel steg 1

steg 2

Nollfyllning: Padding är en operation där man lägger till ett motsvarande antal rader och kolumner på varje sida av inmatningsfunktionskartorna. I det här fallet har utdata samma dimension som indata.

Icke linjäritet (ReLU)

I slutet av faltningsoperationen aktiveras utdata med en aktiveringsfunktion för att möjliggöra icke-linjäritet. Den vanliga aktiveringsfunktionen för ett konvolutionsnät är ReLU. Alla pixlar med ett negativt värde ersätts med noll.

Pooling Operation

Det här steget är lätt att förstå. Syftet med poolningen är att minska dimensionaliteten hos inmatningsbilden. Stegen utförs för att minska operationens beräkningskomplexitet. Genom att minska dimensionaliteten har nätverket färre vikter att beräkna, vilket förhindrar överanpassning.

I det här steget behöver du definiera storleken och steglängden. Ett standardsätt att poola inmatningsbilden är att använda det maximala värdet för objektkartan. Titta på bilden nedan. Poolningen screenar fyra delmatriser av 4×4-objektkartan och returnerar det maximala värdet. Poolningen tar det maximala värdet för en 2×2-array och flyttar sedan detta fönster med två pixlar. Till exempel är den första delmatrisen [3,1,3,2], så poolningen returnerar det maximala, vilket är 3.

Det finns en annan poolningsoperation såsom medelvärdet.

Den här åtgärden minskar storleken på objektkartan kraftigt.

Fullt anslutna lager

Det sista steget består av att bygga en traditionell artificiellt neuralt nätverk som du gjorde i föregående handledning. Du kopplar alla neuroner från föregående lager till nästa lager. Du använder en softmax-aktiveringsfunktion för att klassificera numret på inmatningsbilden.

Recap:

Ett TensorFlow-faltningsneuralt nätverk kompilerar olika lager innan en förutsägelse görs. Ett neuralt nätverk har:

• Ett veckskikt
• ReLU aktiveringsfunktion
• Pooling lager
• Tätt sammanhängande lager

Faltningslagren tillämpar olika filter på en delregion av bilden. ReLU-aktiveringsfunktionen lägger till icke-linjäritet, och poolningslagren minskar dimensionaliteten hos objektkartorna.

Alla dessa lager extracviktig information från bilderna. Slutligen matas funktionskartorna till ett helt sammankopplat lager med en softmax-funktion för att göra en förutsägelse.

Träna CNN med TensorFlow

Nu när du är bekant med byggstenarna i ett convnet är du redo att bygga ett med TensorFlow. Vi kommer att använda MNIST-datauppsättningen för CNN-bildklassificering.

Dataförberedelsen är densamma som den tidigare handledningen. Du kan köra koderna och hoppa direkt till CNN:s arkitektur.

Du kommer att följa stegen nedan för bildklassificering med CNN:

1. Steg 1: Ladda upp datauppsättning
2. Steg 2: Indatalager
3. Steg 3: Konvolutionellt lager
4. Steg 4: Pooling lager
5. Steg 5: Andra konvolutionella lagret och Pooling Lager
6. Steg 6: Tät lager
7. Steg 7: Logit Layer

Versionsnotering: Listningarna nedan riktar sig mot TensorFlow 1.x. I TensorFlow 2 finns inte längre namnrymden tf.layers och tf.estimator.inputs.numpy_input_fn; motsvarigheterna är tf.keras.layers.Conv2D, MaxPooling2D, Dense och Dropout monterade i en tf.keras.Model och tränade med model.fit(). Läs stegen för mekaniken för varje lager och mappa dem sedan till Keras API.

Steg 1: Ladda upp datauppsättning

MNIST-datasetet är tillgängligt via scikit-learn. Ladda ner det och lagra det i Nedladdningar. Du kan ladda upp det med fetch_mldata('MNIST original').

Versionsnotering: mldata.org har stängts ner och fetch_mldata() togs bort i scikit-learn 0.22. Ladda in samma siffror med hämta_öppenml istället använder man fetch_openml('mnist_784', version=1). Resten av pipelinen är oförändrad.

Skapa ett tåg/testset

Du måste dela upp datamängden med train_test_split.

Skala funktionerna

Slutligen kan du skala funktionerna med MinMaxScaler som visas i bildklassificeringen nedan med hjälp av TensorFlow CNN-exemplet.

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

Definiera CNN

Ett CNN använder filter på de råa pixlarna i en bild för att lära sig detaljmönster jämfört med de globala mönster som lärs ut av ett traditionellt neuralt nätverk. För att konstruera ett CNN måste du definiera:

1. Ett faltningslager: Applicera n antal filter på objektkartan. Efter faltningen behöver du använda en ReLU-aktiveringsfunktion för att lägga till icke-linjäritet i nätverket.
2. Pooling-lager: Nästa steg efter faltningen är att nedsampla objektkartan. Syftet är att minska objektkartans dimensionalitet för att förhindra överanpassning och förbättra beräkningshastigheten. Maxpooling är den konventionella tekniken som delar upp objektkartorna i delregioner (vanligtvis med en storlek på 2×2) och endast behåller de maximala värdena.
3. Fullständigt anslutna skikt: Alla neuroner från föregående skikt är anslutna till nästa skikt. CNN kommer att klassificera etiketten enligt särdragen från faltningsskikten och reduceras med poolskiktet.

CNN arkitektur

• Konvolutionellt lager: Tillämpar 14 5×5-filter (t.ex.trac(5×5-pixel-underregioner), med ReLU-aktiveringsfunktion
• Pooling Lager: Utför maximal poolning med ett 2×2-filter och steg på 2 (vilket anger att poolade regioner inte överlappar varandra)
• Convolutional Layer: Applicerar 36 5×5-filter, med ReLU-aktiveringsfunktion
• Pooling Layer #2: Återigen, utför max pooling med ett 2×2 filter och steg på 2
• 1,764 0.4 neuroner, med avbrottsregulariseringshastighet på 0.4 (sannolikheten XNUMX för att något givet element kommer att tappas under träning)
• Tät lager (Logits lager): 10 neuroner, en för varje siffra målklass (0–9).

Det finns tre viktiga moduler att använda för att skapa ett CNN:

• conv2d(). Konstruerar ett tvådimensionellt faltningslager med antalet filter, filterkärnans storlek, utfyllnad och aktiveringsfunktion som argument.
• max_pooling2d(). Konstruerar ett tvådimensionellt poollager med hjälp av algoritmen för maxpoolning.
• tät(). Konstruerar ett tätt lager med de dolda lagren och enheterna

Du kommer att definiera en funktion för att bygga CNN. Låt oss se i detalj hur man konstruerar varje byggsten innan omslag.ping allt tillsammans i funktionen.

Steg 2: Indatalager

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

Du måste definiera en tensor med formen på data. För det kan du använda modulen tf.reshape. I den här modulen måste du förklara att tensorn ska omformas och formen på tensorn. Det första argumentet är egenskaperna hos datan, som definieras i funktionens argument.

En bild har en höjd, en bredd och en kanal. MNIST-datasetet är en monokrom bild med storleken 28×28. Vi ställer in batchstorleken till -1 i argumentet form så att den tar formen av features["x"]. Fördelen är att göra batchstorleken till en hyperparameter att finjustera. Om batchstorleken är satt till 7, kommer tensorn att mata in 5 488 värden (28*28*7).

Steg 3: Konvolutionellt lager

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

Det första faltningslagret har 14 filter med en kärnstorlek på 5×5 och samma utfyllnad. Samma utfyllnad innebär att både utgångstensorn och ingångstensorn ska ha samma höjd och bredd. TensorFlow lägger till nollor i raderna och kolumnerna för att säkerställa samma storlek.

Du använder ReLU-aktiveringsfunktionen. Utdatastorleken blir [28, 28, 14].

Steg 4: Pooling lager

Nästa steg efter faltningen är poolningsberäkningen. Poolningsberäkningen kommer att minska datadimensionaliteten. Du kan använda modulen max_pooling2d med en storlek på 2×2 och ett stridläge på 2. Du använder föregående lager som indata. Utdatastorleken blir [batch_size, 14, 14, 14].

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

Steg 5: Andra konvolutionella lagret och Pooling Lager

Det andra faltningslagret tillämpar 36 filter, vilket ger en utmatningsstorlek på [batch_size, 14, 14, 36]. Poolningslagret använder samma 2×2-fönster och strid på 2 som tidigare, så det halverar varje rumslig axel och utmatningsformen 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)

Steg 6: Tät lager

Sedan måste du definiera det helt sammankopplade lagret. Featurekartan måste plattas ut innan den ansluts till det täta lagret. Du kan använda modulen för omformning med en storlek på 7*7*36.

Det täta lagret kommer att koppla samman 1 764 neuroner. Du lägger till en ReLU-aktiveringsfunktion. Dessutom lägger du till en bortfallsregulariseringsterm med en frekvens på 0.3, vilket innebär att 30 procent av aktiveringarna kommer att sättas till 0. Observera att bortfallet endast sker under träningsfasen. Funktionen cnn_model_fn har ett argumentläge för att deklarera om modellen behöver tränas eller utvärderas, som visas i exemplet med CNN-bildklassificeringen TensorFlow nedan.

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)

Steg 7: Logit Layer

Slutligen, i exemplet med TensorFlow-bildklassificering, kan du definiera det sista lagret med modellens förutsägelse. Utdataformen är lika med batchstorleken och 10 är det totala antalet målklasser.

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

Du kan skapa en ordbok som innehåller klasserna och sannolikheten för varje klass. Funktionen tf.argmax() returnerar indexet för det högsta värdet i logits-lagret. Softmax-funktionen returnerar sannolikheten för varje klass.

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

Du vill bara returnera prediktionsordlistan när läget är inställt på prediktion. Du lägger till den här koden för att visa prediktionerna.

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

Nästa steg består av att beräkna modellens förlust. I den senaste handledningen lärde du dig att förlustfunktionen för en flerklassmodell är korsentropi. Förlusten beräknas enkelt med följande kod:

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

Det sista steget i TensorFlow CNN-exemplet är att optimera modellen, det vill säga att hitta de bästa värdena för vikterna. För det använder du en gradient descent-optimerare med en inlärningshastighet på 0.001. Målet är att minimera förlusten.

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

Du är klar med CNN. Du vill dock visa prestandamåtten under utvärderingsläget. Prestandamätet för en flerklassmodell är noggrannhet. TensorFlow är utrustad med en noggrannhetsmodul som tar två argument, etiketterna och de förutspådda värdena.

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 är allt. Du skapade ditt första CNN och du är redo att slå in allt i en funktion för att använda den för att träna och utvärdera 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)

Anmärkning om den sammansatta funktionen: Den inslagna versionen ovan ställer in det första faltningslagret till 32 filter och bortfall till 0.4, medan steg-för-steg-kodavsnitten använder 14 filter och 0.3. Båda körs, men välj ett värdepar och håll det konsekvent så att de utskrivna formerna matchar lagertabellen.

Stegen nedan är desamma som de tidigare handledningarna.

Först och främst definierar du en estimator med CNN-modellen för bildklassificering.

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

Ett CNN tar lång tid att träna, därför skapar du en loggningskrok för att lagra värdena för softmax-lagren var 50:e iteration.

# 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 är redo att uppskatta modellen. Du ställer in en batchstorlek på 100 och blandar data. Observera att vi har satt in träningssteg på 16 000, vilket kan ta lång tid att träna. Ha tålamod.

# 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 när modellen är tränad kan du utvärdera den och skriva ut resultaten.

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

Utvärderingen skriver ut den återställda kontrollpunkten, steget den stoppades vid och den slutliga mätvärdesordlistan.

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 nuvarande arkitekturen rapporterar utvärderingslexikonet en noggrannhet på 0.9689286, ungefär 97 %. Du kan ändra arkitekturen, batchstorleken och antalet iterationer för att förbättra noggrannheten. CNN har presterat mycket bättre än en artificiellt neuralt nätverk eller logistisk regression: i handledningen om artificiella neurala nätverk hade du en noggrannhet på 96 %, vilket är lägre än CNN:s. CNN:s prestanda är imponerande med en större bilduppsättning, både vad gäller beräkningshastighet och noggrannhet.

Vanliga frågor