Hva er Convolutional Neural Network?
Konvolusjonalt nevrale nettverk, også kjent som convnets eller CNN, er en velkjent metode i datasynsapplikasjoner. Denne typen arkitektur er dominerende for å gjenkjenne objekter fra et bilde eller en video.
I denne opplæringen lærer du hvordan du konstruerer et konvnet og hvordan du bruker TensorFlow til å løse det håndskrevne datasettet.
I denne veiledningen vil du lære
- Convolutional Neural Network
- Arkitektur av et konvolusjonalt nevralt nettverk
- Komponenter av Convnets
- Tren CNN med TensorFlow
- Trinn 1: Last opp datasett
- Trinn 2: Inndatasjikt
- Trinn 3: Konvolusjonslag
- Trinn 4: Bassenglag
- Trinn 5: Andre Convolutional Layer og Pooling Layer
- Trinn 6: Tett lag
- Trinn 7: Logit Layer
Arkitektur av et konvolusjonalt nevralt nettverk
Tenk på Facebook for noen år siden, etter at du lastet opp et bilde til profilen din, ble du bedt om å legge et navn til ansiktet på bildet manuelt. I dag bruker Facebook convnet for å merke vennen din automatisk på bildet.
Et konvolusjonalt nevralt nettverk er ikke veldig vanskelig å forstå. Et inngangsbilde behandles i løpet av konvolusjonsfasen og tilskrives senere en etikett.
En typisk convnet-arkitektur kan oppsummeres i bildet nedenfor. Først og fremst skyves et bilde til nettverket; dette kalles inngangsbildet. Deretter går inngangsbildet gjennom et uendelig antall trinn; dette er den konvolusjonelle delen av nettverket. Endelig kan nevrale nettverk forutsi sifferet på bildet.
Et bilde består av en rekke piksler med høyde og bredde. Et gråtonebilde har bare en 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 fargenes intensitet. 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 se på et bilde som er lagret i MNIST-datasettet. Bildet nedenfor viser hvordan du skal 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 viktigste funksjonene i 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 piksler, inkludert de fra fjellet, som ikke er viktig og kan villede nettverket.
I stedet vil et konvolusjonalt nevrale nettverk 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 om de viktigste elementene i hvert stykke.
Komponenter av Convnets
Det er fire komponenter i en Convnets
- Konvolusjon
- Ikke-lineæritet (ReLU)
- Pooling eller undersampling
- Klassifisering (fullt koblet lag)
- Konvolusjon
Formålet med konvolusjonen er å trekke ut funksjonene 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 skanner en del av bildet, vanligvis med en dimensjon på 3x3 og multipliserer det til et filter. Resultatet av den elementvise multiplikasjonen kalles et funksjonskart. Dette trinnet gjentas til hele bildet er skannet. Merk at etter konvolusjonen blir bildestørrelsen redusert.
Nedenfor er det en URL for å se hvordan handling fungerer.
Det er mange kanaler tilgjengelig. Nedenfor listet vi opp noen av kanalene. Du kan se at hvert filter har et bestemt formål. Merk, på bildet nedenfor; kjernen er et synonym for filteret.
Kilde
Aritmetikk bak konvolusjonen
Konvolusjonsfasen vil bruke filteret på et lite utvalg av piksler i bildet. Filteret vil bevege seg langs inngangsbildet med en generell form på 3x3 eller 5x5. Det betyr at nettverket vil skyve disse vinduene over hele inngangsbildet og beregne konvolusjonen. Bildet nedenfor viser hvordan konvolusjonen fungerer. Størrelsen på lappen er 3x3, og utmatrisen er resultatet av den elementvise operasjonen mellom bildematrisen og filteret.
Kilde
Du merker 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 5x5-funksjonskart og et 3x3-filter. Det er bare ett vindu i midten der filteret kan skjerme et 3x3 rutenett. Utgangsfunksjonskartet vil krympe med to fliser sammen med en 3x3-dimensjon.
For å få den samme utgangsdimensjonen som inngangsdimensjonen, må du legge til polstring. Polstring består i å legge til riktig antall rader og kolonner på hver side av matrisen. Det vil tillate at konvolusjonen sentrerer for alle inngangsfliser. På bildet nedenfor har inngangs- / utgangsmatrisen samme dimensjon 5x5
Når du definerer nettverket, styres de innviklede funksjonene av tre parametere:
- 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 det meste av saken er det mer enn ett filter. Bildet nedenfor viser operasjonene utført i en situasjon med tre filtre
- Stride: Den definerer antall "pixel's jump" mellom to skiver. Hvis trinnet er lik 1, vil vinduene bevege seg med en piksels spredning på en. Hvis trinnet er lik to, vil vinduene hoppe med 2 piksler. Hvis du øker skrittet, vil du ha mindre funksjonskart.
Eksempel skritt 1
Bildetrinn 2
- Nullpolstring: En polstring er en operasjon for å legge til et tilsvarende antall rader og kolonner på hver side av inngangsfunksjonskartene. I dette tilfellet har utgangen samme dimensjon som inngangen.
- Ikke-lineæritet (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 blir erstattet av null.
- Max-pooling-operasjon
Dette trinnet er lett å forstå. Formålet med pooling er å redusere dimensjonaliteten til inngangsbildet. Trinnene er gjort for å redusere beregningskompleksiteten til operasjonen. Ved å redusere dimensjonaliteten har nettverket lavere vekter å beregne, slik at det forhindrer overmontering.
I dette stadiet må du definere størrelse og skritt. En standard måte å samle inngangsbildet på er å bruke maksimumsverdien til funksjonskartet. Se på bildet nedenfor. "Pooling" vil skjerme en fire undermatrise av 4x4-funksjonskartet og returnere maksimumsverdien. Samlingen tar maksimumsverdien til en 2x2 matrise, og flytt deretter vinduene med to piksler. For eksempel er den første undermatrisen [3,1,3,2], pooling vil returnere maksimum, som er 3.
Det er en annen pooling-operasjon som gjennomsnittet.
Denne operasjonen reduserer størrelsen på funksjonskartet aggressivt
- Fullt sammenkoblede lag
Det siste trinnet består i å bygge et tradisjonelt kunstig nevralt nettverk som du gjorde i forrige opplæring. Du kobler alle nevroner fra forrige lag til neste lag. Du bruker en softmax-aktiveringsfunksjon for å klassifisere nummeret på inngangsbildet.
Oppsummering:
Convolutional Neural network kompilerer forskjellige lag før det forutsies. Et nevralt nettverk har:
- Et konvolusjonslag
- Relu-aktiveringsfunksjon
- Bassenglag
- Tett sammenkoblet lag
Konvolusjonslagene bruker forskjellige filtre på en underregion av bildet. Relu-aktiveringsfunksjonen legger til ikke-linearitet, og bassenglagene reduserer dimensjonaliteten til funksjonskartene.
Alle disse lagene henter viktig informasjon fra bildene. Endelig blir funksjonskartet matet til et primært fullkoblet lag med en softmax-funksjon for å forutsi.
Tren CNN med TensorFlow
Nå som du er kjent med byggesteinen til en convnets, er du klar til å bygge en med TensorFlow. Vi vil bruke MNIST-datasettet for bildeklassifisering.
Dataforberedelsen er den samme som den forrige opplæringen. Du kan kjøre kodene og hoppe direkte til CNNs arkitektur.
Du vil følge trinnene nedenfor:
Trinn 1: Last opp datasett
Trinn 2: Inndatasjikt
Trinn 3: Konvolusjonslag
Trinn 4: Bassenglag
Trinn 5: Andre Convolutional Layer og Pooling Layer
Trinn 6: Tett lag
Trinn 7: Logit Layer
Trinn 1: Last opp datasett
MNIST-datasettet er tilgjengelig med scikit for å lære på denne URL-en. Last ned den 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
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_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 )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_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å pikselet i et bilde for å lære detaljemønster sammenlignet med globalt mønster med et tradisjonelt nevralnett. For å konstruere en CNN, må du definere:
- Et konvolusjonslag: Bruk n antall filtre på funksjonskartet. Etter konvolusjonen må du bruke en Relu-aktiveringsfunksjon for å legge til ikke-linearitet i nettverket.
- Bassenglag: Det neste trinnet etter konvolusjonen er å nedprøve funksjonen maks. Hensikten er å redusere dimensjonaliteten til funksjonskartet for å forhindre overmontering og forbedre beregningshastigheten. Maks pooling er den konvensjonelle teknikken, som deler funksjonskartene i underregioner (vanligvis med en 2x2-størrelse) og holder bare maksimale verdier.
- 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 redusert med bassenglaget.
CNN-arkitektur
- Convolutional Layer: Bruker 14 5x5 filtre (trekker ut 5 x 5 piksler underregioner), med ReLU-aktiveringsfunksjon
- Pooling Layer: Utfører maks pooling med et 2x2 filter og stride på 2 (som spesifiserer at poolede regioner ikke overlapper hverandre)
- Convolutional Layer: Bruker 36 5x5 filtre, med ReLU aktiveringsfunksjon
- Pooling Layer 2: Igjen, utfører maks pooling med et 2x2 filter og stride på 2
- 1764 nevroner, med frafallsregulariseringsrate på 0,4 (sannsynlighet for 0,4 at et hvilket som helst element vil bli droppet under trening)
- Tett lag (Logits Layer): 10 nevroner, ett for hver siffer målklasse (0-9).
Det er tre viktige moduler som skal brukes til å lage et CNN:
- conv2d (). Konstruerer et todimensjonalt konvolusjonslag med antall filtre, filterkjernestørrelse, polstring og aktiveringsfunksjon som argumenter.
- max_pooling2d (). Konstruerer et todimensjonalt poolinglag ved bruk av max-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 byggestein før for å pakke alt sammen i funksjonen.
Trinn 2: Inndatasjikt
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. For det kan du bruke modulen tf.reshape. I denne modulen må du erklære at tensoren skal omformes og tensorens form. Det første argumentet er funksjonene til dataene, som er definert i argumentet til funksjonen.
Et bilde har høyde, bredde og kanal. MNIST-datasettet er et monokronisk bilde med en størrelse på 28x28. Vi satte batchstørrelsen til -1 i formargumentet slik at det tar form av funksjonene ["x"]. Fordelen er å lage batchstørrelse hyperparametere til å stille inn. Hvis batchstørrelsen er satt til 7, vil tensoren mate 5 488 verdier (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = 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å 5x5 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 i radene og kolonnene for å sikre samme størrelse.
Du bruker Relu-aktiveringsfunksjonen. Utgangsstørrelsen vil være [28, 28, 14].
Trinn 4: Bassenglag
Det neste trinnet etter konvolusjonen er pooling-beregningen. Sammenslåingsberegningen vil redusere dimensjonaliteten til dataene. Du kan bruke modulen max_pooling2d med en størrelse på 2x2 og skritt på 2. Du bruker forrige lag som inngang. Utgangsstørrelsen vil være [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Trinn 5: Andre Convolutional Layer og Pooling Layer
Det andre konvolusjonslaget har 32 filtre, med en utgangsstørrelse på [batch_size, 14, 14, 32]. Bassenglaget har samme størrelse som før, og utgangsformen 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å flates ut før det kan kobles til det tette laget. Du kan bruke omformingen av modulen med størrelsen 7 * 7 * 36.
Det tette laget vil koble 1764 nevroner. Du legger til en Relu-aktiveringsfunksjon. Dessuten legger du til en frafallsregulariseringsperiode med en hastighet på 0,3, noe som betyr at 30 prosent av vektene vil bli satt til 0. Merk at frafallet bare skjer i løpet av treningsfasen. Funksjonen cnn_model_fn har en argumentmodus for å erklære om modellen må trenes eller evalueres.
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 kan du definere det siste laget med prediksjon av modellen. Utgangsformen er lik batchstørrelsen og 10, det totale antall bilder.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Du kan lage en ordbok som inneholder klassene og sannsynligheten for hver klasse. Modulen tf.argmax () 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 ordboksforutsigelsen når modus er satt til forutsigelse. Du legger til disse kodene for å avvise spådommene
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Neste trinn 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 er å optimalisere modellen, det vil si å finne de beste verdiene for 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 evalueringsmodus. Ytelsesberegningene for en multiklassmodell er nøyaktighetsberegningene. Tensorflow er utstyrt med en modulnøyaktighet med to argumenter, etikettene og de forutsagte 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 din første CNN, og du er klar til å pakke alt inn i en funksjon for å kunne bruke den til å trene og evaluere modellen.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = 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 Layerpool2_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 Layerlogits = 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 Lossloss = 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 modeeval_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 foregående opplæringene.
Først og fremst definerer du en estimator med CNN-modellen.
# Create the Estimatormnist_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 loggkrok for å lagre verdiene til softmax-lagene hver 50 iterasjon.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Du er klar til å estimere 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 modeltrain_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 tog, kan du evaluere den og skrive ut resultatene
# Evaluate the model and print resultseval_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:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO: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 nåværende arkitekturen får du en nøyaktighet på 97%. Du kan endre arkitekturen, batchstørrelsen og antall iterasjon for å forbedre nøyaktigheten. CNNs nevrale nettverk har prestert langt bedre enn ANN eller logistisk regresjon. I veiledningen om kunstig nevralt nettverk hadde du en nøyaktighet på 96%, som er lavere CNN. Forestillinger av CNN er imponerende med et større bilde sett , både på sikt av hastighet beregning og nøyaktighet.
Sammendrag
Et konvolusjonalt nevralt nettverk fungerer veldig bra for å evaluere bildet. Denne typen arkitektur er dominerende for å gjenkjenne objekter fra et bilde eller en video.
For å bygge et CNN, må du følge seks trinn:
Trinn 1: Inndata lag:
Dette trinnet omformer dataene. Formen er lik kvadratroten til antall piksler. For eksempel, hvis et bilde har 156 piksler, er formen 26x26. Du må spesifisere om bildet har farge eller ikke. Hvis ja, hadde du 3 til formen - 3 for RGB-, ellers 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Trinn 2: Konvolusjonslag
Deretter må du lage konvolusjonslagene. Du bruker forskjellige filtre for å la nettverket lære viktige funksjoner. Du angir 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 3: Bassenglag
I det tredje trinnet legger du til et poolinglag. Dette laget reduserer størrelsen på inngangen. Det gjør det ved å ta maksimumsverdien til en undermatrise. Hvis for eksempel matrisen er [3,1,3,2], vil samlingen returnere maksimumet, som er 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Trinn 4: Legg til konvolusjonslag og bassenglag
I dette trinnet kan du legge til så mye du vil ha konv.lag og pooling lag. Google bruker arkitektur med mer enn 20 konv.lag.
Trinn 5: Tett lag
Trinn 5 flater forrige ut for å lage et fullt sammenkoblede 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 6: Logit Layer
Det siste trinnet er spådommen.
logits = tf.layers.dense(inputs=dropout, units=10)