1. Antes de comenzar
En este codelab, aprenderás sobre las convoluciones y por qué son tan potentes en situaciones de visión artificial.
En el codelab anterior, creaste una red neuronal profunda (DNN) simple para la visión artificial de artículos de moda. Esto era limitado porque requería que el elemento de la ropa fuera lo único en la imagen y debía estar centrado.
Por supuesto, esta no es una situación realista. Te recomendamos que la DNN pueda identificar la prenda de la ropa en fotografías con otros objetos o donde esté colocada en una posición frontal y central. Para ello, necesitarás usar convolutions.
Requisitos previos
Este codelab se basa en el trabajo completado en dos cuotas anteriores, Hello to the Hello, World" of machine learning y Crea un modelo de visión artificial. Completa esos codelabs antes de continuar.
Qué aprenderás
- ¿Qué son las convoluciones?
- Cómo crear un mapa de atributos
- ¿Qué es la reducción?
Qué compilarás
- Mapa de atributos de una imagen
Requisitos
Puedes encontrar el código para el resto del codelab que se ejecuta en Colab.
También deberás instalar TensorFlow y las bibliotecas que instalaste en el codelab anterior.
2. ¿Qué son las convoluciones?
Una convolución es un filtro que pasa sobre una imagen, la procesa y extrae las características importantes.
Supongamos que tiene la imagen de una persona con calzado deportivo. ¿Cómo detectarías que hay una calzado deportivo en la imagen? Para que tu programa pueda ver la imagen como calzado deportivo, deberás extraer las características importantes y desenfocarlas. Esto se denomina asignación de atributos.
El proceso de mapeo de atributos es, en teoría, simple. Analizarás cada píxel de la imagen y, luego, los píxeles vecinos. Multiplica los valores de esos píxeles por las ponderaciones equivalentes en un filtro.
Por ejemplo:
En este caso, se especifica una matriz convolucional de 3×3 o el kernel de imagen.
El valor de píxel actual es 192. Para calcular el valor del píxel nuevo, observa los valores vecinos, multiplícalos por los valores especificados en el filtro y haz que el valor del píxel nuevo sea el importe final.
Ahora es momento de explorar cómo funcionan las convoluciones mediante la creación de una convolución básica en una imagen en escala de grises en 2D.
Demostrarás con la imagen ascendente de SciPy. Es una linda imagen integrada con muchos ángulos y líneas.
3. Comenzar a programar
Para comenzar, importa algunas bibliotecas de Python y la imagen de ascenso:
import cv2
import numpy as np
from scipy import misc
i = misc.ascent()
Luego, usa la biblioteca matplotlib de Pyplot para dibujar la imagen de modo que sepas cómo se ve:
import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()
Puedes ver que es una imagen de una escalera. Hay muchas funciones que puede probar y aislar. Por ejemplo, hay líneas verticales sólidas.
La imagen se almacena como un arreglo NumPy, por lo que podemos crear la imagen transformada con solo copiar ese arreglo. Las variables size_x y size_y contendrán las dimensiones de la imagen para que puedas repetirlas más adelante.
i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]
4. Crea la matriz de convolución
Primero, crea una matriz convolucional (o kernel) como un arreglo de 3 x 3:
# 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
Ahora, calcula los píxeles de salida. Itera sobre la imagen, deja un margen de 1 píxel y multiplica cada uno de los vecinos del píxel actual por el valor definido en el filtro.
Esto significa que el píxel actual que se encuentra al lado sobre él y a su izquierda se multiplicará por el elemento de la parte superior izquierda del filtro. Luego, multiplique el resultado por el peso y asegúrese de que esté en el rango de 0 a 255.
Por último, carga el valor nuevo en la imagen transformada:
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. Examine los resultados
Ahora, traza la imagen para ver el efecto de pasar el filtro sobre ella:
# 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 los siguientes valores de filtro y su impacto en la imagen.
Con [-1,0,1,-2,0,2,-1,0,1] obtienes un conjunto muy fuerte de líneas verticales:
Si usa [-1,-2,-1,0,0,0,1,2,1], obtendrá líneas horizontales:
Explore diferentes valores. Además, pruebe filtros de tamaño diferente, como 5 x 5 o 7 x 7.
6. Información sobre la agrupación
Ahora que identificaste las características esenciales de la imagen, ¿qué haces? ¿Cómo se usa el mapa de atributos resultante para clasificar las imágenes?
Al igual que las convoluciones, la agrupación es muy útil para detectar características. Las capas de reducción reducen la cantidad general de información en una imagen al mismo tiempo que mantienen las características que se detectan como presentes.
Existen varios tipos diferentes de agrupación, pero usarás una de estas acciones denominada Agrupación máxima (máx.).
Itera sobre la imagen y, en cada punto, observa el píxel y sus vecinos inmediatos hacia la derecha, debajo y hacia la derecha. Toma la más grande (por eso, la agrupación max) y cárgala en la imagen nueva. Por lo tanto, la imagen nueva tendrá un cuarto del tamaño de la anterior. 
7. Escribir código para agrupación
El siguiente código mostrará una agrupación (2, 2). Ejecútalo para ver el resultado.
Verás que, si bien la imagen es un cuarto del tamaño de la original, mantuvo todas las características.
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()
Observa los ejes de esa representación. La imagen ahora tiene un tamaño de 256 x 256, un cuarto de su tamaño original, y se mejoraron las características detectadas a pesar de que ahora hay menos datos en la imagen.
8. Felicitaciones
Creaste tu primer modelo de visión artificial. Para obtener más información sobre cómo mejorar los modelos de visión artificial, consulta Crea redes neuronales convolucionales (CNN) para mejorar la visión artificial.