Elaborazione delle immagini con la CNN | Guida per principianti all'elaborazione delle immagini

Contenuti

Questo articolo è stato pubblicato nell'ambito del Blogathon sulla scienza dei dati

Los diversos métodos de apprendimento profondo utilizan datos para entrenar algoritmos de redes neuronales para realizar una variedad de tareas de aprendizaje automático, come la classificazione di diverse classi di oggetti. Le reti neurali convoluzionali sono algoritmi di deep learning molto potenti per l'analisi delle immagini. Questo articolo spiegherà come costruire, addestrare e valutare le reti neurali convoluzionali.

Imparerai anche come migliorare la tua capacità di apprendere dai dati e come interpretare i risultati dell'allenamento.. Deep Learning ha diverse applicazioni come l'elaborazione delle immagini, elaborazione del linguaggio naturale, eccetera. Viene utilizzato anche nelle scienze mediche, Media e intrattenimento, Auto Autonome, eccetera.

Cos'è la CNN?

La CNN è un potente algoritmo per l'elaborazione delle immagini. Questi algoritmi sono attualmente i migliori algoritmi che abbiamo per l'elaborazione automatica delle immagini.. Molte aziende usano questi algoritmi per fare cose come identificare gli oggetti in un'immagine.

Le immagini contengono dati di combinazione RGB. Matplotlib può essere usato per importare un'immagine in memoria da un file. Il computer non vede un'immagine, tutto ciò che vedi è una serie di numeri. Le immagini a colori sono memorizzate in array tridimensionali. Le prime due dimensioni corrispondono all'altezza e alla larghezza dell'immagine (il numero di pixel). La última dimensione corresponde a los colores rojo, verde e blu presenti in ogni pixel.

Tre strati di CNN

Reti neurali convoluzionali specializzate per applicazioni di riconoscimento di immagini e video. La CNN viene utilizzata principalmente in attività di analisi delle immagini come il riconoscimento delle immagini, detección de objetos y segmentación.

Ci sono tre tipi di strati nelle reti neurali convoluzionali:

1) copertina convolutiva: in un neuronale rosso típica, ogni neurone di input è connesso al livello nascosto successivo. e la CNN, solo una pequeña región de las neuronas de la livello di input se conecta a la capa oculta de neuronas.

2) Livello di raggruppamento: il livello di raggruppamento viene utilizzato per ridurre la dimensionalità della mappa delle caratteristiche. Ci saranno più livelli di attivazione e raggruppamento all'interno del livello nascosto della CNN.

3) Strato completamente connesso: Livelli completamente connessi forma l'ultimo copertine In rete. L'ingresso al livello completamente connesso è l'output del raggruppamento o convoluzione finale Copertura frontale, che viene appiattito e poi introdotto nel livello completamente connesso.

60350cnn-1-7990985

Fonte: Google Immagini

Set di dati MNIST

In questo articolo, lavoreremo sul riconoscimento degli oggetti nei dati delle immagini utilizzando il set di dati MNIST per il riconoscimento delle cifre scritte a mano.

Il set di dati MNIST è costituito da immagini di cifre da una varietà di documenti scansionati. Ogni immagine è un quadrato di 28 X 28 pixel. In questo set di dati, sono utilizzati 60.000 immagini per addestrare il modello e 10.000 immagini per testare il modello. Ci sono 10 cifre (0 un 9) oh 10 classi da prevedere.

20748screenshot202021-06-1820at207-18-2520pm-5492953

Fonte: Google Immagini


Caricamento del set di dati MNIST

Instale la biblioteca de TensorFlow e importe el conjunto de datos como un conjunto de datos de addestramento y prueba.

Tracciare l'output di esempio dell'immagine

!pip install tensorflow
from keras.datasets import mnist
import matplotlib.pyplot as plt
(X_treno,y_train), (X_test, y_test)= mnist.load_data()
plt.sottotrama()
plt.imshow(X_treno[9], cmap=plt.get_cmap('grigio'))

Produzione:

222-5863504

Modello di deep learning con percettroni multistrato con MNIST

In questo modello, creeremo un semplice modello di rete neurale con un singolo livello nascosto per il set di dati MNIST per il riconoscimento delle cifre scritte a mano.

Un percettrone è un modello a singolo neurone che è l'elemento costitutivo di reti neurali più grandi.. Il percettrone multistrato è costituito da tre strati, vale a dire, il livello di input, la capa oculta y la capa de salida. Il livello nascosto non è visibile al mondo esterno. Sono visibili solo il livello di input e il livello di output. Per tutti i modelli DL, I dati devono essere di natura numerica.

passo 1: importare librerie di chiavi

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils

passo 2: rimodellare i dati

Ogni immagine ha una dimensione di 28X28, quindi c'è 784 pixel. Quindi, il livello di output ha 10 Partenze, lo strato nascosto ha 784 neuroni e lo strato di input ha 784 Biglietti. Dopo, il set di dati viene convertito in un tipo di dati float.

number_pix=X_train.shape[1]*X_train.shape[2] 
X_train=X_train.reshape(X_train.shape[0], numero_pix).come tipo('float32')
X_test=X_test.reshape(X_test.shape[0], numero_pix).come tipo('float32')

passo 3: normalizzare i dati

I modelli NN generalmente richiedono dati in scala. In questo frammento di codice, i dati sono normalizzati da (0-255) un (0-1) y la variabile de destino se codifica en un solo uso para su posterior análisis. La variabile target ha un totale di 10 Lezioni (0-9)

X_train=X_train/255
X_test=X_test/255
y_train= np_utils.to_categorical(y_train)
y_test= np_utils.to_categorical(y_test)
num_classes=y_train.shape[1]
Stampa(num_classi)

Produzione:

10

Ora, Creeremo una funzione NN_model e la compileremo

passo 4: Definire la funzione del modello

def nn_model():
    modello=Sequenziale()
    modello.aggiungi(Denso(numero_pix, input_dim=number_pix, attivazione = 'rileggere'))
    mode.add(Denso(num_classi, attivazione='softmax'))
    modello.compila(perdita="categorical_crossentropy", ottimizzatore="Adamo", metriche=['precisione'])
    modello di ritorno

Ci sono due livelli, una es una capa oculta con la función de activación ReLu y la otra es la capa de salida que usa la función softmax.

passo 5: Eseguire il modello

modello=nn_model()
model.fit(X_treno, y_train, validation_data=(X_test,y_test),epoche=10, batch_size=200, verboso=2)
punteggio= modello.valutare(X_test, y_test, verboso=0)
Stampa('L'errore è: %.2F%%'%(100-punto[1]*100))

Produzione:

Epoca 1/10
300/300 - 11S - perdita: 0.2778 - precisione: 0.9216 - val_loss: 0.1397 - val_accuracy: 0.9604
Epoca 2/10
300/300 - 2S - perdita: 0.1121 - precisione: 0.9675 - val_loss: 0.0977 - val_accuracy: 0.9692
Epoca 3/10
300/300 - 2S - perdita: 0.0726 - precisione: 0.9790 - val_loss: 0.0750 - val_accuracy: 0.9778
Epoca 4/10
300/300 - 2S - perdita: 0.0513 - precisione: 0.9851 - val_loss: 0.0656 - val_accuracy: 0.9796
Epoca 5/10
300/300 - 2S - perdita: 0.0376 - precisione: 0.9892 - val_loss: 0.0717 - val_accuracy: 0.9773
Epoca 6/10
300/300 - 2S - perdita: 0.0269 - precisione: 0.9928 - val_loss: 0.0637 - val_accuracy: 0.9797
Epoca 7/10
300/300 - 2S - perdita: 0.0208 - precisione: 0.9948 - val_loss: 0.0600 - val_accuracy: 0.9824
Epoca 8/10
300/300 - 2S - perdita: 0.0153 - precisione: 0.9962 - val_loss: 0.0581 - val_accuracy: 0.9815
Epoca 9/10
300/300 - 2S - perdita: 0.0111 - precisione: 0.9976 - val_loss: 0.0631 - val_accuracy: 0.9807
Epoca 10/10
300/300 - 2S - perdita: 0.0082 - precisione: 0.9985 - val_loss: 0.0609 - val_accuracy: 0.9828
L'errore è: 1.72%

Nei risultati del modello, es visible a misura que aumenta el número de épocas, migliora la precisione. L'errore è da 1,72%, minore è l'errore, maggiore è la precisione del modello.

Modello di rete neurale convoluzionale utilizzando MNIST

In questa sezione, creeremo semplici modelli CNN per MNIST che dimostrino livelli convoluzionali, raggruppare i livelli e abbandonare i livelli.

passo 1: importa tutte le librerie necessarie

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D

passo 2: Configurare il seed per la riproducibilità e caricare i dati MNIST

seed=10
np.random.seed(seme)
(X_treno,y_train), (X_test, y_test)= mnist.load_data()

passo 3: Convertire i dati in valori mobili

X_train=X_train.reshape(X_train.shape[0], 1,28,28).come tipo('float32')
X_test=X_test.reshape(X_test.shape[0], 1,28,28).come tipo('float32')

passo 4: normalizzare i dati

X_train=X_train/255
X_test=X_test/255
y_train= np_utils.to_categorical(y_train)
y_test= np_utils.to_categorical(y_test)
num_classes=y_train.shape[1]
Stampa(num_classi)

Una classica architettura CNN sembra sotto:

63838cnntoday-3782857

Fonte: Google Immagini

Livello di output
(10 Partenze)
Mantello nascosto
(128 neuroni)
Strato piatto
Mantello dell'abbandono
20%
Livello di raggruppamento massimo
2 × 2
copertina convolutiva
32 mappe, 5 × 5
Livello visibile
1x28x28

Il primo livello nascosto è un livello convoluzionale chiamato Convolution2D. Smaltire 32 mappe di funzionalità con dimensioni 5 × 5 e funzione di macinazione. Questo è il livello di input. Quello che segue è il livello di pooling che assume il valore massimo chiamato MaxPooling2D. In questo modello, è configurato come una dimensione del pool di 2 × 2.

En la capa de abandono ocurre la regolarizzazione. È configurato per escludere casualmente il 20% neuroni di strato per evitare il sovradattamento. Il quinto livello è il livello appiattito che converte i dati della matrice 2D in un vettore chiamato Flatten. Consente l'elaborazione completa dell'output da un livello standard completamente connesso.

Prossimo, lo strato completamente connesso viene utilizzato con 128 neuronas y la funzione sveglia del rectificador. Finalmente, il livello di output ha 10 neuroni per 10 classi e una funzione trigger softmax per generare previsioni simili alla probabilità per ogni classe.

passo 5: Eseguire il modello

def cnn_model():
    modello=Sequenziale()
    modello.aggiungi(Conv2D(32,5,5, imbottitura='uguale',input_shape=(1,28,28), attivazione = 'rileggere'))
    modello.aggiungi(MaxPooling2D(pool_size=(2,2), imbottitura='uguale'))
    modello.aggiungi(Ritirarsi(0.2))
    modello.aggiungi(Appiattire())
    modello.aggiungi(Denso(128, attivazione = 'rileggere'))
    modello.aggiungi(Denso(num_classi, attivazione='softmax'))
    modello.compila(perdita="categorical_crossentropy", ottimizzatore="Adamo", metriche=['precisione'])
    modello di ritorno
modello=cnn_model()
model.fit(X_treno, y_train, validation_data=(X_test,y_test),epoche=10, batch_size=200, verboso=2)
punteggio= modello.valutare(X_test, y_test, verboso=0)
Stampa('L'errore è: %.2F%%'%(100-punto[1]*100))

Produzione:

Epoca 1/10
300/300 - 2S - perdita: 0.7825 - precisione: 0.7637 - val_loss: 0.3071 - val_accuracy: 0.9069
Epoca 2/10
300/300 - 1S - perdita: 0.3505 - precisione: 0.8908 - val_loss: 0.2192 - val_accuracy: 0.9336
Epoca 3/10
300/300 - 1S - perdita: 0.2768 - precisione: 0.9126 - val_loss: 0.1771 - val_accuracy: 0.9426
Epoca 4/10
300/300 - 1S - perdita: 0.2392 - precisione: 0.9251 - val_loss: 0.1508 - val_accuracy: 0.9537
Epoca 5/10
300/300 - 1S - perdita: 0.2164 - precisione: 0.9325 - val_loss: 0.1423 - val_accuracy: 0.9546
Epoca 6/10
300/300 - 1S - perdita: 0.1997 - precisione: 0.9380 - val_loss: 0.1279 - val_accuracy: 0.9607
Epoca 7/10
300/300 - 1S - perdita: 0.1856 - precisione: 0.9415 - val_loss: 0.1179 - val_accuracy: 0.9632
Epoca 8/10
300/300 - 1S - perdita: 0.1777 - precisione: 0.9433 - val_loss: 0.1119 - val_accuracy: 0.9642
Epoca 9/10
300/300 - 1S - perdita: 0.1689 - precisione: 0.9469 - val_loss: 0.1093 - val_accuracy: 0.9667
Epoca 10/10
300/300 - 1S - perdita: 0.1605 - precisione: 0.9493 - val_loss: 0.1053 - val_accuracy: 0.9659
L'errore è: 3.41%

Nei risultati del modello, è visibile all'aumentare del numero di epoche, migliora la precisione. L'errore è 3.41%, errore inferiore maggiore precisione del modello.

Spero che ti sia piaciuto leggere e sentiti libero di usare il mio codice per testarlo per i tuoi scopi. Cosa c'è di più, se c'è qualche commento sul codice o solo sul post del blog, non esitate a contattarmi a [e-mail protetta]

I media mostrati in questo articolo sull'elaborazione delle immagini della CNN non sono di proprietà di DataPeaker e vengono utilizzati a discrezione dell'autore.

Iscriviti alla nostra Newsletter

Non ti invieremo posta SPAM. Lo odiamo quanto te.