La convolución horizontal y vertical de strides se encuentra dentro de la serie de procesos que se llevan a cabo para las redes neuronales convolucionales en cada una de las capas de su arquitectura.

Por ello, en el desarrollo de este post, te mostramos cómo se comporta la convolución horizontal y vertical de strides.

Convolución horizontal y vertical de strides

Hay que partir de que los detectores de patrones en las redes convolucionales no están detectando nada, simplemente están multiplicando y sumando cosas.

Vamos a ver unos ejemplos para comprobar qué es lo que pasa cuando hacemos estas multiplicaciones y sumas para la convolución horizontal y vertical de strides:

# Hacemos los imports necesarios
import numpy as np
from scipy import signal
from scipy import misc
ascent = misc.ascent()
kernel = np.array([[-1, 0, +1],
                   [-1, 0, +1],
                   [-1, 0, +1]])
grad = signal.convolve2d(ascent, kernel, boundary='symm', mode='same')

import matplotlib.pyplot as plt

# función para mostrar dos imágenes juntas
def plot_two(img_orig, img_conv):
  fig, (ax_orig, ax_mag) = plt.subplots(1, 2, figsize=(20, 50))
  ax_orig.imshow(img_orig, cmap='gray')
  ax_orig.set_title('Original')
  ax_orig.set_axis_off()
  ax_mag.imshow((img_conv), cmap='gray')
  ax_mag.set_title('Gradiente')
  ax_mag.set_axis_off()

plot_two(ascent, grad)

Parece que estamos detectando algunos bordes que son, en definitiva, líneas.

Por tanto, parece que tenemos un detector de líneas verticales.

¿Cómo podríamos conseguir uno de líneas horizontales?

kernel = np.array([[-1, -1, -1],
                   [ 0,  0,  0],
                   [+1, +1, +1]])
grad_v = signal.convolve2d(ascent, kernel, boundary='symm', mode='same')
plot_two(ascent, grad_v)

kernel = 1/9 * np.ones((3,3))
grad_v = signal.convolve2d(ascent, kernel, boundary='symm', mode='same')
plot_two(ascent, grad_v)

Estos son algunos de los kernels más utilizados en redes convolucionales tradicionales:

Vamos a ver los ejemplos nosotros mismos:

# Cargamos y mostramos la imagen original
url_img = 'https://upload.wikimedia.org/wikipedia/commons/5/50/Vd-Orig.png'
from urllib.request import urlopen 
from io import BytesIO
from PIL import Image
file = BytesIO(urlopen(url_img).read()) 
img = np.asarray(Image.open(file), dtype='uint8')
plt.imshow(img)
plt.axis('off')

(-0.5, 99.5, 99.5, -0.5)

def convolve3d(img, kernel):
  img_out = np.zeros(img.shape)
  for i in range(img.shape[-1]):
     img_out[:,:,i] = signal.convolve2d(img[:,:,i], kernel, boundary='symm', mode='same')
  return img_out.astype('uint8')

# Probamos con el kernel identidad
kernel = [[0, 0, 0],
         [0, 1, 0],
         [0, 0, 0]]
img_ki = convolve3d(img, kernel)
plot_two(img, img_ki)

También puedes contar con más ejemplos de convolución horizontal y vertical de strides para continuar practicando.

¿Cómo seguir aprendiendo del Big Data?

Ahora que conoces cómo funciona la convolución horizontal y vertical de strides, te aconsejamos continuar aprendiendo al respecto y ajustar este conocimiento a tu desenvolvimiento laboral.

De hecho, desde KeepCoding te ofrecemos nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Gracias a este, podrás aprender todo lo relacionado con las herramientas y lenguajes actuales y más populares del mundo del manejo de los macrodatos. ¡Inscríbete ahora mismo!