CNN-bildklassificering i TensorFlow med steg och exempel

Vad är Convolutional Neural Network?

Konvolutionellt neuralt nätverk, även känd som convnets eller CNN, är en välkänd metod i datorseendeapplikationer. 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. Det används i applikationer som bild- eller videoigenkänning, neural språkbehandling, etc.

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 konvnet-arkitektur kan sammanfattas i bilden nedan. Först och främst skjuts en bild till nätverket; detta kallas ingångsbilden. Sedan går ingångsbilden igenom ett oändligt antal steg; detta är den konvolutionerande delen av nätverket. Slutligen kan det neurala nätverket förutsäga siffran på bilden.

En bild består av en uppsättning pixlar med höjd och bredd. En gråskalebild har bara en kanal medan färgbilden har tre kanaler (var och en för röd, grön och blå). En kanal staplas över varandra. I den här handledningen kommer du att använda en gråskalebild med endast 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 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ättning. Bilden nedan visar hur man representerar bilden av 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 mest kritiska komponenten i modellen är faltningsskiktet. Denna del syftar till att minska storleken på bilden för snabbare beräkningar av vikterna och förbättra dess generalisering.

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 konvolutionella neurala nätverk kommer att använda en matematisk teknik för att extrahera endast de mest relevanta pixlarna. Denna matematiska operation kallas faltning. Denna teknik gör att nätverket kan lära sig allt mer komplexa funktioner i varje lager. Konvolutionen 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 en Convnets

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

Faltning

Syftet med faltningen är att extrahera objektets egenskaper på bilden lokalt. Det betyder att nätverket kommer att lära sig specifika mönster i bilden och kommer att kunna känna igen det ö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 till ett filter. Utdata från den elementvisa multiplikationen kallas en funktionskarta. Detta steg upprepas tills hela bilden har skannats. Observera att storleken på bilden minskas efter faltningen.

Nedan finns en URL för att se hur faltning fungerar.

Det finns många tillgängliga kanaler. Nedan listar vi några av kanalerna. Du kan se att varje filter har ett specifikt syfte. Notera, på bilden nedan; kärnan är en synonym till filtret.

Aritmetik bakom faltningen

Konvolutionsfasen kommer att applicera filtret på en liten uppsättning pixlar i bilden. Filtret kommer att röra sig längs inmatningsbilden med en allmän form på 3×3 eller 5×5. Det betyder att nätverket kommer att skjuta dessa fönster över all ingångsbild och beräkna faltningen. Bilden nedan visar hur faltningen fungerar. Storleken på patchen är 3×3, och utmatrisen är resultatet av den elementmässiga 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 avskärma ett 3×3 rutnät. Utdatakartan kommer att krympa med två brickor tillsammans med en 3×3 dimension.

För att få samma utmatningsmått som inmatningsmåttet 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 kommer att tillåta faltningen att centreras för att passa varje ingångsbricka. På bilden nedan har in-/utgångsmatrisen samma dimension 5×5

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

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

2. Kliva: Den definierar antalet "pixelhopp" mellan två skivor. Om steget är lika med 1 kommer fönstren att röra sig med en pixels spridning på en. Om steget är lika med två kommer fönstren att hoppa med 2 pixlar. Om du ökar steget kommer du att ha mindre kartor.

Exempel steg 1

steg 2

3. Noll stoppning: En utfyllnad är en operation för att lägga till ett motsvarande antal rader och kolumner på varje sida av kartorna för inmatningsfunktioner. I detta fall har utgången samma dimension som ingången.

Icke linjäritet (ReLU)

I slutet av faltningsoperationen är utgången föremål för en aktiveringsfunktion för att tillåta icke-linjäritet. Den vanliga aktiveringsfunktionen för convnet är Relu. Alla pixlar med ett negativt värde kommer att ersättas med noll.

Pooling Operation

Detta steg är lätt att förstå. Syftet med poolningen är att reducera dimensionaliteten hos inmatningsbilden. Stegen görs för att minska operationens beräkningskomplexitet. Genom att minska dimensionaliteten har nätverket lägre vikter att beräkna, så det förhindrar överanpassning.

I detta skede måste du definiera storleken och steget. Ett standardsätt att slå samman inmatningsbilden är att använda det maximala värdet på funktionskartan. Titta på bilden nedan. "Passningen" kommer att visa en fyra delmatris av 4×4-funktionskartan och returnera det maximala värdet. Poolningen tar det maximala värdet av en 2×2-array och flyttar sedan detta fönster med två pixlar. Till exempel är den första undermatrisen [3,1,3,2], poolningen kommer att returnera det maximala, vilket är 3.

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

Denna operation minskar kraftigt storleken på funktionskartan

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:

TensorFlow Convolutional Neural Network 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

De faltande lagren tillämpar olika filter på en delregion av bilden. Relu-aktiveringsfunktionen lägger till icke-linjäritet, och poolskikten minskar dimensionaliteten på kartorna.

Alla dessa lager extraherar viktig information från bilderna. Äntligen matas funktionskartan till ett primärt fullt anslutet 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 byggstenen i en konvnet är du redo att bygga en 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:

Steg 1: Ladda upp datauppsättning

Steg 2: Indatalager

Steg 3: Konvolutionellt lager

Steg 4: Pooling lager

Steg 5: Andra konvolutionella lagret och Pooling Lager

Steg 6: Tät lager

Steg 7: Logit Layer

Steg 1: Ladda upp datauppsättning

MNIST-datauppsättningen är tillgänglig med scikit för att lära dig detta URL. Ladda ner den och lagra den i Nedladdningar. Du kan ladda upp den med fetch_mldata('MNIST original').

Skapa ett tåg/testset

Du måste dela upp datasetet med train_test_split

Skala funktionerna

Slutligen kan du skala funktionen med MinMaxScaler som visas i bildklassificeringen nedan med 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

En CNN använder filter på den råa pixeln i en bild för att lära sig detaljer mönster jämfört med globala mönster med ett traditionellt neuralt nät. För att konstruera ett CNN måste du definiera:

1. Ett faltningslager: Tillämpa n antal filter på funktionskartan. Efter faltningen måste du använda en Relu-aktiveringsfunktion för att lägga till icke-linjäritet till nätverket.
2. Pooling lager: Nästa steg efter faltningen är att nedsampla funktionen max. Syftet är att minska dimensionaliteten hos funktionskartan för att förhindra överanpassning och förbättra beräkningshastigheten. Max pooling är den konventionella tekniken, som delar in funktionskartorna i underregioner (vanligtvis med en 2×2 storlek) och behåller endast 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 (extraherar 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 för att slå ihop allt 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-datauppsättningen är en monokron bild med storleken 28×28. Vi ställer in batchstorleken till -1 i formargumentet så att det tar formen av funktionerna[“x”]. Fördelen är att få batchstorlekshyperparametrarna att ställa in. Om batchstorleken är inställd på 7 kommer tensorn att mata 5,488 28 värden (28*7*XNUMX).

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 faltningsskiktet har 14 filter med en kärnstorlek på 5×5 med samma stoppning. Samma stoppning betyder att både utgångstensor och ingångstensor ska ha samma höjd och bredd. Tensorflow lägger till nollor till raderna och kolumnerna för att säkerställa samma storlek.

Du använder Relu-aktiveringsfunktionen. Utdatastorleken kommer att vara [28, 28, 14].

Steg 4: Pooling lager

Nästa steg efter faltningen är poolningsberäkningen. Poolningsberäkningen kommer att minska dimensionaliteten hos datan. Du kan använda modulen max_pooling2d med en storlek på 2×2 och steg på 2. Du använder föregående lager som indata. Utdatastorleken kommer att vara [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 faltningsskiktet har 32 filter, med en utdatastorlek på [batch_size, 14, 14, 32]. Poolningsskiktet har samma storlek som tidigare och utdataformen är [batch_size, 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)

Steg 6: Tät lager

Sedan måste du definiera det helt anslutna lagret. Funktionskartan måste plattas ut innan den kan kopplas ihop med det täta lagret. Du kan använda modulens omformning med storleken 7*7*36.

Det täta lagret kommer att ansluta 1764 neuroner. Du lägger till en Relu-aktiveringsfunktion. Dessutom lägger du till en regleringsterm för bortfall med en frekvens på 0.3, vilket innebär att 30 procent av vikterna kommer att ställas in på 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 för att utvärdera som visas i nedanstående CNN-bildklassificering TensorFlow-exempel.

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 TensorFlow-bildklassificeringsexemplet kan du definiera det sista lagret med modellens förutsägelse. Utdataformen är lika med batchstorleken och 10, det totala antalet bilder.

# 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. Modulen tf.argmax() with returnerar det högsta värdet om logit-lagren. Funktionen softmax 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 ordboksförutsägelsen när läget är inställt på förutsägelse. Du lägger till dessa koder för att visa förutsägelserna

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

Nästa steg består i att beräkna förlusten av modellen. I den senaste handledningen lärde du dig att förlustfunktionen för en multiklassmodell ä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 på vikterna. För det använder du en Gradient descent optimizer 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åtten för en multiklassmodell är noggrannhetsmåtten. Tensorflow är utrustad med en modulnoggrannhet med två argument, etiketterna och de förutsagda 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)

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

En CNN tar många gånger 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 sätter träningssteg på 16.000 XNUMX, det kan ta mycket 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 utbildad 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)

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 nuvarande arkitektur får du en noggrannhet på 97%. Du kan ändra arkitekturen, batchstorleken och antalet iterationer för att förbättra noggrannheten. CNN:s neurala nätverk har presterat mycket bättre än ANN eller logistisk regression. I handledningen om artificiella neurala nätverk hade du en noggrannhet på 96%, vilket är lägre CNN. CNN:s prestationer är imponerande med en större bild in, både när det gäller hastighetsberäkning och noggrannhet.

Sammanfattning

Ett konvolutionellt neuralt nätverk fungerar mycket bra för att utvärdera bild. Denna typ av arkitektur är dominerande för att känna igen objekt från en bild eller video.

För att bygga ett TensorFlow CNN måste du följa sju steg:

steg 1: Ladda upp datauppsättning:

MNIST-datauppsättningen är tillgänglig med scikit för att lära dig. Ladda ner den och lagra den i Nedladdningar. Du kan ladda upp den med fetch_mldata('MNIST original').

steg 2: Indatalager:

Detta steg omformar data. Formen är lika med kvadratroten av antalet pixlar. Till exempel, om en bild har 156 pixlar är formen 26×26. Du måste ange om bilden har färg eller inte. Om ja, hade du 3 till formen- 3 för RGB-, annars 1.

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

steg 3: Konvolutionerande lager

Därefter måste du skapa faltningsskikten. Du använder olika filter för att låta nätverket lära sig viktiga funktioner. Du anger storleken på kärnan och antalet filter.

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

steg 4: Pooling lager

I det tredje steget lägger du till ett poollager. Detta lager minskar storleken på inmatningen. Det gör det genom att ta det maximala värdet av a-undermatrisen. Till exempel, om undermatrisen är [3,1,3,2], kommer poolningen att returnera det maximala, vilket är 3.

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

steg 5: Lägg till Convolutional Layer och Pooling Lager

I det här steget kan du lägga till så mycket som du vill ha konvlager och poollager. Google använder arkitektur med mer än 20 konv.lager.

steg 6: Tätt lager

Steg 6 platta till det föregående för att skapa ett helt sammankopplat lager. I det här steget kan du använda olika aktiveringsfunktioner och lägga till en bortfallseffekt.

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

Det sista steget är förutsägelsen.

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