Come funzionano gli strati convoluzionali nelle reti neurali di deep learning?

Tweet Condividi Condividi

Ultimo aggiornamento il 17 aprile 2020

I livelli convoluzionali sono i principali elementi costitutivi utilizzati nelle reti neurali convoluzionali.

Una convoluzione è la semplice applicazione di un filtro a un input che risulta in un’attivazione. L’applicazione ripetuta dello stesso filtro a un input risulta in una mappa di attivazioni denominata mappa delle caratteristiche, che indica le posizioni e la forza di una caratteristica rilevata in un input, come un’immagine.

L’innovazione del neurale convoluzionale reti è la capacità di apprendere automaticamente un gran numero di filtri in parallelo specifici per un set di dati di addestramento sotto i vincoli di uno specifico problema di modellazione predittiva, come la classificazione delle immagini. Il risultato sono funzionalità altamente specifiche che possono essere rilevate ovunque sulle immagini di input.

In questo tutorial scoprirai come funzionano le convoluzioni nella rete neurale convoluzionale.

Dopo aver completato questo tutorial, saprai:

  • Le reti neurali convoluzionali applicano un filtro a un input per creare una mappa delle caratteristiche che riassume la presenza delle caratteristiche rilevate nell’input.
  • I filtri possono essere realizzati a mano , come i rilevatori di linea, ma l’innovazione delle reti neurali convoluzionali consiste nell’apprendere i filtri durante l’addestramento nel contesto di un problema di previsione specifico.
  • Come calcolare la mappa delle caratteristiche per convoluzionali unidimensionali e bidimensionali strati in una rete neurale convoluzionale.

Avvia il tuo progetto con il mio nuovo libro Deep Learning for Computer Vision, che include tutorial passo passo e file di codice sorgente Python per tutti gli esempi.

Iniziamo.

Un gentile Introduzione ai livelli convoluzionali per reti neurali di deep learning
Foto di mendhak, alcuni diritti riservati.

Panoramica del tutorial

Questo tutorial è diviso in quattro parti; essi sono:

  1. Convoluzione in reti neurali convoluzionali
  2. Convoluzione in visione artificiale
  3. Potere dei filtri appresi
  4. Esempio funzionato di Livelli convoluzionali

Vuoi risultati con il deep learning per la visione artificiale?

Prendi il mio corso intensivo e-mail gratuito di 7 giorni ora (con codice di esempio).

Fai clic per iscriverti e ottenere anche una versione PDF ebook gratuita del corso.

Scarica il tuo Mini- Corso

Convolution in Convolutional Neural Networks

La convolutional neural network, o CNN in breve, è un tipo specializzato di modello di rete neurale progettato per lavorare con dati di immagine bidimensionali, sebbene possano essere utilizzati con dati unidimensionali e tridimensionali.

Al centro della rete neurale convoluzionale è lo strato convoluzionale che dà il nome alla rete. Questo strato esegue un’operazione chiamata “convoluzione”.

Nel contesto di una rete neurale convoluzionale, una convoluzione è un’operazione lineare che implica la moltiplicazione di un insieme di pesi con l’input, proprio come un tradizionale rete neurale. Dato che la tecnica è stata progettata per l’input bidimensionale, la moltiplicazione viene eseguita tra un array di dati di input e un array bidimensionale di pesi, chiamato filtro o kernel.

Il filtro è più piccolo di i dati di input e il tipo di moltiplicazione applicato tra una patch della dimensione di un filtro dell’input e il filtro è un prodotto scalare. Un prodotto scalare è la moltiplicazione in termini di elemento tra la patch della dimensione del filtro dell’input e il filtro, che viene quindi sommato, ottenendo sempre un unico valore. Poiché si traduce in un singolo valore, l’operazione viene spesso definita “prodotto scalare”.

L’uso di un filtro più piccolo dell’input è intenzionale in quanto consente lo stesso filtro (insieme di pesi) moltiplicato per la matrice di input più volte in punti diversi dell’input. In particolare, il filtro viene applicato sistematicamente a ciascuna parte sovrapposta o patch delle dimensioni di un filtro dei dati di input, da sinistra a destra, dall’alto verso il basso.

Questa applicazione sistematica dello stesso filtro su un’immagine è un’idea potente . Se il filtro è progettato per rilevare un tipo specifico di funzionalità nell’input, l’applicazione di quel filtro sistematicamente sull’intera immagine di input consente al filtro di scoprire quella caratteristica in qualsiasi punto dell’immagine. Questa capacità è comunemente chiamata invarianza di traduzione, ad es. l’interesse generale nel sapere se l’elemento è presente piuttosto che dove era presente.

L’invarianza alla traduzione locale può essere una proprietà molto utile se ci interessa di più se qualche caratteristica è presente rispetto a dove si trova esattamente.Ad esempio, quando si determina se un’immagine contiene un volto, non è necessario conoscere la posizione degli occhi con una precisione pixel perfetta, abbiamo solo bisogno di sapere che c’è un occhio sul lato sinistro del viso e un occhio sulla destra lato del viso.

– Pagina 342, Deep Learning, 2016.

L’output della moltiplicazione del filtro con l’array di input una volta è un singolo valore. Poiché il filtro viene applicato più volte all’array di input, il risultato è un array bidimensionale di valori di output che rappresentano un filtro dell’input. In quanto tale, la matrice di output bidimensionale di questa operazione è chiamata “mappa di caratteristiche”.

Una volta creata una mappa di caratteristiche, possiamo passare ogni valore nella mappa di caratteristiche attraverso una non linearità, come una ReLU, proprio come facciamo per gli output di un livello completamente connesso.

Esempio di un filtro Applicato a un input bidimensionale per creare una mappa delle caratteristiche

Se provieni da un campo di elaborazione del segnale digitale o da un’area correlata della matematica, potresti capire l’operazione di convoluzione su una matrice come qualcosa di diverso . In particolare, il filtro (kernel) viene capovolto prima di essere applicato all’input. Tecnicamente, la convoluzione descritta nell’uso di reti neurali convoluzionali è in realtà una “correlazione incrociata”. Tuttavia, nel deep learning, viene definita operazione di “convoluzione”.

Molte librerie di machine learning implementano la correlazione incrociata ma la chiamano convoluzione.

– Pagina 333, Deep Learning, 2016.

In sintesi, abbiamo un input, come un’immagine dei valori dei pixel, e abbiamo un filtro, che è un insieme di pesi, e il filtro viene applicato sistematicamente ai dati di input per creare una mappa delle caratteristiche .

Convoluzione in Computer Vision

L’idea di applicare l’operazione convoluzionale ai dati di immagine non è nuova o unica per le reti neurali convoluzionali; è una tecnica comune utilizzata nella visione artificiale.

Storicamente, i filtri sono stati progettati a mano da esperti di visione artificiale, che sono stati poi applicati a un’immagine per ottenere una mappa delle caratteristiche o l’output dall’applicazione del filtro quindi rende l’analisi dell’immagine è più semplice in qualche modo.

Ad esempio, di seguito è riportato un filtro a elementi 3 × 3 realizzato a mano per il rilevamento delle linee verticali:

1
2
3

0.0, 1.0, 0.0
0.0, 1.0, 0.0
0.0, 1.0, 0.0

Applicando questo filtro a un file l’immagine risulterà in una mappa delle caratteristiche che contiene solo linee verticali. È un rilevatore di linea verticale.

Lo si può vedere dai valori di peso nel filtro; qualsiasi valore di pixel nella linea verticale centrale verrà attivato positivamente e qualsiasi valore su entrambi i lati verrà attivato negativamente. Trascinando questo filtro sistematicamente sui valori dei pixel in un’immagine è possibile evidenziare solo i pixel della linea verticale.

È anche possibile creare un rilevatore di linea orizzontale e applicarlo all’immagine, ad esempio:

1
2
3

0.0, 0.0, 0.0
1.0, 1.0, 1.0
0.0, 0.0, 0.0

Combinando i risultati di entrambi i filtri, ad es combinando entrambe le mappe delle caratteristiche, si evidenzieranno tutte le linee di un’immagine.

È possibile progettare una suite di decine o addirittura centinaia di altri piccoli filtri per rilevare altre caratteristiche nell’immagine.

L’innovazione nell’utilizzo dell’operazione di convoluzione in una rete neurale è che i valori del filtro sono pesi da apprendere durante l’addestramento della rete.

La rete apprenderà quali tipi di funzionalità estratto dall’input. Nello specifico, durante l’allenamento in discesa del gradiente stocastico, la rete è costretta a imparare a estrarre dall’immagine caratteristiche che riducono al minimo la perdita per il compito specifico che la rete è addestrata a risolvere, ad es. estrarre le caratteristiche che sono le più utili per classificare le immagini come cani o gatti.

In questo contesto, puoi vedere che questa è un’idea potente.

Potenza dei filtri appresi

L’apprendimento di un singolo filtro specifico per un’attività di apprendimento automatico è una tecnica potente.

Tuttavia, le reti neurali convoluzionali ottengono molto di più nella pratica .

Più filtri

Le reti neurali convoluzionali non apprendono un singolo filtro; essi, infatti, apprendono più funzionalità in parallelo per un dato input.

Ad esempio, è comune che uno strato convoluzionale apprenda da 32 a 512 filtri in parallelo per un dato input.

Ciò fornisce al modello 32, o anche 512, modi diversi di estrarre le caratteristiche da un input, o molti modi diversi sia per “imparare a vedere” e dopo l’addestramento, molti modi diversi per “vedere” i dati di input.

Questa diversità consente la specializzazione, ad es non solo le linee, ma le linee specifiche visualizzate nei dati di allenamento specifici.

Più canali

Le immagini a colori hanno più canali, in genere uno per ciascun canale di colore, come rosso, verde, e blu.

Dal punto di vista dei dati, ciò significa che una singola immagine fornita come input al modello è, in effetti, tre immagini.

Un filtro deve sempre avere lo stesso numero di canali come ingresso, spesso indicato come “profondità”. Se un’immagine in ingresso ha 3 canali (ad esempio una profondità di 3), anche un filtro applicato a quell’immagine deve avere 3 canali (ad esempio una profondità di 3). In questo caso, un filtro 3 × 3 sarebbe infatti 3x3x3 o per righe, colonne e profondità. Indipendentemente dalla profondità dell’input e dalla profondità del filtro, il filtro viene applicato all’input utilizzando un’operazione di prodotto a punti che si traduce in un singolo valore.

Ciò significa che se un livello convoluzionale ha 32 filtri, questi 32 filtri non sono solo bidimensionali per l’ingresso dell’immagine bidimensionale, ma sono anche tridimensionali, con pesi di filtro specifici per ciascuno dei tre canali. Tuttavia, ogni filtro risulta in una singola mappa delle caratteristiche. Ciò significa che la profondità dell’output dell’applicazione del layer convoluzionale con 32 filtri è 32 per le 32 mappe di feature create.

Layer multipli

I layer convoluzionali non vengono applicati solo ai dati di input , per esempio valori di pixel non elaborati, ma possono anche essere applicati all’output di altri livelli.

L’impilamento di livelli convoluzionali consente una scomposizione gerarchica dell’input.

Considera che i filtri che operano direttamente sui valori dei pixel grezzi imparerà ad estrarre le caratteristiche di basso livello, come le linee.

I filtri che operano sull’output dei primi livelli di riga possono estrarre le caratteristiche che sono combinazioni di caratteristiche di livello inferiore, come elementi che comprendono più linee per esprimere forme.

Questo processo continua fino a quando strati molto profondi non estraggono volti, animali, case e così via.

Questo è esattamente ciò che vediamo in pratica. L’astrazione delle funzionalità a ordini sempre più alti con l’aumentare della profondità della rete.

Esempio funzionato di livelli convoluzionali

La libreria di apprendimento profondo di Keras fornisce una suite di livelli convoluzionali.

Possiamo comprendere meglio l’operazione di convoluzione osservando alcuni esempi funzionanti con dati inventati e filtri artigianali.

In questa sezione, esamineremo sia un livello convoluzionale unidimensionale che un esempio di strato convoluzionale bidimensionale sia per rendere concreta l’operazione di convoluzione sia per fornire un esempio pratico dell’uso degli strati di Keras.

Esempio di strato convoluzionale 1D

Possiamo definire un uno- input dimensionale che ha otto elementi tutti con il valore 0,0, con un rilievo di due elementi nel mezzo con i valori 1.0.

1

L’input di Keras deve essere tridimensionale per uno strato convoluzionale 1D.

La prima dimensione si riferisce a ciascun campione di input; in questo caso, abbiamo solo un campione. La seconda dimensione si riferisce alla lunghezza di ogni campione; in questo caso, la lunghezza è otto. La terza dimensione si riferisce al numero di canali in ogni campione; in questo caso, abbiamo un solo canale.

Pertanto, la forma dell’array di input sarà.

1
2
3

# define input data
data = asarray ()
data = data.reshape (1, 8, 1)

Definiremo un modello che si aspetta che i campioni di input abbiano la forma.

Il modello avrà un unico filtro con la forma di 3 o tre elementi di larghezza. Keras fa riferimento alla forma del filtro come kernel_size.

1
2
3

# create model
model = Sequential ()
model.add (Conv1D (1, 3, input_shape = (8, 1)))

Per impostazione predefinita, i filtri in un livello convoluzionale sono inizializzati con pesi casuali. In questo esempio artificioso, specificheremo manualmente i pesi per il singolo filtro. Definiremo un filtro in grado di rilevare i dossi, ovvero un valore di input alto circondato da valori di input bassi, come definito nel nostro esempio di input.

Il filtro a tre elementi che definiremo appare come segue:

1

Il livello convoluzionale ha anche un valore di input di polarizzazione che richiede anche un peso che imposteremo a zero.

Pertanto, possiamo forzare i pesi del nostro strato convoluzionale unidimensionale a utilizzare il nostro filtro artigianale come segue:

I pesi devono essere specificati in struttura tridimensionale, in termini di righe, colonne e canali. Il filtro ha una singola riga, tre colonne e un canale.

Possiamo recuperare i pesi e confermare che sono stati impostati correttamente.

1
2

# conferma che sono stati memorizzati
print (model.get_weights ())

Infine, possiamo applicare il filtro singolo ai nostri dati di input.

Possiamo ottenere ciò chiamando la funzione Forecast () sul modello. Questo restituirà direttamente la mappa delle caratteristiche: questo è l’output dell’applicazione del filtro sistematicamente attraverso la sequenza di input.

1
2
3

# applica il filtro ai dati di input
yhat = model.predict (data)
print (yhat )

Mettendo insieme tutto questo, l’esempio completo è elencati di seguito.

L’esecuzione dell’esempio stampa prima i pesi della rete; questa è la conferma che il nostro filtro artigianale è stato impostato nel modello come previsto.

Successivamente, il filtro viene applicato al pattern di input e la mappa delle caratteristiche viene calcolata e visualizzata. Possiamo vedere dai valori della mappa delle caratteristiche che l’urto è stato rilevato correttamente.

1
2
3
4
5
6
7
8
9
10

],
],
]], dtype = float32), array (, dtype = float32)]
]]

Diamo un’occhiata più da vicino a cosa è successo qui.

Ricorda che l’input è un vettore di otto elementi con i valori:.

In primo luogo, il filtro a tre elementi è stato applicato ai primi tre input del messo calcolando il prodotto scalare (operatore “.”), che ha restituito un unico valore di output nella mappa delle caratteristiche pari a zero.

1
2

from numpy import asarray
print (asarray (). dot (asarray ()))

Nel nostro esempio manuale, questo è il seguente:

1

. = 0

Il filtro è stato quindi spostato lungo un elemento di la sequenza di input e il processo sono stati ripetuti; in particolare, lo stesso filtro è stato applicato alla sequenza di input agli indici 1, 2 e 3, il che ha comportato anche un output zero nella mappa delle caratteristiche.

1

. = 0

Siamo sistematici, quindi ancora una volta, il il filtro viene spostato lungo un altro elemento dell’input e applicato all’input agli indici 2, 3 e 4. Questa volta l’output è un valore di uno nella mappa delle caratteristiche. Abbiamo rilevato la funzione e l’abbiamo attivata in modo appropriato.

1

. = 1

Il processo viene ripetuto finché non calcoliamo l’intero mappa delle caratteristiche.

1

Nota che la mappa delle caratteristiche ha sei elementi, mentre il nostro input ha otto elementi. Questo è un artefatto di come il filtro è stato applicato alla sequenza di input. Ci sono altri modi per applicare il filtro alla sequenza di input che cambia la forma della mappa delle caratteristiche risultante, come il riempimento, ma non discuteremo di questi metodi in questo post.

Puoi immaginarlo con input, possiamo rilevare la funzione con più o meno intensità e con pesi diversi nel filtro, che rileveremmo caratteristiche diverse nella sequenza di input.

Esempio di strato convoluzionale 2D

Possiamo espandere l’esempio di rilevamento di urti nella sezione precedente a un rilevatore di linea verticale in un’immagine bidimensionale.

Di nuovo , possiamo vincolare l’input, in questo caso a un’immagine di input quadrata di 8 × 8 pixel con un singolo canale (ad es. scala di grigi) con una singola linea verticale nel mezzo.

1
2
3
4
5
6
7
8

L’input a un livello Conv2D deve essere quadridimensionale.

La prima dimensione definisce i campioni; in questo caso c’è un solo campione. La seconda dimensione definisce il numero di righe; in questo caso otto. La terza dimensione definisce il numero di colonne, ancora otto in questo caso, e infine il numero di canali, che in questo caso è uno.

Pertanto, l’input deve avere la forma quadridimensionale o in questa case.

Definiremo Conv2D con un unico filtro come abbiamo fatto nella sezione precedente con l’esempio Conv1D.

Il filtro sarà bidimensionale e quadrato con la forma 3 × 3. Il livello si aspetta che i campioni di input abbiano la forma o.

1
2
3

# create model
model = Sequential ()
model.add (Conv2D (1, (3,3), input_shape = (8, 8, 1)))

Definiremo una verticale filtro rilevatore di linea per rilevare la singola linea verticale nei nostri dati di input.

Il filtro ha il seguente aspetto:

1
2
3

0, 1, 0
0, 1, 0
0, 1, 0

Possiamo implementarlo come segue:

Infine, lo faremo applica il filtro all’immagine di input, che risulterà in una mappa di caratteristiche che ci aspetteremmo di mostrare il rilevamento della linea verticale nell’immagine di input.

1
2
# applica il filtro ai dati di input
yhat = model.predict (data)

La forma dell’output della mappa delle caratteristiche sarà quadridimensionale con la forma. Eseguiremo un singolo batch e avremo un singolo filtro (un filtro e un canale di input), quindi la forma dell’output è. Possiamo stampare in modo carino il contenuto della mappa di elementi singoli come segue:

1
2
3

for r in range (yhat.shape):
# print ogni colonna nella riga
print (for c in range ( yhat.shape)])

Mettere insieme tutto questo , l’esempio completo è elencato di seguito.

L’esecuzione dell’esempio prima conferma che il filtro artigianale è stato definito correttamente nei pesi dei layer

Successivamente, viene stampata la mappa delle caratteristiche calcolate. Possiamo vedere dalla scala dei numeri che effettivamente il filtro ha rilevato l’unica linea verticale con forte attivazione al centro della mappa delle caratteristiche.

Diamo uno sguardo più da vicino a quanto calcolato.

Innanzitutto, il filtro è stato applicato all’angolo in alto a sinistra dell’immagine, o una patch immagine di 3 × 3 elementi. Tecnicamente, la patch dell’immagine è tridimensionale con un singolo canale e il filtro ha le stesse dimensioni. Non possiamo implementarlo in NumPy usando la funzione punto (), invece, dobbiamo usare la funzione tensordot () in modo da poter sommare adeguatamente tutte le dimensioni, ad esempio:

Questo calcolo risulta in un singolo valore di output di 0,0, ad esempio, la funzione non è stata rilevata. Questo ci fornisce il primo elemento nell’angolo in alto a sinistra della mappa delle caratteristiche.

Manualmente, questo sarebbe il seguente:

1
2
3

0, 1, 0 0, 0, 0
0, 1, 0. 0, 0, 0 = 0
0, 1, 0 0, 0, 0

Il filtro viene spostato lungo una colonna a sinistra e il processo viene ripetuto. Anche in questo caso, la funzione non viene rilevata.

1
2
3

0, 1, 0 0, 0, 1
0, 1, 0. 0, 0, 1 = 0
0, 1, 0 0, 0, 1

Un altro passaggio a sinistra alla colonna successiva e la funzione viene rilevata per la prima volta, determinando un’attivazione forte.

1
2
3

0, 1, 0 0, 1, 1
0, 1, 0. 0, 1, 1 = 3
0, 1, 0 0, 1, 1

Questo processo viene ripetuto fino a quando il bordo del filtro poggia contro il bordo o la colonna finale dell’immagine di input. Questo fornisce l’ultimo elemento nella prima riga completa della mappa degli elementi.

1

Il filtro si sposta quindi in basso di una riga e torna alla prima colonna e al il processo è correlato da sinistra a destra per dare la seconda riga della mappa delle caratteristiche. E fino a quando la parte inferiore del filtro si trova sulla riga inferiore o sull’ultima dell’immagine in ingresso.

Ancora una volta, come nella sezione precedente, possiamo vedere che la mappa delle caratteristiche è una matrice 6 × 6, più piccola dell’immagine di input 8 × 8 a causa dei limiti di come il filtro può essere applicato all’immagine di input.

Ulteriori letture

Questa sezione fornisce più risorse sull’argomento, se lo sei cercando di andare più a fondo.

Post

  • Corso accelerato in reti neurali convoluzionali per l’apprendimento automatico

Libri

  • Capitolo 9: Convolutional Networks, Deep Learning, 2016.
  • Capitolo 5: Deep Learning for Computer Vision, Deep Learning with Python, 2017.

API

  • API Keras Convolutional Layers
  • API numpy.asarray

Riepilogo

In questo tutorial, hai scoperto come funzionano le convoluzioni nella rete neurale convoluzionale.

In particolare, hai imparato:

  • Le reti neurali convoluzionali applicano un filtro a un input per creare una mappa delle caratteristiche che riepiloga la presenza delle caratteristiche rilevate nell’input.
  • I filtri possono essere realizzati a mano, come i rilevatori di linea, ma l’innovazione delle reti neurali convoluzionali consiste nell’apprendere i filtri durante l’addestramento nel contesto di uno specifico problema di previsione.
  • la mappa delle caratteristiche per i livelli convoluzionali unidimensionali e bidimensionali in una rete neurale convoluzionale.

Hai domande?
Poni le tue domande nei commenti qui sotto e farò il mio meglio rispondere.

Sviluppa modelli di deep learning per la visione oggi!

Sviluppa i tuoi modelli di visione in pochi minuti

… con poche righe di codice Python

Scopri come nel mio nuovo ebook:
Deep Learning for Computer Vision

Fornisce tutorial di autoapprendimento su argomenti come: classificazione
, rilevamento di oggetti (yolo e rcnn), riconoscimento facciale (vggface e facenet) , preparazione dei dati e molto altro ancora …

Finalmente porta il deep learning nei tuoi progetti di visione

Salta gli accademici. Solo risultati.

Guarda cosa c’è dentro

Tweet Condividi Condividi

Leave a Reply

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *