Convolución dilatada

Prerrequisito: Redes Neuronales Convolucionales

Convolución Dilatada: Es una técnica que expande el kernel (entrada) insertando huecos entre sus elementos consecutivos. En términos más simples, es lo mismo que la convolución pero implica la omisión de píxeles para cubrir un área más grande de la entrada. 

Un parámetro adicional l (factor de dilatación) indica cuánto se expande la entrada. En otras palabras, según el valor de este parámetro, (l-1) píxeles se omiten en el kernel. La figura 1 muestra la diferencia entre la convolución normal y la dilatada. En esencia, la convolución normal es solo una convolución dilatada de 1 .

Fig. 1: Convolución normal frente a convolución dilatada

Intuición: 

La convolución dilatada ayuda a expandir el área de la imagen de entrada cubierta sin agrupación. El objetivo es cubrir más información de la salida obtenida con cada operación de convolución. Este método ofrece un campo de visión más amplio al mismo costo computacional. Determinamos el valor del factor de dilatación ( l ) al ver cuánta información se obtiene con cada convolución en valores variables de l .  

Al usar este método, podemos obtener más información sin aumentar la cantidad de parámetros del kernel. En la figura 1 , la imagen de la izquierda muestra una convolución dilatada. Al mantener el valor de l = 2, saltamos 1 píxel ( l – 1 píxel) mientras mapeamos el filtro en la entrada, cubriendo así más información en cada paso. 

Fórmula involucrada: 

where,
F(s) = Input 
k(t) = Applied Filter
*l = l-dilated convolution
(F*lk)(p) = Output

Ventajas de la convolución dilatada:   

Usar este método en lugar de la convolución normal es mejor ya que: 

1. Campo receptivo más grande (es decir, sin pérdida de cobertura)
2. Computacionalmente eficiente (ya que proporciona una mayor cobertura con el mismo costo de cómputo)
3. Implementación de menor consumo de memoria (ya que omite el paso de agrupación)
4. Sin pérdida de resolución de la imagen de salida (ya que dilatamos en lugar de realizar la agrupación)
5. La estructura de esta convolución ayuda a mantener el orden de los datos. 

Implementación de código: 

import numpy as np
import tensorflow as tf
import sys
from  scipy.signal import convolve2d
 
np.random.seed(678)
tf.random.set_seed(6789)
sess = tf.compat.v1.Session()
 
# Initializing a 9x9 matrix of zeros.
mat_size = 9
matrix = np.zeros((mat_size,mat_size)).astype(np.float32)
 
# Assigning 1's in the middle of matrix
# to create a random input matrix
for x in range(4,7):
    for y in range(3,6):
        matrix[y,x] = 1
 
# Creating a random kernel for test
kernel = np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9]
]).astype(np.float32)
 
print("Original Matrix Shape : ",matrix.shape)
print(matrix)
print('\n')
print("Original kernel Shape : ",kernel.shape)
print(kernel)
 
# self-initializing a dilated kernel.
# ======[dilation factor = 3]======
dilated_kernel = np.array([
    [1,0,0,2,0,0,3],
    [0,0,0,0,0,0,0],
    [0,0,0,0,0,0,0],
    [4,0,0,5,0,0,6],
    [0,0,0,0,0,0,0],
    [0,0,0,0,0,0,0],
    [7,0,0,8,0,0,9]
])
 
print('\n')
print("Dilated kernel Shape : ",dilated_kernel.shape)
print(dilated_kernel)
 
print('\n')
print("DILATED CONVOLUTION RESULTS [Dilation Factor = 3]")
output = convolve2d(matrix,dilated_kernel,mode='valid')
print("Numpy Results Shape: ",output.shape)
print(output)

 Producción 

El siguiente resultado se obtiene del código anterior.  

Producción

La salida obtenida es para un factor de dilatación de 3. Para más experimentación, puede inicializar dilated_kernel con diferentes valores del factor de dilatación y observar los cambios en la salida obtenida.