Classificazione delle immagini CNN in TensorFlow con passaggi ed esempi

Che cos'è la rete neurale convoluzionale?

Rete neurale convoluzionale, noto anche come convnets o CNN, è un metodo ben noto nelle applicazioni di computer vision. È una classe di reti neurali profonde che vengono utilizzate per analizzare le immagini visive. Questo tipo di architettura è dominante per riconoscere oggetti da un'immagine o un video. Viene utilizzato in applicazioni come il riconoscimento di immagini o video, l'elaborazione del linguaggio neurale, ecc.

Archistruttura di una rete neurale convoluzionale

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

Una rete neurale convoluzionale per la classificazione delle immagini non è molto difficile da comprendere. Un'immagine di input viene elaborata durante la fase di convoluzione e in seguito le viene attribuita un'etichetta.

Una tipica architettura convnet può essere riassunta nell'immagine sottostante. Innanzitutto, un'immagine viene spinta sulla rete; questa è chiamata immagine di input. Quindi, l'immagine di input passa attraverso un numero infinito di passaggi; questa è la parte convoluzionale della rete. Infine, la rete neurale può predire la cifra sull'immagine.

Un'immagine è composta da una serie 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 è sovrapposto l'uno all'altro. In questo tutorial utilizzerai un'immagine in scala di grigi con un solo canale. Ogni pixel ha un valore da 0 a 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 file set di dati MNIST. L'immagine seguente mostra come rappresentare l'immagine di sinistra in un formato matriciale. Si noti che la matrice originale è stata standardizzata per essere compresa tra 0 e 1. Per i colori più scuri, il valore nella matrice è circa 0.9 mentre i pixel bianchi hanno un valore pari a 0.

Operazione convoluzionale

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

Durante la parte convoluzionale la rete mantiene le caratteristiche essenziali dell'immagine ed esclude il rumore irrilevante. La modella, ad esempio, impara a riconoscere un elefante da un'immagine con una montagna sullo sfondo. Se si utilizza una rete neurale tradizionale, il modello assegnerà a tutti i pixel, compresi quelli della montagna, un peso che non è essenziale e può trarre in inganno la rete.

Invece, a Keras la rete neurale convoluzionale utilizzerà una tecnica matematica per spiegaretracseleziona solo i pixel più rilevanti. Questa operazione matematica si chiama convoluzione. Questa tecnica permette alla rete di apprendere caratteristiche sempre più complesse a ogni livello. La convoluzione divide la matrice in piccole parti per apprendere gli elementi più essenziali all'interno di ciascuna parte.

Componenti della rete neurale convoluzionale (ConvNet o CNN)

Ci sono quattro componenti di un Convnets

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

Circonvoluzione

Lo scopo della convoluzione è di esprimeretracLa rete neurale apprenderà le caratteristiche dell'oggetto nell'immagine a livello locale. Ciò significa che la rete apprenderà schemi specifici all'interno dell'immagine e sarà in grado di riconoscerli ovunque nell'immagine.

La convoluzione è una moltiplicazione elemento per elemento. Il concetto è facile da capire. Il computer analizzerà una parte dell'immagine, solitamente con una dimensione di 3×3 e la moltiplicherà per un filtro. L'output della moltiplicazione elemento per elemento è chiamato feature map. Questo passaggio viene ripetuto finché non è stata scansionata tutta l'immagine. Nota 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 elenchiamo alcuni canali. Puoi vedere che ogni filtro ha uno scopo specifico. Nota, nella foto qui sotto; il Kernel è sinonimo di filtro.

Aritmetica dietro la convoluzione

La fase convoluzionale applicherà il filtro su una piccola matrice di pixel all'interno dell'immagine. Il filtro si sposterà lungo l'immagine di input con una forma generale di 3×3 o 5×5. Ciò significa che la rete farà scorrere queste finestre su tutta l'immagine di input e calcolerà la convoluzione. L'immagine sottostante mostra come funziona la convoluzione. La dimensione della patch è 3×3 e la matrice di output è il risultato dell'operazione elemento per elemento tra la matrice dell'immagine e il filtro.

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

Effetto confine

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

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. Ciò consentirà alla convoluzione di centrarsi su ogni riquadro di input. Nell'immagine sotto, la matrice input/output ha la stessa dimensione 5×5

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

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

2. Passo: Definisce il numero di "salto di pixel" tra due slice. Se il passo è uguale a 1, le finestre si muoveranno con una diffusione di pixel di uno. Se il passo è uguale a due, le finestre salteranno di 2 pixel. Se si aumenta il passo, si avranno feature map più piccole.

Esempio di passo 1

passo 2

3. Imbottitura zero: 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.

Non linearità (ReLU)

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

Pooling Operaproduzione

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

In questa fase, devi definire la dimensione e la falcata. Un modo standard per raggruppare l'immagine di input è usare il valore massimo della feature map. Guarda l'immagine qui sotto. Il "pooling" selezionerà una sottomatrice a quattro della feature map 4×4 e restituirà il valore massimo. Il pooling prende il valore massimo di un array 2×2 e poi sposta questa finestra di due pixel. Ad esempio, la prima sottomatrice è [3,1,3,2], il pooling restituirà il massimo, che è 3.

Esiste un'altra operazione di raggruppamento, come la media.

Questa operazione riduce in modo aggressivo la dimensione della mappa delle caratteristiche

Livelli completamente connessi

L'ultimo passo consiste nel costruire un tradizionale rete neurale artificiale come hai fatto nel tutorial precedente. Connetti tutti i neuroni dallo strato precedente allo strato successivo. Si utilizza una funzione di attivazione softmax per classificare il numero sull'immagine di input.

Recap:

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

• Uno strato convoluzionale
• Funzione di attivazione Relu
• Poolinstrato g
• Strato densamente connesso

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

Tutti questi strati estracLe informazioni essenziali vengono ricavate dalle immagini. Infine, la mappa delle caratteristiche viene fornita a un livello primario completamente connesso con una funzione softmax per effettuare una previsione.

Addestra la CNN con TensorFlow

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

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

Seguirai i passaggi seguenti per la classificazione delle immagini utilizzando la CNN:

Passaggio 1: carica il set di dati

Passaggio 2: livello di input

Passaggio 3: livello convoluzionale

Passo 4: Poolinstrato g

Passaggio 5: secondo livello convoluzionale e Pooling Strato

Passaggio 6: strato denso

Passaggio 7: livello Logit

Passaggio 1: carica il set di dati

Il set di dati MNIST è disponibile con scikit per imparare a farlo URL. Scaricalo e memorizzalo in Download. Puoi caricarlo con fetch_mldata('MNIST originale').

Creare un set di treni/test

È necessario dividere il set di dati con train_test_split

Ridimensiona le caratteristiche

Infine, puoi ridimensionare la funzionalità con MinMaxScaler come mostrato nella classificazione delle immagini di seguito utilizzando l'esempio TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Definire la CNN

Una CNN utilizza filtri sul pixel grezzo di un'immagine per apprendere i dettagli del pattern da confrontare con il pattern globale con una rete neurale tradizionale. Per costruire una CNN, è necessario definire:

1. Un livello convoluzionale: applica n numero di filtri alla mappa delle caratteristiche. Dopo la convoluzione, è necessario utilizzare una funzione di attivazione Relu per aggiungere non linearità alla rete.
2. Pooling layer: il passo successivo dopo la convoluzione è il downsampling della feature max. Lo scopo è ridurre la dimensionalità della feature map per evitare l'overfitting e migliorare la velocità di calcolo. Il max pooling è la tecnica convenzionale, che divide le feature map in sottoregioni (solitamente con una dimensione 2×2) e mantiene solo i valori massimi.
3. Livelli completamente connessi: tutti i neuroni dei livelli precedenti sono connessi ai livelli successivi. La CNN classificherà l'etichetta in base alle caratteristiche dei livelli convoluzionali e ridotta con il livello di pooling.

Architettura CNN

• Strato convoluzionale: applica 14 filtri 5×5 (es.trac(sottoregioni di 5×5 pixel), con funzione di attivazione ReLU
• Pooling Layer: esegue il pooling massimo con un filtro 2×2 e uno stride di 2 (che specifica che le regioni raggruppate non si sovrappongono)
• Livello convoluzionale: applica 36 filtri 5×5, con funzione di attivazione ReLU
• Pooling Livello n. 2: Ancora una volta, esegue il pooling massimo con un filtro 2×2 e un passo di 2
• 1,764 neuroni, con un tasso di regolarizzazione dell'abbandono pari a 0.4 (probabilità di 0.4 che un dato elemento venga eliminato durante l'allenamento)
• Strato denso (strato Logits): 10 neuroni, uno per ogni classe target di cifre (0–9).

Ci sono tre moduli importanti da utilizzare per creare una CNN:

• conv2d(). Costruisce un livello convoluzionale bidimensionale con il numero di filtri, la dimensione del kernel del filtro, il riempimento e la funzione di attivazione come argomenti.
• max_pooling2d(). Costruisce un livello di pooling bidimensionale utilizzando l'algoritmo max-pooling.
• 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 elemento costitutivo prima di racchiudere il tutto 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 riguarda le caratteristiche dei dati, definite nell'argomento della funzione.

Un'immagine ha un'altezza, una larghezza e un canale. Il set di dati MNIST è un'immagine monocronica di dimensione 28×28. Impostiamo la dimensione del batch su -1 nell'argomento forma in modo che assuma la forma delle caratteristiche[“x”]. Il vantaggio è ottimizzare gli iperparametri delle dimensioni del batch. Se la dimensione batch è impostata su 7, il tensore alimenterà 5,488 valori (28*28*7).

Passaggio 3: livello convoluzionale

# first Convolutional Layer
  conv1 = 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 5×5 con lo stesso riempimento. Lo stesso riempimento significa che sia il tensore di output che quello di input dovrebbero avere la stessa altezza e larghezza. Tensorflow aggiungerà zeri alle righe e alle colonne per garantire la stessa dimensione.

Utilizzi la funzione di attivazione Relu. La dimensione di output sarà [28, 28, 14].

Passo 4: Poolinstrato g

Il passo successivo dopo la convoluzione è il calcolo del pooling. Il calcolo del pooling ridurrà la dimensionalità dei dati. Puoi usare il modulo max_pooling2d con una dimensione di 2×2 e uno stride di 2. Utilizzi il layer precedente come input. La dimensione dell'output sarà [batch_size, 14, 14, 14]

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

Passaggio 5: secondo livello convoluzionale e Pooling Strato

Il secondo livello convoluzionale ha 32 filtri, con una dimensione di output di [batch_size, 14, 14, 32]. Il livello di pooling ha la stessa dimensione 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 la rimodellazione del modulo con una dimensione di 7*7*36.

Lo strato denso collegherà 1764 neuroni. Aggiungi 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% dei pesi sarà impostato su 0. Tieni presente che l'abbandono avviene solo durante la fase di formazione. La funzione cnn_model_fn ha una modalità argomento per dichiarare se il modello deve essere addestrato o da valutare come mostrato nell'esempio TensorFlow di classificazione delle immagini CNN di seguito.

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: livello Logit

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

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

Puoi 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")  }			

Vuoi 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 passo successivo consiste nel calcolare la perdita del modello. Nell'ultimo tutorial, hai imparato che la funzione di perdita per un modello multiclasse è l'entropia incrociata. La perdita è facilmente calcolata con il seguente codice:

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

Il passaggio finale dell'esempio TensorFlow CNN è ottimizzare il modello, ovvero trovare i migliori valori dei pesi. Per questo, utilizzi un ottimizzatore di discesa del gradiente con un tasso 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, desideri visualizzare le metriche delle prestazioni durante la modalità di valutazione. Le metriche delle prestazioni per un modello multiclasse sono le metriche di precisione. Tensorflow è dotato di un modulo di precisione 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 per racchiudere tutto in una funzione per utilizzarla per addestrare e valutare il modello.

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

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

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

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

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

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

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

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

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

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

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

I passaggi seguenti sono gli stessi dei tutorial precedenti.

Innanzitutto si definisce uno stimatore con il modello CNN per la classificazione delle immagini.

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

Una CNN richiede molte volte l'addestramento, pertanto crei un hook di registrazione per memorizzare i valori dei livelli softmax ogni 50 iterazioni.

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

Sei pronto per stimare il modello. Imposti una dimensione batch pari a 100 e mescoli i dati. Tieni presente che impostiamo passaggi di allenamento di 16.000, l'addestramento può richiedere molto tempo. Essere pazientare.

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

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

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

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

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

Sintesi

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

Per costruire una CNN TensorFlow, devi seguire sette passaggi:

Fase 1: Carica set di dati:

Il set di dati MNIST è disponibile con scikit per imparare. Scaricalo e memorizzalo in Download. Puoi caricarlo con fetch_mldata('MNIST originale').

Fase 2: 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, allora la forma è 26×26. Devi specificare se l'immagine ha un colore o meno. Se sì, allora hai 3 alla forma, 3 per RGB, altrimenti 1.

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

Fase 3: Strato convoluzionale

Successivamente, è necessario creare i livelli convoluzionali. Applichi diversi filtri per consentire alla rete di apprendere funzionalità importanti. Specifica 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)

Fase 4: Poolinstrato g

Nel terzo passaggio, aggiungi un livello di pooling. Questo livello riduce la dimensione dell'input. Lo fa prendendo il valore massimo di una sottomatrice. Ad esempio, se la sottomatrice è [3,1,3,2], il pooling restituirà il massimo, che è 3.

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

Fase 5: Aggiungi livello convoluzionale e Pooling Strato

In questa fase, puoi aggiungere tutti i layer convoluzionali e di pooling che desideri. Google Utilizza un'architettura con più di 20 strati convoluzionali.

Fase 6: Strato denso

Il passaggio 6 appiattisce il precedente per creare livelli completamente connessi. In questo passaggio, puoi utilizzare diverse funzioni di attivazione e aggiungere un effetto di esclusione.

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)

Fase 7: Livello logit

Il passo finale è la previsione.

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