Vad är Convolutional Neural Network?
Convolutional neuralt nätverk, även känt som convnets eller CNN, är en välkänd metod i datorsynstillämpningar. Denna typ av arkitektur är dominerande för att känna igen objekt från en bild eller video.
I den här handledningen lär du dig hur du konstruerar ett konvnet och hur du använder TensorFlow för att lösa det handskrivna datasetet.
I den här handledningen lär du dig
- Convolutional Neural Network
- Arkitektur för ett konvolutionellt neuralt nätverk
- Komponenter i Convnets
- Träna CNN med TensorFlow
- Steg 1: Ladda upp datauppsättning
- Steg 2: Inmatningsskikt
- Steg 3: Konvolutionsskikt
- Steg 4: Pooling lager
- Steg 5: Andra konvolutionella lagret och poollagret
- Steg 6: Tätt lager
- Steg 7: Logit Layer
Arkitektur för ett konvolutionellt neuralt nätverk
Tänk på Facebook för några år sedan, efter att du laddade upp en bild till din profil, blev du ombedd att lägga till ett namn i ansiktet på bilden manuellt. Numera använder Facebook convnet för att märka din vän på bilden automatiskt.
Det är inte särskilt svårt att förstå ett omvälvande neurala nätverk. En ingångsbild bearbetas under konvolutionsfasen och tilldelas senare en etikett.
En typisk convnet-arkitektur kan sammanfattas i bilden nedan. Först och främst skjuts en bild till nätverket; detta kallas ingångsbilden. Därefter går den inmatade bilden genom ett oändligt antal steg; det här är den sammanslagna delen av nätverket. Slutligen kan det neurala nätverket förutsäga siffran på bilden.
En bild består av en rad pixlar med höjd och bredd. En gråskalebild har bara en kanal medan färgbilden har tre kanaler (var och en för rött, grönt och blått). En kanal staplas över varandra. I den här handledningen använder du en gråskalebild med endast en kanal. Varje pixel har ett värde från 0 till 255 för att återspegla färgens intensitet. Till exempel visar en pixel som är lika med 0 en vit färg medan pixeln med ett värde nära 255 blir mörkare.
Låt oss ta en titt på en bild som är lagrad i MNIST-datasetet. Bilden nedan visar hur man representerar bilden till vänster i matrisformat. Observera att originalmatrisen har standardiserats till att vara mellan 0 och 1. För mörkare färg är värdet i matrisen cirka 0,9 medan vita pixlar har ett värde på 0.
Konvolutionsfunktion
Den mest kritiska komponenten i modellen är konvolutionsskiktet. Denna del syftar till att minska storleken på bilden för snabbare beräkningar av vikterna och förbättra dess generalisering.
Under konvolutionsdelen behåller nätverket de väsentliga funktionerna i bilden och utesluter irrelevant ljud. Till exempel lär modellen sig att känna igen en elefant från en bild med ett berg i bakgrunden. Om du använder ett traditionellt neuralt nätverk tilldelar modellen en vikt till alla pixlar, inklusive de från berget, vilket inte är nödvändigt och kan vilseleda nätverket.
I stället använder ett favsionsneuralt nätverk en matematisk teknik för att endast extrahera de mest relevanta pixlarna. Denna matematiska operation kallas faltning. Denna teknik gör det möjligt för nätverket att lära sig alltmer komplexa funktioner i varje lager. Konvolutionen delar upp matrisen i små bitar för att lära sig de viktigaste elementen i varje bit.
Komponenter i Convnets
Det finns fyra komponenter i en Convnets
- Veck
- Icke linjäritet (ReLU)
- Poolning eller delprovtagning
- Klassificering (helt anslutet lager)
- Veck
Syftet med konvolutionen är att extrahera objektets funktioner på bilden lokalt. Det betyder att nätverket lär sig specifika mönster inom bilden och kommer att kunna känna igen det överallt i bilden.
Konvolution är en elementvis multiplikation. Konceptet är lätt att förstå. Datorn skannar en del av bilden, vanligtvis med dimensionen 3x3 och multiplicerar den till ett filter. Utgången från den elementvisa multiplikationen kallas en funktionskarta. Detta steg upprepas tills hela bilden skannas. Observera att bildens storlek minskas efter konvolutionen.
Nedan finns det en URL för att se hur handling fungerar.
Det finns många tillgängliga kanaler. Nedan listade vi några av kanalerna. Du kan se att varje filter har ett specifikt syfte. Observera, på bilden nedan; Kärnan är en synonym för filtret.
Källa
Aritmetik bakom konvolutionen
Konvolutionsfasen tillämpar filtret på ett litet antal pixlar i bilden. Filtret rör sig längs inmatningsbilden med en allmän form på 3x3 eller 5x5. Det betyder att nätverket kommer att glida dessa fönster över hela inmatningsbilden och beräkna konvolutionen. Bilden nedan visar hur kollapsen fungerar. Storleken på lappen är 3x3 och utmatningsmatrisen är resultatet av den elementvisa operationen mellan bildmatrisen och filtret.
Källa
Du märker att bredden och höjden på utgången kan skilja sig från ingångens bredd och höjd. Det händer på grund av gränseffekten.
Gränseffekt
Bilden har en 5x5-funktionskarta och ett 3x3-filter. Det finns bara ett fönster i mitten där filtret kan skärma ett 3x3 rutnät. Utmatningsfunktionskartan krymper med två brickor tillsammans med en 3x3-dimension.
För att få samma utmatningsdimension som inmatningsdimensionen måste du lägga till stoppning. Padding består av att lägga till rätt antal rader och kolumner på varje sida av matrisen. Det gör det möjligt för konvolutionen att passa varje inmatningsbricka. I bilden nedan har inmatnings- / utmatningsmatrisen samma dimension 5x5
När du definierar nätverket styrs de inblandade funktionerna av tre parametrar:
- Djup: Den definierar antalet filter som ska tillämpas under fällningen. I föregående exempel såg du ett djup på 1, vilket innebär att endast ett filter används. I de flesta fall finns det mer än ett filter. Bilden nedan visar de åtgärder som utförts i en situation med tre filter
- Stride: Den definierar antalet "pixel's jump" mellan två skivor. Om steget är lika med 1 kommer fönstren att röra sig med en pixelspridning på en. Om steget är lika med två hoppar fönstren med 2 pixlar. Om du ökar steget kommer du att ha mindre funktionskartor.
Exempel steg 1
Bildsteg 2
- Nollpolstring: En stoppning är en operation för att lägga till motsvarande antal rader och kolumner på vardera sidan av inmatningsfunktionskartorna. I det här fallet har utgången samma dimension som ingången.
- Icke linjäritet (ReLU)
I slutet av konvolutionsoperationen är utsignalen föremål för en aktiveringsfunktion för att tillåta icke-linjäritet. Den vanliga aktiveringsfunktionen för convnet är Relu. Hela pixeln med ett negativt värde kommer att ersättas med noll.
- Max-poolning
Detta steg är lätt att förstå. Syftet med sammanslagningen är att minska dimensionen hos den inmatade bilden. Stegen är gjorda för att minska operationens beräkningskomplexitet. Genom att minska dimensionaliteten har nätverket lägre vikter att beräkna, så det förhindrar övermontering.
I det här steget måste du definiera storlek och steg. Ett vanligt sätt att samla inmatningsbilden är att använda det maximala värdet på funktionskartan. Titta på bilden nedan. "Pooling" visar en fyra undermatris av 4x4-funktionskartan och returnerar det maximala värdet. Poolningen tar det maximala värdet för en 2x2-array och flyttar sedan fönstren med två pixlar. Till exempel är den första undermatrisen [3,1,3,2], poolen returnerar det maximala, vilket är 3.
Det finns en annan poolning som medelvärdet.
Denna åtgärd minskar storleken på funktionskartan aggressivt
- Helt anslutna lager
Det sista steget består i att bygga ett traditionellt artificiellt neuralt nätverk som du gjorde i föregående handledning. Du ansluter alla nervceller från föregående lager till nästa lager. Du använder en softmax-aktiveringsfunktion för att klassificera numret på den inmatade bilden.
Sammanfattning:
Convolutional Neural Network kompilerar olika lager innan man gör en förutsägelse. Ett neuralt nätverk har:
- Ett fällningsskikt
- Relu-aktiveringsfunktion
- Poollager
- Tätt anslutet lager
Fångningsskikten tillämpar olika filter på en delregion i bilden. Relu-aktiveringsfunktionen lägger till icke-linjäritet, och poollagren minskar dimensionerna hos funktionskartorna.
Alla dessa lager extraherar viktig information från bilderna. Äntligen matas funktionskartan till ett primärt fullt anslutet lager med en softmax-funktion för att göra en förutsägelse.
Träna CNN med TensorFlow
Nu när du är bekant med byggstenarna i en convnets är du redo att bygga en med TensorFlow. Vi använder MNIST-datasetet för bildklassificering.
Dataförberedelsen är densamma som i föregående handledning. Du kan köra koder och hoppa direkt till CNN: s arkitektur.
Du kommer att följa stegen nedan:
Steg 1: Ladda upp datauppsättning
Steg 2: Inmatningsskikt
Steg 3: Konvolutionsskikt
Steg 4: Pooling lager
Steg 5: Andra konvolutionella lagret och poollagret
Steg 6: Tätt lager
Steg 7: Logit Layer
Steg 1: Ladda upp datauppsättning
MNIST-datasetet är tillgängligt med scikit för att lära sig på denna URL. Ladda ner den och lagra den i Nedladdningar. Du kan ladda upp den med fetch_mldata ('MNIST original').
Skapa ett tåg / testuppsättning
Du måste dela upp datasetet med train_test_split
Skala funktionerna
Slutligen kan du skala 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:]
Definiera CNN
En CNN använder filter på den råa pixeln i en bild för att lära sig detaljmönster jämfört med globalt mönster med ett traditionellt neuralnät. För att konstruera ett CNN måste du definiera:
- Ett konvolutionsskikt: Använd ett antal filter på funktionskartan. Efter sammanslagningen måste du använda en Relu-aktiveringsfunktion för att lägga till icke-linjäritet i nätverket.
- Poollager: Nästa steg efter konvolution är att nedprovera funktionen max. Syftet är att minska funktionskartans dimension för att förhindra överanpassning och förbättra beräkningshastigheten. Max pooling är den konventionella tekniken, som delar upp funktionskartorna i underregioner (vanligtvis med en 2x2-storlek) och behåller endast de maximala värdena.
- Fullt anslutna lager: Alla nervceller från tidigare lager är anslutna till nästa lager. CNN kommer att klassificera etiketten enligt funktionerna från fusklagren och reduceras med poollagret.
CNN-arkitektur
- Convolutional Layer: Tillämpar 14 5x5-filter (extraherar 5x5-pixel underregioner), med ReLU-aktiveringsfunktion
- Pooling Layer: Utför maxpooling med ett 2x2-filter och steg på 2 (vilket anger att poolade regioner inte överlappar varandra)
- Convolutional Layer: Tillämpar 36 5x5 filter med ReLU-aktiveringsfunktion
- Pooling Layer # 2: Återigen utför maxpooling med ett 2x2 filter och steg 2
- 1764 nervceller, med bortfallsregulariseringsfrekvens på 0,4 (sannolikhet 0,4 att ett visst element kommer att tappas under träning)
- Dens skikt (Logits Layer): 10 nervceller, en för varje siffra målklass (0-9).
Det finns tre viktiga moduler att använda för att skapa ett CNN:
- conv2d (). Konstruerar ett tvådimensionellt fällningsskikt med antalet filter, filterkärnstorlek, stoppning och aktiveringsfunktion som argument.
- max_pooling2d (). Konstruerar ett tvådimensionellt poollager med max-pooling-algoritmen.
- tät(). Konstruerar ett tätt lager med dolda lager och enheter
Du kommer att definiera en funktion för att bygga CNN. Låt oss se i detalj hur man konstruerar varje byggsten innan vi slår samman allt i funktionen.
Steg 2: Inmatningsskikt
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Du måste definiera en tensor med formen på data. För det kan du använda modulen tf.reshape. I den här modulen måste du deklarera att tensorn ska omformas och tensorns form. Det första argumentet är datafunktionerna, som definieras i funktionens argument.
En bild har en höjd, en bredd och en kanal. MNIST-datasetet är en monokronisk bild med en storlek på 28x28. Vi sätter batchstorleken till -1 i formargumentet så att det tar formen på funktionerna ["x"]. Fördelen är att göra batchparametern hyperparametrar att ställa in. Om satsstorleken är inställd på 7 matar tensorn 5 488 värden (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örsta fällningsskiktet har 14 filter med en kärnstorlek på 5x5 med samma stoppning. Samma stoppning betyder att både utgångstensorn och inmatningstensorn ska ha samma höjd och bredd. Tensorflöde lägger till nollor i raderna och kolumnerna för att säkerställa samma storlek.
Du använder Relu-aktiveringsfunktionen. Utmatningsstorleken blir [28, 28, 14].
Steg 4: Pooling lager
Nästa steg efter konvolutionen är poolberäkningen. Poolberäkningen kommer att minska dimensionens data. Du kan använda modulen max_pooling2d med en storlek på 2x2 och steg 2. Du använder föregående lager som inmatning. Utmatningsstorleken blir [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Steg 5: Andra konvolutionella lagret och poollagret
Det andra fällningsskiktet har 32 filter med en utmatningsstorlek på [batch_size, 14, 14, 32]. Poollagret har samma storlek som tidigare och utgångsformen är [batch_size, 14, 14, 18].
conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
Steg 6: Tätt lager
Sedan måste du definiera det fullständigt anslutna lagret. Funktionskartan måste planas ut innan den kan anslutas till det täta skiktet. Du kan använda omformningen av modulen med en storlek på 7 * 7 * 36.
Det täta skiktet ansluter 1764 neuroner. Du lägger till en Relu-aktiveringsfunktion. Dessutom lägger du till en bortfallsregleringsperiod med en hastighet på 0,3, vilket innebär att 30 procent av vikterna kommer att ställas till 0. Observera att bortfallet endast sker under träningsfasen. Funktionen cnn_model_fn har ett argumentläge för att deklarera om modellen behöver tränas eller utvärderas.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Steg 7: Logit Layer
Slutligen kan du definiera det sista lagret med förutsägelsen av modellen. Utmatningsformen är lika med batchstorleken och 10, det totala antalet bilder.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Du kan skapa en ordbok som innehåller klasserna och sannolikheten för varje klass. Modulen tf.argmax () med returnerar det högsta värdet om logit-lagren. Softmax-funktionen returnerar sannolikheten för varje klass.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Du vill bara returnera ordboksförutsägelsen när läget är inställt på förutsägelse. Du lägger till dessa koder för att skicka förutsägelserna
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Nästa steg består i att beräkna förlusten av modellen. I den senaste handledningen lärde du dig att förlustfunktionen för en multiklassmodell är korsentropi. Förlusten beräknas enkelt med följande kod:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
Det sista steget är att optimera modellen, det vill säga att hitta de bästa värdena för vikterna. För det använder du en Gradient Descent Optimizer med en inlärningshastighet på 0,001. Målet är att minimera förlusten
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Du är klar med CNN. Du vill dock visa prestandamätvärdena under utvärderingsläget. Prestandamätvärdena för en multiklassmodell är noggrannhetsmåtten. Tensorflow är utrustat med en modulnoggrannhet med två argument, etiketterna och de förutsagda värdena.
eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Det är allt. Du skapade din första CNN och du är redo att sätta in allt i en funktion för att kunna använda den för att träna och utvärdera 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)
Stegen nedan är desamma som tidigare handledning.
Först och främst definierar 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 många gånger att träna, därför skapar du en loggkrok för att lagra värdena för softmax-lagren var 50: e 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 är redo att uppskatta modellen. Du ställer in en batchstorlek på 100 och blandar data. Observera att vi ställer in träningssteg på 16.000, det kan ta mycket tid att träna. Ha tålamod.
# 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 när modellen är tåg kan du utvärdera den och skriva ut resultaten
# 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 nuvarande arkitekturen får du en noggrannhet på 97%. Du kan ändra arkitekturen, batchstorleken och antalet iteration för att förbättra noggrannheten. CNN: s neurala nätverk har presterat mycket bättre än ANN eller logistisk regression. I handledningen om artificiellt neurala nätverk hade du en noggrannhet på 96%, vilket är lägre än CNN. Föreställningarna av CNN är imponerande med en större bild set , både i termer av hastighetsberäkning och noggrannhet.
Sammanfattning
Ett fackligt neuralt nätverk fungerar mycket bra för att utvärdera bilden. Denna typ av arkitektur är dominerande för att känna igen objekt från en bild eller video.
För att bygga ett CNN måste du följa sex steg:
Steg 1: Inmatningsskikt:
Detta steg omformar data. Formen är lika med kvadratroten av antalet pixlar. Till exempel, om en bild har 156 pixlar, är formen 26x26. Du måste ange om bilden har färg eller inte. Om ja, hade du 3 till formen - 3 för RGB-, annars 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Steg 2: Konvolutionsskikt
Därefter måste du skapa konvolutionslagren. Du använder olika filter så att nätverket kan lära sig viktig funktion. Du anger kärnans storlek och mängden filter.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Steg 3: Pooling lager
I det tredje steget lägger du till ett poollager. Detta lager minskar storleken på ingången. Det gör det genom att ta det maximala värdet för en undermatris. Till exempel, om delmatrisen är [3,1,3,2], kommer poolningen att returnera det maximala, vilket är 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Steg 4: Lägg till Convolutional Layer och Pooling Layer
I det här steget kan du lägga till så mycket du vill ha konv-lager och pooling-lager. Google använder arkitektur med mer än 20 konv.skikt.
Steg 5: Tätt lager
Steg 5 plattar föregående för att skapa ett helt anslutna lager. I det här steget kan du använda en annan aktiveringsfunktion och lägga till en bortfallseffekt.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Steg 6: Logit Layer
Det sista steget är förutsägelsen.
logits = tf.layers.dense(inputs=dropout, units=10)