1. Prima di iniziare
In questo codelab, scoprirai le convoluzioni e il motivo per cui sono così potenti negli scenari di visione artificiale.
Nel codelab precedente, hai creato una semplice Deep Neural Network (DNN) per la visione artificiale degli articoli di moda. Questo era limitato perché era necessario che l'articolo di abbigliamento fosse l'unico elemento della foto e dovesse essere centrato.
Naturalmente, questo non è uno scenario realistico. Vuoi che il tuo DNN sia in grado di identificare il capo di abbigliamento nelle immagini con altri oggetti o in cui non è posizionato in primo piano. Per farlo, dovrai usare le convoluzioni.
Prerequisiti
Questo codelab si basa sul lavoro completato in due istanze precedenti, Dai il benvenuto a "Hello, World" di machine learning e Crea un modello di visione artificiale. Completa questi codelab prima di continuare.
Cosa imparerai a fare:
- Cosa sono le convoluzioni
- Come creare una mappa delle caratteristiche
- Che cos'è il pooling
Cosa imparerai a realizzare
- Mappa di un'immagine in primo piano
Che cosa ti serve
Puoi trovare il codice per il resto del codelab in esecuzione in Colab.
Dovrai anche installare TensorFlow e le librerie installate nel codelab precedente.
2. Cosa sono le convoluzioni?
Una convoluzione è un filtro che passa su un'immagine, la elabora ed estrae le caratteristiche importanti.
Supponiamo che tu abbia l'immagine di una persona che indossa una sneaker. Come puoi rilevare la presenza di una sneaker nell'immagine? Affinché il tuo programma possa "vedi" l'immagine come una sneaker, dovrai estrarre le caratteristiche importanti e sfocare le caratteristiche essenziali. Questa funzionalità è chiamata mappatura funzionalità.
Teoricamente il processo di mappatura delle funzionalità è semplice. Eseguirai la scansione di ogni pixel nell'immagine e guarderai quindi ai pixel adiacenti. Puoi moltiplicare i valori di tali pixel per le ponderazioni equivalenti in un filtro.
Ad esempio:
In questo caso, viene specificata una matrice di convoluzione 3x3, o kernel immagine.
Attualmente il valore pixel è 192. Puoi calcolare il valore del nuovo pixel esaminando i valori dei vicini, moltiplicandoli per i valori specificati nel filtro e impostando il nuovo pixel come importo finale.
Ora è il momento di esplorare il funzionamento delle convoluzioni creando un'immagine di base per la conversione in scala di grigi 2D.
Dimostrerai che con l'immagine di salita di SciPy. È una bella immagine integrata con molti angoli e linee.
3. Inizia programmazione
Inizia importando alcune librerie Python e l'immagine di salita:
import cv2
import numpy as np
from scipy import misc
i = misc.ascent()
A questo punto, utilizza la libreria Pyplot matplotlib per disegnare l'immagine in modo che sappia che aspetto ha:
import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()
Si vede che è l'immagine di una scalinata. Esistono molte funzionalità che puoi provare a isolare. ad esempio, linee forti verticali.
L'immagine viene archiviata come un array NumPy, quindi possiamo creare l'immagine trasformata semplicemente copiandola. Le variabili size_x e size_y manterranno le dimensioni dell'immagine in modo che tu possa eseguirne il loop in un secondo momento.
i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]
4. Crea la matrice di convoluzione
Innanzitutto, crea una matrice di convoluzione (o kernel) come array 3x3:
# This filter detects edges nicely
# It creates a filter that only passes through sharp edges and straight lines.
# Experiment with different values for fun effects.
#filter = [ [0, 1, 0], [1, -4, 1], [0, 1, 0]]
# A couple more filters to try for fun!
filter = [ [-1, -2, -1], [0, 0, 0], [1, 2, 1]]
#filter = [ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
# If all the digits in the filter don't add up to 0 or 1, you
# should probably do a weight to get it to do so
# so, for example, if your weights are 1,1,1 1,2,1 1,1,1
# They add up to 10, so you would set a weight of .1 if you want to normalize them
weight = 1
Ora calcola i pixel di output. Ripeti l'iterazione dell'immagine lasciando un margine di 1 pixel e moltiplica ogni adiacente del pixel corrente per il valore definito nel filtro.
Ciò significa che il vicino corrente del pixel sopra e a sinistra del moltiplicatore verrà moltiplicato per l'elemento in alto a sinistra nel filtro. Quindi, moltiplica il risultato per il peso e assicurati che l'intervallo sia compreso nell'intervallo da 0 a 255.
Infine, carica il nuovo valore nell'immagine trasformata:
for x in range(1,size_x-1):
for y in range(1,size_y-1):
output_pixel = 0.0
output_pixel = output_pixel + (i[x - 1, y-1] * filter[0][0])
output_pixel = output_pixel + (i[x, y-1] * filter[0][1])
output_pixel = output_pixel + (i[x + 1, y-1] * filter[0][2])
output_pixel = output_pixel + (i[x-1, y] * filter[1][0])
output_pixel = output_pixel + (i[x, y] * filter[1][1])
output_pixel = output_pixel + (i[x+1, y] * filter[1][2])
output_pixel = output_pixel + (i[x-1, y+1] * filter[2][0])
output_pixel = output_pixel + (i[x, y+1] * filter[2][1])
output_pixel = output_pixel + (i[x+1, y+1] * filter[2][2])
output_pixel = output_pixel * weight
if(output_pixel<0):
output_pixel=0
if(output_pixel>255):
output_pixel=255
i_transformed[x, y] = output_pixel
5. Esamina i risultati
Ora traccia l'immagine per vedere l'effetto del passaggio del filtro:
# Plot the image. Note the size of the axes -- they are 512 by 512
plt.gray()
plt.grid(False)
plt.imshow(i_transformed)
#plt.axis('off')
plt.show()
Considera i seguenti valori dei filtri e il loro impatto sull'immagine.
L'uso di [-1,0,1,-2,0,2,-1,0,1] offre un insieme di linee verticali molto forti:
Utilizzando [-1,-2,-1,0,0,0,1,2,1] ottieni linee orizzontali:
Esplora valori diversi. Inoltre, prova a utilizzare filtri di diverse dimensioni, ad esempio 5 x 5 o 7 x 7.
6. Informazioni sulla chat
Ora che hai identificato le funzionalità essenziali dell'immagine, cosa puoi fare? Come utilizzi la mappa delle funzionalità risultante per classificare le immagini?
Come per le convoluzioni, il pooling è molto utile per rilevare le funzionalità. I livelli di raggruppamento permettono di ridurre la quantità complessiva di informazioni in un'immagine, mantenendo al contempo le funzionalità rilevate come presenti.
Esistono diversi tipi di pool, ma ne utilizzerai uno chiamato massimo (max).
Ripeti l'immagine sopra e, a ogni punto, considera il pixel e i suoi vicini adiacenti a destra, sotto e a destra. Prendine il più grande (ovvero pool massimo) e caricalo nella nuova immagine. Di conseguenza, la nuova immagine sarà un quarto più grande della vecchia. 
7. Scrivi il codice per il pool
Il codice seguente mostra un pool (2, 2). Eseguilo per vedere l'output.
Vedrai che, sebbene l'immagine sia un quarto delle dimensioni originali, ha conservato tutte le funzionalità.
new_x = int(size_x/2)
new_y = int(size_y/2)
newImage = np.zeros((new_x, new_y))
for x in range(0, size_x, 2):
for y in range(0, size_y, 2):
pixels = []
pixels.append(i_transformed[x, y])
pixels.append(i_transformed[x+1, y])
pixels.append(i_transformed[x, y+1])
pixels.append(i_transformed[x+1, y+1])
pixels.sort(reverse=True)
newImage[int(x/2),int(y/2)] = pixels[0]
# Plot the image. Note the size of the axes -- now 256 pixels instead of 512
plt.gray()
plt.grid(False)
plt.imshow(newImage)
#plt.axis('off')
plt.show()
Prendi nota degli assi della trama. L'immagine ha ora una dimensione di 256 x 256, un quarto delle sue dimensioni originali e le funzionalità rilevate sono state migliorate nonostante la quantità di dati attualmente presente nell'immagine sia migliorata.
8. Complimenti
Hai creato il tuo primo modello di visione artificiale! Per scoprire come migliorare ulteriormente i tuoi modelli di visione artificiale, consulta Sviluppare reti neurali convoluzionali (CNN) per migliorare la visione artificiale.