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 i computervisionsapplikationer. 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. Det bruges i applikationer som billed- eller videogenkendelse, neural sprogbehandling osv.

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 på billedet nedenfor. Først og fremmest skubbes et billede til netværket; dette kaldes inputbilledet. Derefter gennemgår inputbilledet et uendeligt antal trin; dette er den konvolutionerende 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å). En kanal er stablet over hinanden. I denne vejledning vil du bruge 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 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æt. Billedet nedenfor viser, hvordan man repræsenterer billedet af venstre i et matrixformat. Bemærk, at den oprindelige matrix er blevet 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 foldningslaget. Denne del sigter mod at reducere størrelsen af ​​billedet for hurtigere beregninger af vægtene og forbedre dets generalisering.

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 foldende neurale netværk vil bruge en matematisk teknik til kun at udtrække de mest relevante pixels. Denne matematiske operation kaldes foldning. Denne teknik gør det muligt for netværket at lære mere og mere komplekse funktioner på hvert lag. Konvolutionen opdeler matrixen i små stykker for at lære de vigtigste elementer i hvert stykke.

Komponenter af Convolutional Neural Network (ConvNet eller CNN)

Der er fire komponenter i en Convnets

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

foldning

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

Konvolution er en elementmæssig multiplikation. Konceptet er let at forstå. Computeren scanner en del af billedet, normalt med en dimension på 3×3 og multiplicerer det til et filter. Outputtet af den elementvise multiplikation kaldes et funktionskort. Dette trin gentages, indtil hele billedet er scannet. Bemærk, at efter foldningen reduceres størrelsen af ​​billedet.

Nedenfor er der en URL for at se i aktion, hvordan foldning fungerer.

Der er mange tilgængelige kanaler. Nedenfor har vi listet nogle af kanalerne. Du kan se, at hvert filter har et bestemt formål. Bemærk, på billedet nedenfor; Kernen 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 glide disse vinduer hen over hele inputbilledet og beregne foldningen. Billedet nedenfor viser, hvordan foldningen fungerer. Størrelsen på patchen er 3×3, og outputmatrixen er resultatet af den elementmæssige operation mellem billedmatrixen 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 afskærme et 3×3 gitter. Udgangsfunktionskortet vil krympe med to fliser sammen med en 3×3 dimension.

For at få samme outputdimension som inputdimensionen skal du tilføje polstring. Padding består i at tilføje det rigtige antal rækker og kolonner på hver side af matrixen. Det vil tillade foldningen at centrere passer til hver inputflise. På billedet nedenfor har input/output matrixen samme dimension 5×5

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

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

2. stride: Den definerer antallet af "pixelspring" mellem to udsnit. Hvis skridtet er lig med 1, vil vinduerne bevæge sig med en pixels spredning på én. Hvis skridtet er lig med to, vil vinduerne hoppe med 2 pixels. Hvis du øger skridtet, vil du have mindre feature maps.

Eksempel skridt 1

skridt 2

3. Nul-polstring: En udfyldning er en operation, hvor man tilføjer et tilsvarende antal rækker og kolonner på hver side af inputfunktionskortene. I dette tilfælde har output samme dimension som input.

Ikke-linearitet (ReLU)

Ved afslutningen af ​​foldningsoperationen er outputtet underlagt en aktiveringsfunktion for at tillade ikke-linearitet. Den sædvanlige aktiveringsfunktion for convnet er Relu. Alle pixel med en negativ værdi vil blive erstattet af nul.

Pooling Operation

Dette trin er let at forstå. Formålet med sammenlægningen er at reducere dimensionaliteten af ​​inputbilledet. Trinene er udført for at reducere den beregningsmæssige kompleksitet af operationen. Ved at formindske dimensionaliteten har netværket lavere vægte at beregne, så det forhindrer overfitting.

I denne fase skal du definere størrelsen og skridtet. En standard måde at samle inputbilledet på er at bruge den maksimale værdi af featurekortet. Se på billedet nedenfor. "Pulning" vil screene en fire undermatrix af 4×4 feature map og returnere den maksimale værdi. Puljen 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], sammenlægningen vil returnere maksimum, som er 3.

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

Denne handling reducerer aggressivt størrelsen af ​​featurekortet

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

TensorFlow Convolutional Neural netværk kompilerer forskellige lag, før de foretager en forudsigelse. Et neuralt netværk har:

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

De foldede lag anvender forskellige filtre på en underregion af billedet. Relu-aktiveringsfunktionen tilføjer ikke-linearitet, og poolinglagene reducerer dimensionaliteten af ​​funktionskortene.

Alle disse lag udtrækker væsentlig information fra billederne. Til sidst føres funktionerne til et primært fuldt forbundet lag med en softmax-funktion til at lave en forudsigelse.

Træn CNN med TensorFlow

Nu hvor du er bekendt med byggestenen i en convnets, er du klar til at bygge en 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:

Trin 1: Upload datasæt

Trin 2: Inputlag

Trin 3: Konvolutionslag

Trin 4: Pooling lag

Trin 5: Andet foldningslag og Pooling lag

Trin 6: Tæt lag

Trin 7: Logit Layer

Trin 1: Upload datasæt

MNIST-datasættet er tilgængeligt med scikit for at lære dette URL. Download det og gem det i Downloads. Du kan uploade det med fetch_mldata('MNIST original').

Lav et tog/testsæt

Du skal opdele datasættet med train_test_split

Skaler funktionerne

Endelig kan du skalere funktionen 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

En CNN bruger filtre på den rå pixel af et billede for at lære detaljerede mønstre sammenlignet med globale mønstre med et traditionelt neuralt net. For at konstruere et CNN skal du definere:

1. Et foldningslag: Anvend n antal filtre på featurekortet. Efter foldningen skal du bruge en Relu-aktiveringsfunktion for at tilføje ikke-linearitet til netværket.
2. Pooling-lag: Det næste trin efter foldningen er at nedsample funktionen max. Formålet er at reducere dimensionaliteten af ​​funktionskortet for at forhindre overtilpasning og forbedre beregningshastigheden. Max pooling er den konventionelle teknik, som opdeler feature maps i underregioner (normalt med en 2×2 størrelse) 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 (udtrækker 5×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 vil definere en funktion til at bygge CNN. Lad os se i detaljer, hvordan man konstruerer hver byggeklods, før vi pakker 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 monokront billede med en størrelse på 28×28. Vi sætter batchstørrelsen til -1 i formargumentet, så det tager formen af ​​funktionerne[“x”]. Fordelen er at få batchstørrelseshyperparametrene til at tune. 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 foldningslag har 14 filtre med en kernestørrelse på 5×5 med samme polstring. Den samme polstring 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 foldningen er pooling-beregningen. Pooling-beregningen vil reducere dimensionaliteten af ​​dataene. Du kan bruge modulet max_pooling2d med en størrelse på 2×2 og stride på 2. Du bruger det forrige 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 foldningslag har 32 filtre med en outputstørrelse på [batch_size, 14, 14, 32]. Poolinglaget har samme størrelse som før, og outputformen er [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)

Trin 6: Tæt lag

Derefter skal du definere det fuldt forbundne lag. Funktionskortet skal være fladt, før det kan forbindes med det tætte lag. Du kan bruge modulet omformning med en størrelse på 7*7*36.

Det tætte lag vil forbinde 1764 neuroner. Du tilføjer en Relu-aktiveringsfunktion. Desuden tilføjer du en frafaldsregulariseringsterm med en rate på 0.3, hvilket betyder, at 30 procent af vægtene vil blive sat til 0. Bemærk, at frafaldet kun finder sted i træningsfasen. Funktionen cnn_model_fn har en argumenttilstand til at erklære, om modellen skal trænes eller til at evaluere som vist i nedenstående CNN-billedklassificering TensorFlow-eksempel.

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

Til sidst i TensorFlow-billedklassificeringseksemplet kan du definere det sidste lag med modellens forudsigelse. Outputformen er lig med batchstørrelsen og 10, det samlede antal billeder.

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

Du kan oprette en ordbog, der indeholder klasserne og sandsynligheden for hver klasse. Modulet tf.argmax() with returnerer den højeste værdi, hvis logit-lagene. Funktionen softmax 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 ordbogsforudsigelsen, når tilstanden er indstillet til forudsigelse. Du tilføjer disse koder 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 tabet af modellen. I den sidste tutorial 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 af vægtene. Til det bruger du en Gradient descent optimizer med en indlæringshastighed 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. Ydeevnemålingerne for en multiklassemodel er nøjagtighedsmålingerne. Tensorflow er udstyret med en modulnøjagtighed med 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)

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

En CNN tager mange gange at træne, derfor opretter du en Logging-hook til at gemme værdierne af softmax-lagene hver 50. 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 er klar til at estimere modellen. Du indstiller en batchstørrelse på 100 og blander dataene. Bemærk at vi sætter træningstrin på 16.000, det kan tage meget 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 i gang, 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)

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 får du en nøjagtighed på 97%. Du kan ændre arkitekturen, batchstørrelsen og antallet af iterationer for at forbedre nøjagtigheden. CNNs neurale netværk har klaret sig langt bedre end ANN eller logistisk regression. I selvstudiet om kunstigt neuralt netværk havde du en nøjagtighed på 96%, hvilket er lavere CNN. Præstationerne fra CNN er imponerende med et større billede sæt, både hvad angår hastighedsberegning og nøjagtighed.

Resumé

Et foldet neuralt netværk fungerer meget godt til at evaluere billede. Denne type arkitektur er dominerende til at genkende objekter fra et billede eller en video.

For at bygge en TensorFlow CNN skal du følge syv trin:

Trin 1: Upload datasæt:

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

Trin 2: Input lag:

Dette trin omformer dataene. Formen er lig med kvadratroden af ​​antallet af pixels. For eksempel, hvis et billede har 156 pixels, er formen 26×26. Du skal angive, om billedet har farve eller ej. Hvis ja, så havde du 3 til formen- 3 for RGB-, ellers 1.

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

Trin 3: Konvolutionerende lag

Dernæst skal du oprette de foldede lag. Du anvender forskellige filtre for at tillade netværket at lære vigtige funktioner. Du angiver størrelsen på kernen og mængden af ​​filtre.

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

Trin 4: Pooling lag

I det tredje trin tilføjer du et pooling-lag. Dette lag reducerer størrelsen af ​​input. Det gør det ved at tage den maksimale værdi af en undermatrix. For eksempel, hvis undermatrixen er [3,1,3,2], vil poolingen returnere maksimum, som er 3.

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

Trin 5: Tilføj Convolutional Layer og Pooling lag

I dette trin kan du tilføje så meget som du ønsker konv-lag og pooling-lag. Google bruger arkitektur med mere end 20 konv. lag.

Trin 6: Tæt lag

Trin 6 flad det forrige ud for at skabe et fuldt forbundet lag. I dette trin kan du bruge forskellige aktiveringsfunktioner og tilføje en frafaldseffekt.

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

Det sidste trin er forudsigelsen.

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