CNN bildeklassifisering i TensorFlow med trinn og eksempler

Hva er Convolutional Neural Network?

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

ArchiTecture of a Convolutional Neural Network

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

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

En typisk konvnet-arkitektur kan oppsummeres i bildet nedenfor. Først av alt skyves et bilde til nettverket; dette kalles inngangsbildet. Deretter går inndatabildet gjennom et uendelig antall trinn; dette er den konvolusjonelle delen av nettverket. Til slutt kan det nevrale nettverket forutsi sifferet på bildet.

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

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

Konvolusjonsoperasjon

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

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

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

Komponenter i Convolutional Neural Network (ConvNet eller CNN)

Det er fire komponenter i en Convnets

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

Konvolusjon

Hensikten med konvolusjonen er å trekke ut egenskapene til objektet på bildet lokalt. Det betyr at nettverket vil lære spesifikke mønstre i bildet og vil kunne gjenkjenne det overalt i bildet.

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

Nedenfor er det en URL for å se i aksjon hvordan konvolusjon fungerer.

Det er mange tilgjengelige kanaler. Nedenfor har vi listet opp noen av kanalene. Du kan se at hvert filter har et bestemt formål. Merk, på bildet nedenfor; Kjernen er et synonym til filteret.

Aritmetikk bak konvolusjonen

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

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

Grenseeffekt

Bildet har et 5×5 funksjonskart og et 3×3 filter. Det er bare ett vindu i midten hvor filteret kan skjerme et 3×3 rutenett. Utdatakartet vil krympe med to fliser sammen med en 3×3-dimensjon.

For å få samme utdatadimensjon som inngangsdimensjonen, må du legge til polstring. Utfylling består av å legge til riktig antall rader og kolonner på hver side av matrisen. Det vil tillate konvolusjonen å sentrere passe hver inngangsflis. På bildet nedenfor har input/output matrisen samme dimensjon 5×5

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

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

2. Skritt: Den definerer antall "pikselhopp" mellom to skiver. Hvis skrittet er lik 1, vil vinduene bevege seg med en piksels spredning på én. Hvis skrittet er lik to, vil vinduene hoppe med 2 piksler. Hvis du øker skrittet, vil du ha mindre funksjonskart.

Eksempel skritt 1

skritt 2

3. Null-polstring: En utfylling er en operasjon for å legge til et tilsvarende antall rader og kolonner på hver side av kartene for inndatafunksjoner. I dette tilfellet har utgangen samme dimensjon som inngangen.

Ikke-linearitet (ReLU)

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

Pooling Operasjon

Dette trinnet er lett å forstå. Formålet med sammenslåingen er å redusere dimensjonaliteten til inngangsbildet. Trinnene er gjort for å redusere den beregningsmessige kompleksiteten til operasjonen. Ved å redusere dimensjonaliteten har nettverket lavere vekter å beregne, slik at det forhindrer overtilpasning.

I dette stadiet må du definere størrelsen og skrittet. En standard måte å samle inndatabildet på er å bruke maksimalverdien til funksjonskartet. Se på bildet nedenfor. "Samling" vil vise en fire undermatrise av 4×4 funksjonskart og returnere maksimalverdien. Sammenslåingen tar den maksimale verdien av en 2×2-matrise og flytter deretter vinduene med to piksler. For eksempel er den første undermatrisen [3,1,3,2], sammenslåingen vil returnere maksimum, som er 3.

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

Denne operasjonen reduserer kraftig størrelsen på funksjonskartet

Fullt tilkoblede lag

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

Oppsummering:

TensorFlow Convolutional Neural-nettverk kompilerer forskjellige lag før de lager en prediksjon. Et nevralt nettverk har:

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

Konvolusjonslagene bruker forskjellige filtre på en underregion av bildet. Relu-aktiveringsfunksjonen legger til ikke-linearitet, og sammenslåingslagene reduserer dimensjonaliteten til funksjonskartene.

Alle disse lagene trekker ut viktig informasjon fra bildene. Til slutt mates funksjonskartet til et primært fullt tilkoblet lag med en softmax-funksjon for å lage en prediksjon.

Tren CNN med TensorFlow

Nå som du er kjent med byggesteinen til en konvnet, er du klar til å bygge en med tensorflow. Vi vil bruke MNIST-datasettet for CNN-bildeklassifisering.

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

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

Trinn 1: Last opp datasett

Trinn 2: Inndatalag

Trinn 3: Konvolusjonslag

Trinn 4: Pooling lag

Trinn 5: Andre konvolusjonslag og Pooling Lag

Trinn 6: Tett lag

Trinn 7: Logit Layer

Trinn 1: Last opp datasett

MNIST-datasettet er tilgjengelig med scikit for å lære om dette URL. Last den ned og lagre den i Nedlastinger. Du kan laste den opp med fetch_mldata('MNIST original').

Lag et tog/testsett

Du må dele datasettet med train_test_split

Skaler funksjonene

Til slutt kan du skalere funksjonen med MinMaxScaler som vist i bildeklassifiseringen nedenfor ved å bruke 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 bruker filtre på den rå pikselen til et bilde for å lære detaljert mønster sammenlignet med globalt mønster med et tradisjonelt nevralt nett. For å konstruere et CNN, må du definere:

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

CNN arkitektur

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

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

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

Du vil definere en funksjon for å bygge CNN. La oss se i detalj hvordan du konstruerer hver byggekloss før vi pakker alt sammen i funksjonen.

Trinn 2: Inndatalag

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

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

Et bilde har en høyde, en bredde og en kanal. MNIST-datasettet er et monokront bilde med en størrelse på 28×28. Vi setter batchstørrelsen til -1 i formargumentet slik at den tar formen til funksjonene[“x”]. Fordelen er å få batchstørrelseshyperparametrene til å justere. Hvis batchstørrelsen er satt til 7, vil tensoren mate 5,488 verdier (28*28*7).

Trinn 3: Konvolusjonslag

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

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

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

Trinn 4: Pooling lag

Det neste trinnet etter konvolusjonen er sammenslåingsberegningen. Sammenslåingsberegningen vil redusere dimensjonaliteten til dataene. Du kan bruke modulen max_pooling2d med en størrelse på 2×2 og skritt på 2. Du bruker forrige lag som input. Utdatastørrelsen vil være [batch_size, 14, 14, 14]

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

Trinn 5: Andre konvolusjonslag og Pooling Lag

Det andre konvolusjonslaget har 32 filtre, med en utdatastørrelse på [batch_size, 14, 14, 32]. Sammenslåingslaget har samme størrelse som før og utdataformen 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)

Trinn 6: Tett lag

Deretter må du definere det fullt tilkoblede laget. Funksjonskartet må være flatt før det kan kobles til det tette laget. Du kan bruke modulomformingen med en størrelse på 7*7*36.

Det tette laget vil forbinde 1764 nevroner. Du legger til en Relu-aktiveringsfunksjon. Dessuten legger du til en frafallsregulariseringsterm med en rate på 0.3, noe som betyr at 30 prosent av vektene settes til 0. Merk at frafallet bare finner sted under treningsfasen. Funksjonen cnn_model_fn har en argumentmodus for å deklarere om modellen må trenes eller for å evaluere som vist i eksemplet under CNN-bildeklassifiseringen 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)

Trinn 7: Logit Layer

Til slutt i TensorFlow-bildeklassifiseringseksemplet kan du definere det siste laget med prediksjonen til modellen. Utdataformen er lik batchstørrelsen og 10, det totale antallet bilder.

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

Du kan lage en ordbok som inneholder klassene og sannsynligheten for hver klasse. Modulen tf.argmax() with returnerer den høyeste verdien hvis logit-lagene. Softmax-funksjonen returnerer sannsynligheten for hver klasse.

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

Du vil bare returnere ordbokprediksjonen når modus er satt til prediksjon. Du legger til disse kodene for å vise spådommene

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

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

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

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

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

Du er ferdig med CNN. Du vil imidlertid vise ytelsesberegningene under evalueringsmodusen. Ytelsesberegningene for en flerklassemodell er nøyaktighetsberegningene. Tensorflow er utstyrt med en modulnøyaktighet med to argumenter, etikettene og de predikerte verdiene.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

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

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

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

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

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

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

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

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

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Trinnene nedenfor er de samme som de tidligere veiledningene.

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

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

En CNN tar mange ganger å trene, derfor lager du en Logging-hook for å lagre verdiene til softmax-lagene hver 50. iterasjon.

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

Du er klar til å anslå modellen. Du angir en batchstørrelse på 100 og blander dataene. Merk at vi setter treningstrinn på 16.000, det kan ta mye tid å trene. Vær tålmodig.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Nå som modellen er i gang, kan du evaluere den og skrive ut resultatene

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

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 dagens arkitektur får du en nøyaktighet på 97 %. Du kan endre arkitekturen, batchstørrelsen og antall iterasjoner for å forbedre nøyaktigheten. CNNs nevrale nettverk har prestert langt bedre enn ANN eller logistisk regresjon. I opplæringen om kunstig nevrale nettverk hadde du en nøyaktighet på 96%, som er lavere CNN. Prestasjonene til CNN er imponerende med et større bilde sett, både når det gjelder hastighetsberegning og nøyaktighet.

Sammendrag

Et konvolusjonelt nevralt nettverk fungerer veldig bra for å evaluere bildet. Denne typen arkitektur er dominerende for å gjenkjenne objekter fra et bilde eller en video.

For å bygge en TensorFlow CNN, må du følge syv trinn:

Trinn 1: Last opp datasett:

MNIST-datasettet er tilgjengelig med scikit for å lære. Last den ned og lagre den i Nedlastinger. Du kan laste den opp med fetch_mldata('MNIST original').

Trinn 2: Inndatalag:

Dette trinnet omformer dataene. Formen er lik kvadratroten av antall piksler. For eksempel, hvis et bilde har 156 piksler, er formen 26×26. Du må spesifisere om bildet har farger eller ikke. Hvis ja, så hadde du 3 til formen- 3 for RGB-, ellers 1.

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

Trinn 3: Konvolusjonslag

Deretter må du lage konvolusjonslagene. Du bruker forskjellige filtre for å la nettverket lære viktige funksjoner. Du spesifiserer størrelsen på kjernen og mengden filtre.

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

Trinn 4: Pooling lag

I det tredje trinnet legger du til et samlingslag. Dette laget reduserer størrelsen på inngangen. Det gjør det ved å ta den maksimale verdien av en undermatrise. For eksempel, hvis undermatrisen er [3,1,3,2], vil sammenslåingen returnere maksimum, som er 3.

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

Trinn 5: Legg til Convolutional Layer og Pooling Lag

I dette trinnet kan du legge til så mye du vil konv-lag og pooling-lag. Google bruker arkitektur med mer enn 20 konv.lag.

Trinn 6: Tett lag

Trinn 6 flater ut det forrige for å lage et fullstendig sammenkoblet lag. I dette trinnet kan du bruke en annen aktiveringsfunksjon og legge til en frafallseffekt.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Trinn 7: Logit Layer

Det siste trinnet er spådommen.

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