Hvad er Convolutional Neural Network?
Convolutionsneurale netværk, også kendt som convnets eller CNN, er en velkendt metode i computersynsapplikationer. Denne type arkitektur er dominerende for at genkende objekter fra et billede eller en video.
I denne vejledning lærer du, hvordan du konstruerer et convnet, og hvordan du bruger TensorFlow til at løse det håndskrevne datasæt.
I denne vejledning lærer du
- Convolutional Neural Network
- Arkitektur af et revolutionært neuralt netværk
- Komponenter af Convnets
- Tog CNN med TensorFlow
- Trin 1: Upload datasæt
- Trin 2: Inputlag
- Trin 3: Konvolutionslag
- Trin 4: Pooling-lag
- Trin 5: Andet konvolutionslag og poollag
- Trin 6: Tæt lag
- Trin 7: Logit Layer
Arkitektur af et revolutionært neuralt netværk
Tænk på Facebook for et par år siden, efter at du havde uploadet 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 sammenfaldende neuralt netværk er ikke særlig svært at forstå. Et inputbillede behandles i sammenløbsfasen og tilskrives senere en etiket.
En typisk convnet-arkitektur kan opsummeres i billedet nedenfor. Først og fremmest skubbes et billede til netværket; dette kaldes inputbillede. Derefter går inputbilledet gennem et uendeligt antal trin; dette er den konvolutionsdel af netværket. Endelig kan det neurale netværk forudsige cifret på billedet.
Et billede er sammensat af en række pixels med højde og bredde. Et gråtonebillede har kun en kanal, mens farvebilledet har tre kanaler (hver for rød, grøn og blå). En kanal er stablet over hinanden. I denne vejledning bruger du et gråtonebillede med kun en kanal. Hver pixel har en værdi fra 0 til 255 for at afspejle intensiteten af farven. 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ættet. Billedet nedenfor viser, hvordan man repræsenterer billedet til venstre i et matrixformat. Bemærk, at den oprindelige matrix er standardiseret til at være mellem 0 og 1. For mørkere farver er værdien i matricen ca. 0,9, mens hvide pixels har en værdi på 0.
Konvolutionsoperation
Den mest kritiske komponent i modellen er det foldede lag. Denne del sigter mod at reducere billedets størrelse til hurtigere beregning af vægten og forbedre dets generalisering.
Under den konvolutionsdel holder netværket de væsentlige funktioner i billedet og udelukker irrelevant støj. For eksempel lærer modellen, hvordan man genkender en elefant fra et billede med et bjerg i baggrunden. Hvis du bruger et traditionelt neuralt netværk, tildeler modellen en vægt til alle pixels, inklusive dem fra bjerget, hvilket ikke er vigtigt og kan vildlede netværket.
I stedet anvender et nedviklet neuralt netværk 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. Kollusionen opdeler matricen i små stykker for at lære de mest væsentlige elementer inden for hvert stykke.
Komponenter af Convnets
Der er fire komponenter i en Convnets
- Konvolution
- Ikke-lineæritet (ReLU)
- Samling eller delprøveudtagning
- Klassifikation (fuldt forbundet lag)
- Konvolution
Formålet med sammenløbet er at udtrække objektets funktioner på billedet lokalt. Det betyder, at netværket lærer specifikke mønstre i billedet og vil kunne genkende det overalt i billedet.
Konvolution er en elementvis multiplikation. Konceptet er let at forstå. Computeren scanner en del af billedet, normalt med en dimension på 3x3 og multiplicerer det med et filter. Outputtet af den elementvise multiplikation kaldes et funktionskort. Dette trin gentages, indtil hele billedet er scannet. Bemærk, at billedets størrelse efter konvolution reduceres.
Nedenfor er der en URL til at se i aktion, hvordan foldning fungerer.
Der er adskillige kanaler tilgængelige. Nedenfor listede vi nogle af kanalerne. Du kan se, at hvert filter har et specifikt formål. Bemærk, på billedet nedenfor; Kernen er et synonym for filteret.
Kilde
Aritmetik bag sammenfaldet
Konvolutionsfasen anvender filteret på et lille antal pixels i billedet. Filteret bevæger sig langs inputbilledet med en generel form på 3x3 eller 5x5. Det betyder, at netværket vil skubbe disse vinduer over hele inputbilledet og beregne sammenfaldet. Billedet nedenfor viser, hvordan sammenløbet fungerer. Størrelsen på patch er 3x3, og outputmatrixen er resultatet af den elementvise operation mellem billedmatrixen og filteret.
Kilde
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ænseffekten.
Grænseeffekt
Billedet har et 5x5-funktionskort og et 3x3-filter. Der er kun et vindue i midten, hvor filteret kan skærm et 3x3 gitter. Outputfunktionskortet krymper med to fliser sammen med en 3x3-dimension.
For at få den samme outputdimension som inputdimensionen skal du tilføje polstring. Polstring består i at tilføje det rigtige antal rækker og kolonner på hver side af matrixen. Det gør det muligt for konvolutionen at centrere for alle inputfliser. På billedet nedenfor har input / output-matrix den samme dimension 5x5
Når du definerer netværket, styres de indviklede funktioner af tre parametre:
- Dybde: Det definerer antallet af filtre, der skal anvendes under sammenløbet. I det foregående eksempel så du en dybde på 1, hvilket betyder, at der kun bruges et filter. I de fleste tilfælde er der mere end et filter. Billedet nedenfor viser de operationer, der er udført i en situation med tre filtre
- Stride: Det definerer antallet af "pixel's jump" mellem to skiver. Hvis skridtet er lig med 1, bevæger vinduerne sig med en pixels spredning på en. Hvis skridtet er lig med to, springer vinduerne med 2 pixels. Hvis du øger skridtet, har du mindre funktionskort.
Eksempel skridt 1
Billedtrin 2
- Nul-polstring: En polstring er en operation til at tilføje et tilsvarende antal rækker og søjler på hver side af inputfunktionskortene. I dette tilfælde har output samme dimension som input.
- Ikke-lineæritet (ReLU)
I slutningen af konvolutionsoperationen er output udsat for en aktiveringsfunktion for at tillade ikke-linearitet. Den sædvanlige aktiveringsfunktion for convnet er Relu. Al pixel med en negativ værdi erstattes af nul.
- Max-pooling-drift
Dette trin er let at forstå. Formålet med poolingen er at reducere dimensionaliteten af inputbilledet. Trinene udføres for at reducere den beregningsmæssige kompleksitet af operationen. Ved at mindske dimensionaliteten har netværket lavere vægte at beregne, så det forhindrer overmontering.
I dette trin skal du definere størrelse og skridt. En standard måde at samle inputbilledet på er at bruge den maksimale værdi af funktionskortet. Se på billedet nedenfor. "Pooling" viser en fire submatrix af 4x4-funktionskortet og returnerer den maksimale værdi. Samlingen tager den maksimale værdi af et 2x2 array og flytter derefter dette vindue med to pixels. For eksempel er den første undermatrix [3,1,3,2], poolingen returnerer det maksimale, som er 3.
Der er en anden pooling-operation som middelværdien.
Denne handling reducerer aggressivt størrelsen på funktionskortet
- Fuldt forbundne lag
Det sidste trin består i at opbygge et traditionelt kunstigt neuralt netværk, som du gjorde i den foregående vejledning. 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é:
Convolutional Neural network kompilerer forskellige lag, inden der forudsiges. Et neuralt netværk har:
- Et sammenblandingslag
- Relu-aktiveringsfunktion
- Pooling lag
- Tæt forbundet lag
Konvolutionslagene anvender forskellige filtre på en underregion af billedet. Relu-aktiveringsfunktionen tilføjer ikke-linearitet, og poolingslagene reducerer dimensionaliteten af funktionskortene.
Alle disse lag trækker vigtig information ud af billederne. Endelig føres funktionskortet til et primært fuldt tilsluttet lag med en softmax-funktion for at forudsige.
Tog CNN med TensorFlow
Nu hvor du er fortrolig med byggestenen til en konvnet, er du klar til at bygge en med TensorFlow. Vi bruger MNIST-datasættet til billedklassificering.
Dataforberedelsen er den samme som den foregående tutorial. Du kan køre koderne og springe direkte til CNNs arkitektur.
Du følger nedenstående trin:
Trin 1: Upload datasæt
Trin 2: Inputlag
Trin 3: Konvolutionslag
Trin 4: Pooling-lag
Trin 5: Andet konvolutionslag og poollag
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 på denne URL. Download det og gem det i Downloads. Du kan uploade det med fetch_mldata ('MNIST original').
Opret et tog / testsæt
Du skal opdele datasættet med train_test_split
Skaler funktionerne
Endelig kan du skalere funktionen 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 bruger filtre på den rå pixel i et billede for at lære detaljer mønster sammenlignet med globalt mønster med et traditionelt neuralt net. For at konstruere et CNN skal du definere:
- Et sammenblandingslag: Anvend n antal filtre på funktionskortet. Efter sammenløbet skal du bruge en Relu-aktiveringsfunktion til at tilføje ikke-linearitet til netværket.
- Pooling-lag: Det næste trin efter sammenløbet er at nedprøve funktionen max. Formålet er at reducere funktionskortets dimensionalitet for at forhindre overmontering og forbedre beregningshastigheden. Max pooling er den konventionelle teknik, der deler funktionskortene i underregioner (normalt med en 2x2 størrelse) og kun holder de maksimale værdier.
- Fuldt forbundne lag: Alle neuroner fra de tidligere lag er forbundet til de næste lag. CNN klassificerer mærkaten i henhold til funktionerne fra de sammenfaldende lag og reduceres med poolingslaget.
CNN-arkitektur
- Convolutional Layer: Anvender 14 5x5 filtre (ekstraherer 5x5-pixel underregioner) med ReLU-aktiveringsfunktion
- Pooling Layer: Udfører maks. Pooling med et 2x2 filter og stride på 2 (som specificerer at poolede regioner ikke overlapper hinanden)
- Convolutional Layer: Anvender 36 5x5 filtre med ReLU aktiveringsfunktion
- Pooling Layer # 2: Igen udfører max pooling med et 2x2 filter og stride på 2
- 1.764 neuroner, med dropout-reguleringshastighed på 0,4 (sandsynlighed for 0,4 at et givet element vil blive droppet under træning)
- Tæt lag (Logits Layer): 10 neuroner, en for hver cifret målklasse (0-9).
Der er tre vigtige moduler, der skal bruges til at oprette et CNN:
- conv2d (). Konstruerer et todimensionalt konvolutionslag med antallet af filtre, filterkernestørrelse, polstring 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 definerer en funktion til at opbygge CNN. Lad os se i detaljer, hvordan man konstruerer hver byggesten, 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 på dataene. Til det kan du bruge modulet tf.reshape. I dette modul skal du erklære, at tensoren skal omformes, og tensorens form. Det første argument er funktionerne i dataene, som er defineret i funktionens argument.
Et billede har en højde, en bredde og en kanal. MNIST-datasættet er et monokronisk billede med en størrelse på 28x28. Vi indstiller batchstørrelsen til -1 i formargumentet, så det tager form af funktionerne ["x"]. Fordelen er at gøre batchstørrelsen hyperparametre til at indstille. Hvis batchstørrelsen er indstillet til 7, vil tensoren føde 5.488 værdier (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 sammenblandingslag har 14 filtre med en kernestørrelse på 5x5 med samme polstring. Den samme polstring betyder, at både output-tensor og input-tensor skal have samme højde og bredde. Tensorflow tilføjer nuller til rækkerne og kolonnerne for at sikre den samme størrelse.
Du bruger Relu-aktiveringsfunktionen. Outputstørrelsen vil være [28, 28, 14].
Trin 4: Pooling-lag
Det næste trin efter sammenfaldet er pooling-beregningen. Den samlede beregning reducerer datadimensionaliteten. Du kan bruge modulet max_pooling2d med en størrelse på 2x2 og stride på 2. Du bruger det forrige lag som input. Outputstørrelsen vil være [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Trin 5: Andet konvolutionslag og poollag
Det andet foldelag har 32 filtre med en outputstørrelse på [batch_size, 14, 14, 32]. Puljelaget 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 tilsluttede lag. Funktionskortet skal være fladt før det kan forbindes med det tætte lag. Du kan bruge modulets omformning med en størrelse på 7 * 7 * 36.
Det tætte lag forbinder 1764 neuroner. Du tilføjer en Relu-aktiveringsfunktion. Desuden tilføjer du et frafaldsregulariseringsudtryk med en hastighed på 0,3, hvilket betyder, at 30 procent af vægten vil blive indstillet 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 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)
Trin 7: Logit Layer
Endelig kan du definere det sidste lag med forudsigelsen af modellen. Outputformen er lig med batchstørrelsen og 10, det samlede antal billeder.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Du kan oprette en ordbog, der indeholder klasserne og sandsynligheden for hver klasse. Modulet tf.argmax () med returnerer den højeste værdi, hvis logit-lagene. Softmax-funktionen returnerer sandsynligheden for hver klasse.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Du vil kun returnere ordbogen forudsigelse, når tilstanden er indstillet til forudsigelse. Du tilføjer disse koder for at udsende 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 vejledning lærte du, at tabsfunktionen for en multiklassemodel er krydsentropi. Tabet beregnes let 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 er at optimere modellen, det vil sige at finde de bedste værdier af vægten. Til det bruger du en Gradient Descent Optimizer med en læringsrate 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 performance-metrics under evalueringstilstand. Ydelsesmå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 din første CNN, og du er klar til at pakke alt ind i en funktion for at bruge det til at træne 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)
Trinene nedenfor er de samme som de tidligere tutorials.
Først og fremmest 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 tager mange gange at træne, derfor opretter du en logningskrog, der lagrer værdierne for softmax-lag hver 50 iteration.
# 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 at estimere modellen. Du indstiller en batchstørrelse på 100 og blander dataene. Bemærk, at vi indstiller træningstrin på 16.000, det kan tage meget tid at træne. 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])
Nu hvor modellen er tog, kan du evaluere den og udskrive resultaterne
# 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 nuværende arkitektur får du en nøjagtighed på 97%. Du kan ændre arkitekturen, batchstørrelsen og antallet af iteration for at forbedre nøjagtigheden. CNN's neurale netværk har klaret sig meget bedre end ANN eller logistisk regression. I vejledningen om kunstigt neuralt netværk havde du en nøjagtighed på 96%, hvilket er lavere CNN. De opførelser af CNN er imponerende med et større billede sæt , både på sigt af hastighed beregning og nøjagtighed.
Resumé
Et sammenblandet neuralt netværk fungerer meget godt til at evaluere billedet. Denne type arkitektur er dominerende for at genkende objekter fra et billede eller en video.
For at opbygge et CNN skal du følge seks trin:
Trin 1: Inputlag:
Dette trin omformer dataene. Formen er lig med kvadratroden af antallet af pixels. For eksempel, hvis et billede har 156 pixels, er formen 26x26. 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 2: Konvolutionslag
Dernæst skal du oprette de sammenblandingslag. Du anvender forskellige filtre for at give netværket mulighed for at lære vigtig funktion. Du angiver kernens størrelse og antallet af filtre.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Trin 3: Pooling lag
I det tredje trin tilføjer du et poolinglag. Dette lag formindsker inputstørrelsen. Det gør det ved at tage den maksimale værdi af en undermatrix. For eksempel, hvis submatricen er [3,1,3,2], vil poolingen returnere det maksimale, som er 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Trin 4: Tilføj konvolutionslag og poollag
I dette trin kan du tilføje så meget som du vil have konv. Lag og pooling lag. Google bruger arkitektur med mere end 20 konv.lag.
Trin 5: Tæt lag
Trin 5 flader det forrige ud for at skabe et fuldt forbundne lag. I dette trin kan du bruge en anden aktiveringsfunktion 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 6: Logit Layer
Det sidste trin er forudsigelsen.
logits = tf.layers.dense(inputs=dropout, units=10)
