Classificazione delle immagini CNN in TensorFlow con passaggi ed esempi
Team editoriale
⚡ Riepilogo intelligente
Le reti neurali convoluzionali analizzano un'immagine con piccoli filtri anziché ponderare ogni pixel in modo uguale, ed è per questo che dominano la visione artificiale. Questa guida illustra ogni livello e classifica le cifre del dataset MNIST utilizzando TensorFlow.
Che cos'è la rete neurale convoluzionale?
Rete neurale convoluzionaleLe reti neurali convoluzionali (CNN), note anche come reti convoluzionali, sono un metodo ben noto nelle applicazioni di visione artificiale. Si tratta di una classe di reti neurali profonde utilizzate per analizzare immagini visive. Questo tipo di architettura è dominante nel riconoscimento di oggetti da foto o video. Viene utilizzato in applicazioni come il riconoscimento di immagini o video, l'elaborazione del linguaggio naturale e i sistemi di raccomandazione.
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.
L'architettura tipica di una rete neurale convoluzionale (convnet) può essere riassunta nell'immagine sottostante. Innanzitutto, un'immagine viene inserita nella rete; questa viene chiamata immagine di input. Successivamente, l'immagine di input viene elaborata attraverso una serie di passaggi; questa è la parte convoluzionale della rete. Infine, la rete neurale è in grado di prevedere la cifra presente nell'immagine.
Un'immagine è composta da una matrice di pixel con altezza e larghezza. Un'immagine in scala di grigi ha un solo canale, mentre un'immagine a colori ne ha tre (uno per il rosso, uno per il verde e uno per il blu). I canali sono sovrapposti. In questo tutorial, utilizzeremo un'immagine in scala di grigi con un solo canale. Ogni pixel ha un valore compreso tra 0 e 255 che riflette l'intensità del colore. Ad esempio, un pixel con valore 0 rappresenterà il 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 MNISTL'immagine sottostante mostra come rappresentare l'immagine a sinistra in formato matrice. Si noti che la matrice originale è stata standardizzata in modo che i valori siano compresi tra 0 e 1. Per i colori più scuri, il valore nella matrice è circa 0.9, mentre i pixel bianchi hanno un valore di 0.
Operazione convoluzionale
Il componente più critico del modello è lo strato convoluzionale. Questa parte ha lo scopo di ridurre le dimensioni dell'immagine per velocizzare il calcolo dei pesi e migliorare 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)
Una rete convoluzionale è composta da quattro elementi:
- Circonvoluzione
- Non linearità (ReLU)
- Pooling o sottocampionamento
- 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 comprendere. Il computer scansiona una parte dell'immagine, solitamente con dimensioni di 3×3, e la moltiplica per un filtro. Il risultato della moltiplicazione elemento per elemento è chiamato mappa delle caratteristiche. Questo passaggio viene ripetuto fino a quando l'intera immagine non è stata scansionata. Si noti che, dopo la convoluzione, le dimensioni dell'immagine vengono ridotte.
Il diagramma sottostante mostra una porzione dell'immagine che viene moltiplicata per il filtro al fine di produrre una singola cella della mappa delle caratteristiche.
L'animazione sottostante mostra la stessa convoluzione applicata all'intera immagine.
Sono disponibili numerosi filtri. Di seguito ne elenchiamo alcuni. Come si può notare, ogni filtro ha uno scopo specifico. Nell'immagine sottostante, il termine "kernel" è sinonimo di filtro.
Aritmetica dietro la convoluzione
La fase convoluzionale applicherà il filtro a 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 ed eseguirà la convoluzione. L'animazione 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 presenta una mappa di caratteristiche 5×5 e un filtro 3×3. È presente una sola finestra centrale in cui il filtro può filtrare una griglia 3×3. La mappa di caratteristiche risultante si riduce di due riquadri su ciascun asse, mantenendo una dimensione di 3×3.
Per ottenere una matrice di output con le stesse dimensioni di input, è necessario aggiungere del padding. Il padding consiste nell'aggiungere il numero corretto di righe e colonne su ciascun lato della matrice. Ciò consentirà alla convoluzione di centrare ogni riquadro di input. Nell'immagine sottostante, le matrici di input e output hanno le stesse dimensioni, 5×5.
Quando si definisce la rete, le caratteristiche convolute sono controllate da tre parametri:
Profondità: Definisce il numero di filtri da applicare durante la convoluzione. Nell'esempio precedente, avete visto una profondità di 1, il che significa che viene utilizzato un solo filtro. Nella maggior parte dei casi, ci sono più filtri. L'animazione seguente mostra le operazioni eseguite in una situazione con tre filtri.
Passo: Definisce il numero di "salto di pixel" tra due sezioni. Se lo stride è uguale a 1, la finestra si sposterà con uno spostamento di un pixel. Se lo stride è uguale a due, la finestra salterà di 2 pixel. Aumentando lo stride, si otterranno mappe di caratteristiche più piccole. I due diagrammi seguenti confrontano uno stride di 1 con uno stride di 2.
Esempio di passo 1
passo 2
Zero-padding: Il padding è un'operazione che consiste nell'aggiungere un numero corrispondente di righe e colonne su ciascun lato delle mappe di input. In questo caso, l'output ha le stesse dimensioni dell'input.
Non linearità (ReLU)
Al termine dell'operazione di convoluzione, l'output viene sottoposto a una funzione di attivazione per consentire la non linearità. La funzione di attivazione più comune per una rete neurale convoluzionale è ReLU. Tutti i pixel con un valore negativo vengono sostituiti da zero.
Pooling Operaproduzione
Questo passaggio è facile da comprendere. 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 meno pesi da calcolare, prevenendo così l'overfitting.
In questa fase, è necessario definire la dimensione e lo stride. Un metodo standard per eseguire il pooling dell'immagine di input consiste nell'utilizzare il valore massimo della mappa delle caratteristiche. Osservate l'immagine sottostante. Il pooling analizzerà quattro sottomatrici della mappa delle caratteristiche 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], quindi il pooling restituirà il massimo, che è 3.
Esiste un'altra operazione di raggruppamento, come la media.
Questa operazione riduce drasticamente le dimensioni 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:
Una rete neurale convoluzionale di TensorFlow assembla diversi strati prima di effettuare una previsione. Una rete neurale ha:
- Uno strato convoluzionale
- Funzione di attivazione ReLU
- Poolinstrato g
- Strato densamente connesso
Gli strati convoluzionali applicano filtri diversi a una sottoregione dell'immagine. La funzione di attivazione ReLU aggiunge non linearità, mentre gli strati di pooling riducono la dimensionalità delle mappe di caratteristiche.
Tutti questi strati estracLe informazioni essenziali vengono ricavate dalle immagini. Infine, le mappe delle caratteristiche vengono fornite a un livello completamente connesso con una funzione softmax per effettuare una previsione.
Addestra la CNN con TensorFlow
Ora che hai familiarità con i blocchi costitutivi di una rete convoluzionale, sei pronto a costruirne una con 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
Nota sulla versione: Gli elenchi seguenti sono destinati a TensorFlow 1.x. In TensorFlow 2 lo spazio dei nomi tf.layers e tf.estimator.inputs.numpy_input_fn non esistono più; gli equivalenti sono tf.keras.layers.Conv2D, MaxPooling2D, Dense e Dropout assemblati in un tf.keras.Model e addestrati con model.fit(). Leggi i passaggi per comprendere il funzionamento di ogni livello, quindi mappali sull'API di Keras.
Passaggio 1: carica il set di dati
Il dataset MNIST è disponibile tramite scikit-learn. Scaricalo e salvalo nella cartella Download. Puoi caricarlo con fetch_mldata('MNIST original').
Nota sulla versione: mldata.org è stato chiuso e fetch_mldata() è stato rimosso in scikit-learn 0.22. Su qualsiasi installazione corrente, carica le stesse cifre con fetch_openml invece, utilizzando fetch_openml('mnist_784', version=1). Il resto della pipeline rimane invariato.
Creare un set di treni/test
È necessario suddividere il dataset con train_test_split.
Ridimensiona le caratteristiche
Infine, è possibile scalare le caratteristiche con MinMaxScaler, come mostrato nell'esempio di classificazione delle immagini qui sotto utilizzando 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 sui pixel grezzi di un'immagine per apprendere schemi di dettaglio, a differenza degli schemi globali appresi da una rete neurale tradizionale. Per costruire una CNN, è necessario definire:
- Strato convoluzionale: applica n filtri alla mappa delle caratteristiche. Dopo la convoluzione, è necessario utilizzare una funzione di attivazione ReLU per aggiungere non linearità alla rete.
- PoolinStrato g: Il passaggio successivo alla convoluzione consiste nel sottocampionare la mappa delle caratteristiche. Lo scopo è ridurre la dimensionalità della mappa delle caratteristiche per prevenire l'overfitting e migliorare la velocità di calcolo. Il max pooling è la tecnica convenzionale, che divide le mappe delle caratteristiche in sottoregioni (solitamente di dimensioni 2×2) e conserva solo i valori massimi.
- 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 blocco prima di concludere.ping 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 riguarda le caratteristiche dei dati, definite nell'argomento della funzione.
Un'immagine ha un'altezza, una larghezza e un canale. Il dataset MNIST è un'immagine monocromatica di dimensioni 28×28. Impostiamo la dimensione del batch a -1 nell'argomento shape in modo che assuma la forma delle caratteristiche ["x"]. Il vantaggio è quello di rendere la dimensione del batch un iperparametro da ottimizzare. Se la dimensione del batch è impostata a 7, il tensore fornirà 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 e lo stesso padding. Lo stesso padding significa che sia il tensore di output che quello di input devono avere la stessa altezza e larghezza. TensorFlow aggiungerà degli zeri alle righe e alle colonne per garantire le stesse dimensioni.
Si utilizza la funzione di attivazione ReLU. La dimensione dell'output sarà [28, 28, 14].
Passo 4: Poolinstrato g
Il passaggio successivo alla convoluzione è il calcolo del pooling. Il calcolo del pooling ridurrà la dimensionalità dei dati. È possibile utilizzare il modulo max_pooling2d con una dimensione di 2×2 e uno stride di 2. Si utilizza il livello 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 strato convoluzionale applica 36 filtri, ottenendo una dimensione di output di [batch_size, 14, 14, 36]. Lo strato di pooling utilizza la stessa finestra 2×2 e lo stesso passo di 2 di prima, quindi dimezza ciascun asse spaziale e la forma dell'output diventa [batch_size, 7, 7, 36].
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
Successivamente, è necessario definire il layer completamente connesso. La mappa delle caratteristiche deve essere appiattita prima di essere connessa con il layer denso. È possibile utilizzare il modulo di ridimensionamento con una dimensione di 7*7*36.
Lo strato denso collegherà 1,764 neuroni. Si aggiunge una funzione di attivazione ReLU. Inoltre, si aggiunge un termine di regolarizzazione dropout con un tasso di 0.3, il che significa che il 30% delle attivazioni verrà impostato a 0. Si noti che il dropout avviene solo durante la fase di addestramento. La funzione cnn_model_fn ha un argomento mode per dichiarare se il modello deve essere addestrato o valutato, come mostrato nell'esempio di classificazione di immagini CNN in TensorFlow riportato 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 con TensorFlow, è possibile definire l'ultimo strato con la previsione del modello. La dimensione dell'output è pari alla dimensione del batch più 10, ovvero il numero totale di classi target.
# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)
È possibile creare un dizionario contenente le classi e la probabilità di ciascuna classe. La funzione tf.argmax() restituisce l'indice del valore più alto nel livello 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 il dizionario di previsione solo quando la modalità è impostata su "previsione". Aggiungere questo codice 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 funzione di perdita del modello. Nell'ultimo tutorial, avete appreso che la funzione di perdita per un modello multiclasse è l'entropia incrociata. La perdita si calcola facilmente con il seguente codice:
# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
L'ultimo passaggio dell'esempio di CNN in TensorFlow consiste nell'ottimizzare il modello, ovvero nel trovare i valori ottimali dei pesi. A tale scopo, si utilizza un ottimizzatore a discesa del gradiente con un tasso di apprendimento di 0.001. L'obiettivo è minimizzare la funzione di perdita.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
loss=loss,
global_step=tf.train.get_global_step())
Hai completato la CNN. Tuttavia, desideri visualizzare le metriche di performance durante la modalità di valutazione. La metrica di performance per un modello multiclasse è l'accuratezza. TensorFlow è dotato di un modulo di accuratezza che accetta 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)
Nota sulla funzione assemblata: La versione concatenata qui sopra imposta il primo strato convoluzionale a 32 filtri e il dropout a 0.4, mentre gli snippet passo passo utilizzano 14 filtri e 0.3. Entrambi funzionano, ma scegliete una coppia di valori e mantenetela coerente in modo che le forme stampate corrispondano alla tabella degli strati.
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")
L'addestramento di una rete neurale convoluzionale (CNN) richiede molto tempo, pertanto è necessario creare un meccanismo di logging 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. Imposta una dimensione del batch di 100 e mescola i dati. Tieni presente che abbiamo impostato 16,000 passaggi di addestramento, il che potrebbe richiedere molto tempo. Abbi pazienza.
# 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 è stato addestrato, è possibile 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)
La valutazione stampa il checkpoint ripristinato, il passaggio in cui si è interrotta e il dizionario finale delle metriche.
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, il dizionario di valutazione riporta un'accuratezza di 0.9689286, circa il 97%. È possibile modificare l'architettura, la dimensione del batch e il numero di iterazioni per migliorare l'accuratezza. La CNN ha ottenuto risultati di gran lunga migliori rispetto a un rete neurale artificiale o regressione logistica: nel tutorial sulle reti neurali artificiali, hai ottenuto un'accuratezza del 96%, inferiore a quella della CNN. Le prestazioni della CNN sono impressionanti con un set di immagini più ampio, sia in termini di velocità di calcolo che di accuratezza.
