Classificazione delle immagini TensorFlow: CNN (Convolutional Neural Network)

Cos'è la rete neurale convoluzionale?

La rete neurale convoluzionale, nota anche come convnet o CNN, è un metodo ben noto nelle applicazioni di visione artificiale. Questo tipo di architettura è dominante per riconoscere gli oggetti da un'immagine o da un video.

In questo tutorial imparerai come costruire un convnet e come utilizzare TensorFlow per risolvere il set di dati scritto a mano.

In questo tutorial imparerai

• Rete neurale convoluzionale
• Architettura di una rete neurale convoluzionale
• Componenti di convnet
• Allena la CNN con TensorFlow
• Passaggio 1: carica il set di dati
• Passaggio 2: livello di input
• Passaggio 3: strato convoluzionale
• Passaggio 4: livello di raggruppamento
• Passaggio 5: secondo strato convoluzionale e strato di pooling
• Passaggio 6: strato denso
• Passaggio 7: Logit Layer

Architettura di una rete neurale convoluzionale

Pensa a Facebook qualche anno fa, dopo aver caricato un'immagine sul tuo profilo, ti è stato chiesto di aggiungere manualmente un nome al volto sulla foto. Al giorno d'oggi, Facebook utilizza convnet per taggare automaticamente il tuo amico nella foto.

Una rete neurale convoluzionale non è molto difficile da capire. Un'immagine di input viene elaborata durante la fase di convoluzione e successivamente viene attribuita un'etichetta.

Una tipica architettura convnet può essere riassunta nell'immagine sottostante. Prima di tutto, un'immagine viene inviata alla rete; questa è chiamata immagine di input. Quindi, l'immagine in ingresso passa attraverso un numero infinito di passaggi; questa è la parte convoluzionale della rete. Infine, la rete neurale può prevedere la cifra sull'immagine.

Un'immagine è composta da un array di pixel con altezza e larghezza. Un'immagine in scala di grigi ha un solo canale mentre l'immagine a colori ha tre canali (ciascuno per rosso, verde e blu). Un canale è impilato l'uno sull'altro. In questo tutorial, utilizzerai un'immagine in scala di grigi con un solo canale. Ogni pixel ha un valore compreso tra 0 e 255 per riflettere l'intensità del colore. Ad esempio, un pixel uguale a 0 mostrerà un colore bianco mentre un pixel con un valore vicino a 255 sarà più scuro.

Diamo un'occhiata a un'immagine memorizzata nel set di dati MNIST. L'immagine sotto mostra come rappresentare l'immagine della sinistra in un formato matrice. Si noti che la matrice originale è stata standardizzata per essere compresa tra 0 e 1. Per i colori più scuri, il valore nella matrice è di circa 0,9 mentre i pixel bianchi hanno un valore di 0.

Operazione convoluzionale

La componente più critica nel modello è lo strato convoluzionale. Questa parte mira a ridurre le dimensioni dell'immagine per calcoli più veloci dei pesi e migliorarne la generalizzazione.

Durante la parte convoluzionale, la rete mantiene le caratteristiche essenziali dell'immagine ed esclude i rumori irrilevanti. Ad esempio, il modello sta imparando a riconoscere un elefante da un'immagine con una montagna sullo sfondo. Se si utilizza una rete neurale tradizionale, il modello assegnerà un peso a tutti i pixel, compresi quelli di montagna che non è essenziale e può fuorviare la rete.

Invece, una rete neurale convoluzionale utilizzerà una tecnica matematica per estrarre solo i pixel più rilevanti. Questa operazione matematica è chiamata convoluzione. Questa tecnica consente alla rete di apprendere funzionalità sempre più complesse a ogni livello. La convoluzione divide la matrice in piccoli pezzi per apprendere gli elementi più essenziali all'interno di ogni pezzo.

Componenti di convnet

Ci sono quattro componenti di un Convnets

1. Convoluzione
2. Non linearità (ReLU)
3. Pooling o sottocampionamento
4. Classificazione (livello completamente connesso)

• Convoluzione

Lo scopo della convoluzione è estrarre localmente le caratteristiche dell'oggetto sull'immagine. Significa che la rete apprenderà modelli specifici all'interno dell'immagine e sarà in grado di riconoscerli ovunque nell'immagine.

La convoluzione è una moltiplicazione basata sugli elementi. Il concetto è di facile comprensione. Il computer scansionerà una parte dell'immagine, solitamente con una dimensione di 3x3, e la moltiplicherà per ottenere un filtro. L'output della moltiplicazione per elemento è chiamato mappa delle caratteristiche. Questo passaggio viene ripetuto fino a quando non viene acquisita l'intera immagine. Notare che, dopo la convoluzione, la dimensione dell'immagine viene ridotta.

Di seguito, c'è un URL per vedere in azione come funziona la convoluzione.

Sono disponibili numerosi canali. Di seguito, abbiamo elencato alcuni dei canali. Puoi vedere che ogni filtro ha uno scopo specifico. Nota, nella foto sotto; il kernel è sinonimo di filtro.

fonte

Aritmetica dietro la convoluzione

La fase convoluzionale applicherà il filtro su un piccolo array di pixel all'interno dell'immagine. Il filtro si sposterà lungo l'immagine in ingresso con una forma generale di 3x3 o 5x5. Significa che la rete farà scorrere queste finestre su tutta l'immagine di input e calcolerà la convoluzione. L'immagine sotto mostra come funziona la convoluzione. La dimensione della patch è 3x3 e la matrice di output è il risultato dell'operazione in termini di elemento tra la matrice dell'immagine e il filtro.

fonte

Notate che la larghezza e l'altezza dell'output possono essere diverse dalla larghezza e dall'altezza dell'input. Succede a causa dell'effetto bordo.

Effetto bordo

L'immagine ha una mappa delle caratteristiche 5x5 e un filtro 3x3. C'è solo una finestra al centro in cui il filtro può schermare una griglia 3x3. La mappa delle caratteristiche di output si ridurrà di due tessere insieme a una dimensione 3x3.

Per ottenere la stessa dimensione di output della dimensione di input, è necessario aggiungere il riempimento. Il riempimento consiste nell'aggiungere il giusto numero di righe e colonne su ciascun lato della matrice. Permetterà alla convoluzione di centrare ogni tessera di input. Nell'immagine sottostante, la matrice input / output ha la stessa dimensione 5x5

Quando si definisce la rete, le caratteristiche convolte sono controllate da tre parametri:

1. Profondità: definisce il numero di filtri da applicare durante la convoluzione. Nell'esempio precedente, hai visto una profondità di 1, il che significa che viene utilizzato un solo filtro. Nella maggior parte dei casi, è presente più di un filtro. L'immagine sotto mostra le operazioni eseguite in una situazione con tre filtri

2. Stride: definisce il numero di "pixel di salto" tra due sezioni. Se il passo è uguale a 1, le finestre si sposteranno con uno spread di un pixel. Se il passo è uguale a due, le finestre salteranno di 2 pixel. Se aumenti il ​​passo, avrai mappe delle caratteristiche più piccole.

Passo di esempio 1

Passo dell'immagine 2

3. Zero-padding: un riempimento è un'operazione di aggiunta di un numero corrispondente di righe e colonne su ciascun lato delle mappe delle caratteristiche di input. In questo caso, l'output ha la stessa dimensione dell'input.
4. Non linearità (ReLU)

Al termine dell'operazione di convoluzione, l'uscita è soggetta ad una funzione di attivazione per consentire la non linearità. La normale funzione di attivazione di convnet è Relu. Tutti i pixel con valore negativo verranno sostituiti da zero.

• Operazione di pooling massimo

Questo passaggio è facile da capire. Lo scopo del pooling è ridurre la dimensionalità dell'immagine di input. I passaggi vengono eseguiti per ridurre la complessità computazionale dell'operazione. Diminuendo la dimensionalità, la rete ha pesi inferiori da calcolare, quindi previene l'overfitting.

In questa fase è necessario definire la taglia e il passo. Un modo standard per raggruppare l'immagine di input consiste nell'utilizzare il valore massimo della mappa delle caratteristiche. Guarda la foto sotto. Il "raggruppamento" schermerà una quattro sottomatrici della mappa delle caratteristiche 4x4 e restituirà il valore massimo. Il raggruppamento prende il valore massimo di un array 2x2 e quindi sposta questa finestra di due pixel. Ad esempio, la prima sotto-matrice è [3,1,3,2], il raggruppamento restituirà il massimo, che è 3.

C'è un'altra operazione di pooling come la media.

Questa operazione riduce in modo aggressivo le dimensioni della mappa delle caratteristiche

• Strati completamente connessi

L'ultimo passaggio consiste nel costruire una rete neurale artificiale tradizionale come hai fatto nel tutorial precedente. Colleghi tutti i neuroni dal livello precedente al livello successivo. Si utilizza una funzione di attivazione softmax per classificare il numero sull'immagine in ingresso.

Ricapitolare:

La rete neurale convoluzionale compila diversi livelli prima di fare una previsione. Una rete neurale ha:

• Uno strato convoluzionale
• Funzione di attivazione di Relu
• Strato di raggruppamento
• Strato densamente connesso

Gli strati convoluzionali applicano filtri diversi su una sottoregione dell'immagine. La funzione di attivazione di Relu aggiunge non linearità e gli strati di pooling riducono la dimensionalità delle mappe delle caratteristiche.

Tutti questi livelli estraggono le informazioni essenziali dalle immagini. Infine, la mappa delle caratteristiche viene inviata a un livello principale completamente connesso con una funzione softmax per fare una previsione.

Allena la CNN con TensorFlow

Ora che hai familiarità con gli elementi costitutivi di un convnet, sei pronto per crearne uno con TensorFlow. Useremo il set di dati MNIST per la classificazione delle immagini.

La preparazione dei dati è la stessa del tutorial precedente. Puoi eseguire i codici e passare direttamente all'architettura della CNN.

Seguirai i passaggi seguenti:

Passaggio 1: carica il set di dati

Passaggio 2: livello di input

Passaggio 3: strato convoluzionale

Passaggio 4: livello di raggruppamento

Passaggio 5: secondo strato convoluzionale e strato di pooling

Passaggio 6: strato denso

Passaggio 7: Logit Layer

Passaggio 1: carica il set di dati

Il set di dati MNIST è disponibile con scikit da apprendere a questo URL. Scaricalo e memorizzalo in Download. Puoi caricarlo con fetch_mldata ('MNIST original').

Crea un set di treni / test

Devi dividere il set di dati con train_test_split

Scala le caratteristiche

Infine, puoi ridimensionare la funzione con 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:]

Definisci la CNN

Una CNN utilizza filtri sul pixel grezzo di un'immagine per apprendere il modello di dettagli rispetto al modello globale con una rete neurale tradizionale. Per costruire una CNN, devi definire:

1. Un layer convoluzionale: applica un numero n di filtri alla mappa delle caratteristiche. Dopo la convoluzione, è necessario utilizzare una funzione di attivazione Relu per aggiungere non linearità alla rete.
2. Livello di pooling: il passaggio successivo alla convoluzione consiste nel downsampling della feature max. Lo scopo è ridurre la dimensionalità della mappa delle caratteristiche per prevenire l'overfitting e migliorare la velocità di calcolo. Il pooling massimo è la tecnica convenzionale, che divide le mappe delle caratteristiche in sottoregioni (di solito con una dimensione 2x2) e mantiene solo i valori massimi.
3. Livelli completamente connessi: tutti i neuroni dei livelli precedenti sono collegati ai livelli successivi. La CNN classificherà l'etichetta in base alle caratteristiche degli strati convoluzionali e ridotta con lo strato di pooling.

Architettura CNN

• Livello convoluzionale: applica 14 filtri 5x5 (estraendo sottoregioni 5x5 pixel), con funzione di attivazione ReLU
• Livello pool: esegue il pool massimo con un filtro 2x2 e un passo di 2 (che specifica che le regioni raggruppate non si sovrappongono)
• Strato convoluzionale: applica 36 filtri 5x5, con funzione di attivazione ReLU
• Pooling Layer # 2: Anche in questo caso, esegue il pooling massimo con un filtro 2x2 e un passo di 2
• 1.764 neuroni, con tasso di regolarizzazione di abbandono di 0,4 (probabilità di 0,4 che un dato elemento venga eliminato durante l'allenamento)
• Dense Layer (Logits Layer): 10 neuroni, uno per ogni classe di destinazione delle cifre (0-9).

Esistono tre moduli importanti da utilizzare per creare una CNN:

• conv2d (). Costruisce uno strato convoluzionale bidimensionale con il numero di filtri, la dimensione del kernel del filtro, il riempimento e la funzione di attivazione come argomenti.
• max_pool2d (). Costruisce uno strato di pooling bidimensionale utilizzando l'algoritmo di pooling massimo.
• denso(). Costruisce uno strato denso con gli strati e le unità nascosti

Definirai una funzione per costruire la CNN. Vediamo in dettaglio come costruire ogni building block prima di racchiudere tutto insieme nella funzione.

Passaggio 2: livello di input

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

È necessario definire un tensore con la forma dei dati. Per questo, puoi usare il modulo tf.reshape. In questo modulo, è necessario dichiarare il tensore da rimodellare e la forma del tensore. Il primo argomento sono le caratteristiche dei dati, che sono definite nell'argomento della funzione.

Un'immagine ha un'altezza, una larghezza e un canale. Il set di dati MNIST è un'immagine monocromatica con una dimensione di 28x28. Impostiamo la dimensione del batch su -1 nell'argomento shape in modo che assuma la forma delle caratteristiche ["x"]. Il vantaggio consiste nell'ottimizzazione degli iperparametri della dimensione del batch. Se la dimensione del batch è impostata su 7, il tensore fornirà 5.488 valori (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)

Il primo strato convoluzionale ha 14 filtri con una dimensione del kernel di 5x5 con lo stesso riempimento. Lo stesso riempimento significa che sia il tensore di output che il tensore di input dovrebbero avere la stessa altezza e larghezza. Tensorflow aggiungerà zeri alle righe e alle colonne per garantire la stessa dimensione.

Si utilizza la funzione di attivazione di Relu. La dimensione dell'output sarà [28, 28, 14].

Passaggio 4: livello di raggruppamento

Il passo successivo dopo la convoluzione è il calcolo del pool. Il calcolo del pooling ridurrà la dimensionalità dei dati. È possibile utilizzare il modulo max_pool2d con una dimensione di 2x2 e passo di 2. Si utilizza il livello precedente come input. La dimensione dell'output sarà [batch_size, 14, 14, 14]

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

Passaggio 5: secondo strato convoluzionale e strato di pooling

Il secondo strato convoluzionale ha 32 filtri, con una dimensione di output di [batch_size, 14, 14, 32]. Lo strato di pooling ha le stesse dimensioni di prima e la forma di output è [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)

Passaggio 6: strato denso

Quindi, è necessario definire il livello completamente connesso. La mappa delle caratteristiche deve essere appiattita prima di essere collegata allo strato denso. È possibile utilizzare il modulo rimodellare con una dimensione di 7 * 7 * 36.

Lo strato denso collegherà 1764 neuroni. Aggiungete una funzione di attivazione Relu. Inoltre, aggiungi un termine di regolarizzazione dell'abbandono con un tasso di 0,3, il che significa che il 30 percento dei pesi verrà impostato a 0. Nota che il ritiro avviene solo durante la fase di allenamento. La funzione cnn_model_fn ha una modalità argomento per dichiarare se il modello deve essere addestrato o per valutare.

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)

Passaggio 7: Logit Layer

Infine, puoi definire l'ultimo layer con la previsione del modello. La forma di output è uguale alla dimensione del batch e 10, il numero totale di immagini.

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

È possibile creare un dizionario contenente le classi e la probabilità di ciascuna classe. Il modulo tf.argmax () con restituisce il valore più alto se i livelli logit. La funzione softmax restituisce la probabilità di ciascuna classe.

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

Si desidera restituire la previsione del dizionario solo quando la modalità è impostata su previsione. Aggiungi questi codici per visualizzare le previsioni

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

Il passaggio successivo consiste nel calcolare la perdita del modello. Nell'ultimo tutorial, hai appreso che la funzione di perdita per un modello multiclasse è l'entropia incrociata. La perdita è facilmente calcolabile con il codice seguente:

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

Il passaggio finale è ottimizzare il modello, ovvero trovare i migliori valori dei pesi. Per questo, utilizzi un Ottimizzatore discesa gradiente con una velocità di apprendimento di 0,001. L'obiettivo è ridurre al minimo la perdita

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

Hai finito con la CNN. Tuttavia, si desidera visualizzare le metriche delle prestazioni durante la modalità di valutazione. Le metriche delle prestazioni per un modello multiclasse sono le metriche di accuratezza. Tensorflow è dotato di una precisione del modulo con due argomenti, le etichette e i valori previsti.

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)

Questo è tutto. Hai creato la tua prima CNN e sei pronto a racchiudere tutto in una funzione per usarla per addestrare e valutare il modello.

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)

I passaggi seguenti sono gli stessi dei tutorial precedenti.

Prima di tutto, definisci uno stimatore con il modello CNN.

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

Una CNN impiega molte volte per allenarsi, quindi crei un hook di registrazione per memorizzare i valori dei livelli softmax ogni 50 iterazioni.

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

Sei pronto per stimare il modello. Si imposta una dimensione batch di 100 e si mescolano i dati. Tieni presente che impostiamo fasi di formazione di 16.000, può richiedere molto tempo per la formazione. Essere pazientare.

# 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])

Ora che il modello è stato addestrato, puoi valutarlo e stampare i risultati

# 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}

Con l'attuale architettura, ottieni una precisione del 97%. È possibile modificare l'architettura, la dimensione del batch e il numero di iterazioni per migliorare la precisione. La rete neurale della CNN ha funzionato molto meglio della ANN o della regressione logistica. Nel tutorial sulla rete neurale artificiale, hai avuto una precisione del 96%, che è inferiore alla CNN. Le prestazioni della CNN sono impressionanti con un set di immagini più ampio , sia in termini di velocità di calcolo che di accuratezza.

Sommario

Una rete neurale convoluzionale funziona molto bene per valutare l'immagine. Questo tipo di architettura è dominante per riconoscere gli oggetti da un'immagine o da un video.

Per costruire una CNN, devi seguire sei passaggi:

Passaggio 1: livello di input:

Questo passaggio rimodella i dati. La forma è uguale alla radice quadrata del numero di pixel. Ad esempio, se un'immagine ha 156 pixel, la forma è 26x26. È necessario specificare se l'immagine ha colore o meno. Se sì, allora avevi 3 per la forma- 3 per RGB-, altrimenti 1.

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

Passaggio 2: strato convoluzionale

Successivamente, è necessario creare i livelli convoluzionali. Si applicano diversi filtri per consentire alla rete di apprendere funzionalità importanti. Specificate la dimensione del kernel e la quantità di filtri.

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

Passaggio 3: livello di raggruppamento

Nella terza fase, aggiungi un livello di raggruppamento. Questo livello riduce la dimensione dell'input. Lo fa prendendo il valore massimo della sub-matrice. Ad esempio, se la sotto-matrice è [3,1,3,2], il raggruppamento restituirà il massimo, che è 3.

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

Passaggio 4: aggiungi strato convoluzionale e strato di pooling

In questo passaggio, puoi aggiungere quanto vuoi conv layer e pooling layers. Google utilizza un'architettura con più di 20 livelli di conv.

Passaggio 5: strato denso

Il passaggio 5 appiattisce il precedente per creare livelli completamente collegati. In questo passaggio è possibile utilizzare diverse funzioni di attivazione e aggiungere un effetto di abbandono.

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)

Passaggio 6: Logit Layer

Il passaggio finale è la previsione.

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