TICS-579-Deep Learning

Clase 7: Redes Convolucionales

Alfonso Tobar-Arancibia

alfonso.tobar.a@edu.uai.cl

Limitaciones de las FFN

Número de Parametros:

• \(W_1 = 784 \cdot 256 + 256 = 200960\)
• \(W_2 = 256 \cdot 128 + 128 = 32896\)
• \(W_3 = 128 \cdot 10 + 10 = 1290\)
• Total = 235146.

¿Y si tengo una imágen de \(512 \times 512\)? 67,143,306 de parámetros.

Limitaciones de las FFN

Translation Invariance

Se refiere a la capacidad de poder detectar un patrón/objeto en diferentes posiciones de la imágen.

Las FFN no son capaces de ver patrones globales sino que se enfocan en el valor preciso de una feature. Si el objeto cambia de posición las features cambian a valores completamente distintos haciendo que la red tenga mayor tendencia al error.

Imágenes

Imagen

Definiremos una imágen como un Tensor de Tres dimensiones, en el cual se representa H, W y C (Altura, Ancho y Canales).

La convención más común es utilizar imágenes de 24-bits 3 canales de \(2^8\) valores (es decir 8-bits) que representan la intensidad de los colores Rojo (R), Verde (G) y Azul (B). Las dimensiones de \(H\) y \(W\) definen la resolución en píxeles de la imágen.

Imágenes

Para importar imágenes en Pytorch existen distintas librerías como PIL u OpenCV. Ambas usan la convención de \((H,W,C)\), la diferencia está en el orden de los canels. PIL utiliza la convención RGB, mientras que OpenCV utiliza BGR por lo que se necesitan algunas convenciones adicionales.

Lamentablemente la convención que escogió Pytorch es que una imágen tiene (C, H, W), es decir, primero canales, y luego alto y ancho. Normalmente las librerías no usan esta convención por lo que una permutación o transposición de dimensiones va a ser necesario casi la mayoría de las veces.

image = torch.tensor(...)

image[0,:,:]
imagen[0] # alternativa

image[1,:,:]
imagen[1] # alternativa

image[2,:,:]
imagen[2] # alternativa

Imágenes

Cuando tenemos un batch de imágenes entonces tendremos un Tensor de 4 dimensiones de dimensiones (N,C,H,W), donde \(N\) representa el Batch Size, \(C\) el número de Canales, \(H\) el alto y \(W\) el ancho.

Luego un Tensor de Dimensiones (32,3,224,512) implica que tenemos 32 imágenes RGB de dimensiones \(224\times512\).

Indexing

• Al tener tantas dimensiones elegir elementos se vuelve un poco complicado. En general se utilizarán sólo los primeros dos índices, el primero para escoger la imágen y el segundo para escoger el canal. En general Pytorch permite usar sólo el primer index y obviar el resto. Pero no permite hacer lo mismo con los siguientes.

Redes Convolucionales: Definición e Inspiración

Redes Convolucionales (CNN)

Son un tipo distinto de Redes Neuronales donde sus parámetros aprenden “feature maps” de los datos. Principalemente se aplican en imágenes, pero pueden aplicarse para secuencias unidimensionales o secuencias de imágenes (videos).

Existe el mito de que las Redes Convolucionales se inspiraron en el funcionamiento del Cortex Visual humano. No sé si es tan así.

¿Por qué necesitamos Redes Convolucionales? Evitar la sobreparametrización. ¿Por qué esto es un problema?

Timeline

• 1990: Yann LeCun et al. propone uno de los primeros intentos de CNN, el cual va agregando features más simples en features más complejas progresivamente.
• 1998: Yann LeCun, propone LeNet-5 con 2 redes convolucionales y 3 FFN.
• 2012: Alex Krizhevsky et al. propone AlexNet (5 capas convolucionales y 3 FFN), el cual obtiene SOTA performance en ImageNet.

Partes de una CNN

Convolución

Corresponde a una operación para extraer features maps en la cual un filtro o kernel se va desplazando en cada sección de los datos (secuencia, imagen o video).

Ojo

Esto es nuevamente un término marketero, porque no es una Convolucional real, sino una operación llamada Cross Correlation.

Feature Map

Corresponde a la salida de una convolución y es un nuevo tensor que captura ciertas características del dato (secuencia, imagen o video). Cuando se trata de imágenes normalmente es capaz de detectar bordes, cambios de textura, color, formas, o elementos más pequeños.

Es importante notar que los features maps son de una dimensionalidad menor a la entrada debido a la operación de Convolución.

Se obtendrán tantos feature maps como filtros se apliquen.

Entendiendo el Kernel

Gaussian Blur

Líneas Horizontales

Bordes

Kernel

El Kernel va a ser el set de parámetros que la red convolucional va a aprender. En palabras sencillas, la misma red aprende cuáles son los aspectos más relevantes de la imagen que le permitirán entender cómo clasificar o detectar elementos en ella.

El Kernel se aplica a todos los canales a la vez, lo cuál inicialmente lo hace ver como una operación bastante costosa computacionalmente.

El Kernel introduce el primer hiperparámetro de las CNN que es el Kernel Size. En general son cuadrados, y de dimensión impar.

Hiperparámetros de la Convolución

Stride

Corresponde a la cantidad de pasos en que se mueve el Kernel. Un stride más grande implica feature maps más pequeños y menos detalles. Strides más pequeños retiene más detalles, pero implica un mayor número de operaciones.

Padding

Corresponde a un relleno para dar mayor movimiento del kernel. Permite evitar la reducción de dimensionalidad por parte de la convolución además de considerar la información de los bordes de la imagen. Se llama “valid” a no usar padding, y “same” a agregar suficientes píxeles para evitar la reducción de dimensión.

Dilation

En este caso se tienen gaps al momento de aplicar el Kernel. Normalmente aplicar dilation aumenta el campo receptivo de la convolución capturando más contexto sin la necesidad de aumentar el kernel size. 1 implica sin dilation.

Convolución en Pytorch

nn.Conv2d(in_channels, out_channels, kernel_size, stride=1,padding=0,dilation=1)

Input

Este tipo de redes no requiere que se le den las dimensiones de la imagen, pero sí espera recibir tensores de dimensión \((N,C_{in}, H_{in},W_{in})\).

Output

La Red convolucional devuelve un Tensor de Dimensiones \((N,C_{out}, H_{out}, W_{out})\). Donde:

\[H_{out} = \left\lfloor \frac{H_{in} + 2 \cdot padding[0] - dilation[0]\cdot (kernel\_size[0] - 1) - 1}{stride[0]} + 1 \right\rfloor\] \[W_{out} = \left\lfloor \frac{W_{in} + 2 \cdot padding[1] - dilation[1]\cdot (kernel\_size[1] - 1) - 1}{stride[1]} + 1 \right\rfloor\]

Es importante tener noción del tamaño de la imagen para poder escoger un kernel_size que recorra la imagen completa y que no deje partes sin convolucionar.

Partes de una CNN: Pooling

Pooling

El Pooling es una operación de agregación que permite ir disminuyendo la dimensionalidad. De esta manera la red puede comenzar a especializarse en aspectos cada vez más finos.

El Pooling también se aplica de manera móvil como una convolución. Pero a diferencia de esta normalmente no genera traslape.

Acá se introduce otro hiperparámetro que es el Pooling Size. En general es cuadrado pero de dimensión par.

Pooling in Pytorch

nn.AvgPool2d(kernel_size, stride=None,padding=0)
nn.MaxPool2d(kernel_size, stride=None,padding=0, dilation=1)

Ojo

stride=None implica stride = kernel_size.

Importante mencionar que Average Pooling no permite Dilation.

\[H_{out} = \left\lfloor \frac{H_{in} + 2 \cdot padding[0] - dilation[0]\cdot (kernel\_size[0] - 1) - 1}{stride[0]} + 1 \right\rfloor\] \[W_{out} = \left\lfloor \frac{W_{in} + 2 \cdot padding[1] - dilation[1]\cdot (kernel\_size[1] - 1) - 1}{stride[1]} + 1 \right\rfloor\]

Arquitectura de una CNN

Feature Extractor - Encoder - Backbone

Corresponde al bloque de que generalmente contiene CNNs que se encargará de extraer features.

Flatten

Corresponde a una Operación Intermedia que dejará todos los píxeles de la imagen como un vector fila que puede ser tomado por la FFN.

Prediction Head - Head - MLP

Corresponde a una FFN que tomará las features aprendidas por la CNN y generará una predicción.

MNIST con CNN

• El número de Parámetros para una Red con muchas más capas bajó considerablemente, de 67M a 373K de Parámetros.

Variante en 1d

Conv1d

Corresponde a la variante de una dimensión, en la cual la entrada corresponden a secuencias de elementos como podrían ser series de tiempo, audio o hasta cadenas de texto.

En este caso la implementación en Pytorch es similar a la 2D sólo que esperando tensores de dimensiones \((N,C_{in}, L_{in})\), donde \(C_{in}\) corresponde al número de canales, que en el caso de series de tiempo equivale a features, y \(L_{in}\) corresponde al largo de la secuencia.

La salida de la Conv1d tendrá dimensiones \((N,C_{out},L_{out})\) con:

\[L_{out} = \left\lfloor \frac{L_{in} + 2 \cdot padding - dilation \cdot (kernel\_size - 1) - 1}{stride} + 1 \right\rfloor\]

Variante en 3d

Conv3d

Corresponde a la variante de tres dimensiones, en la cual la entrada corresponde a secuencias de imágenes, es decir, videos.

Este caso también es similar sólo que se esperan tensores de dimensiones \((N, C_{in}, D_{in}, H_{in}, W_{in})\) donde \(C_in\) corresponde al número de canales, \(D\) en el caso de un video corresponde al número de frames de tamaño \(H_{in} \times W_{in}\).

La salida de la Conv1d tendrá dimensiones \((N,C_{out},D_{out},H_{out},W_{out})\) con:

\[D_{out} = \left\lfloor \frac{D_{in} + 2 \cdot padding[0] - dilation[0] \cdot (kernel\_size[0] - 1) - 1}{stride[0]} + 1 \right\rfloor\] \[H_{out} = \left\lfloor \frac{H_{in} + 2 \cdot padding[1] - dilation[1]\cdot (kernel\_size[1] - 1) - 1}{stride[1]} + 1 \right\rfloor\] \[W_{out} = \left\lfloor \frac{W_{in} + 2 \cdot padding[2] - dilation[2]\cdot (kernel\_size[2] - 1) - 1}{stride[2]} + 1 \right\rfloor\]

Ejemplos de Arquitecturas

Class Dismissed