Redes neuronales convolucionales

Aprendizaje profundo intermedio con PyTorch

Michal Oleszak

Machine Learning Engineer

¿Por qué no utilizar capas lineales?

Un cuadrado negro que representa una imagen en escala de grises de 256 x 256 píxeles.

Aprendizaje profundo intermedio con PyTorch

¿Por qué no utilizar capas lineales?

Una imagen en escala de grises de 256 por 256 comprende alrededor de 65 000 valores de píxeles.

Aprendizaje profundo intermedio con PyTorch

¿Por qué no utilizar capas lineales?

Una capa lineal de 1000 neuronas procesa los valores de 65 000 píxeles.

Aprendizaje profundo intermedio con PyTorch

¿Por qué no utilizar capas lineales?

Hay 65 millones de conexiones entre la imagen y la capa.

Aprendizaje profundo intermedio con PyTorch

¿Por qué no utilizar capas lineales?

Con una imagen en color RGB, hay 200 m de conexiones.

Aprendizaje profundo intermedio con PyTorch

¿Por qué no utilizar capas lineales?

  • Capas lineales:
    • Entrenamiento lento
    • Sobreajuste
    • No reconoces los patrones espaciales.
  • Una alternativa mejor: ¡las capas convolucionales!

Imagen con un gato en la esquina y las neuronas leyendo esa parte de la imagen.

Aprendizaje profundo intermedio con PyTorch

Capa convolucional

El filtro de tamaño 3 por 3 se desliza sobre la entrada de tamaño 5 por 5 para producir un mapa de características de tamaño 3 por 3.

  • Desliza los filtros de parámetros sobre la entrada.
  • En cada posición, realiza la convolución.
  • Mapa de características resultante:
    • Conserva los patrones espaciales de la entrada.
    • Utiliza menos parámetros que la capa lineal.
  • Un filtro = un mapa de características
  • Aplicar activaciones a mapas de características
  • Todos los mapas de características combinados forman el resultado.
  • nn.Conv2d(3, 32, kernel_size=3)
Aprendizaje profundo intermedio con PyTorch

Convolución

Se multiplican entre sí dos matrices de 3 por 3 y se suman todos los números de la matriz resultante.

  1. Calcula el producto escalar del parche de entrada y el filtro.
    • Campo superior izquierdo: 2 × 1 = 2
  2. Suma el resultado.
Aprendizaje profundo intermedio con PyTorch

Zero-padding

Una imagen de 4 por 4 rodeada por un marco de píxeles con valor cero.

  • Añade un marco de ceros a la entrada de la capa convolucional.
nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)
  • Mantiene las dimensiones espaciales de los tensores de entrada y salida.
  • Garantiza que los píxeles de los bordes se traten igual que los demás.
Aprendizaje profundo intermedio con PyTorch

Agrupación máxima

Una matriz de 4 por 4 con cada cuarto marcado con un color diferente se convierte en una matriz de 2 por 2 después del agrupamiento máximo.

  • Desliza una ventana sin superposición sobre la entrada.
  • En cada posición, conserva solo el valor máximo.
  • Se utiliza después de capas convolucionales para reducir las dimensiones espaciales.
  • nn.MaxPool2d(kernel_size=2)
Aprendizaje profundo intermedio con PyTorch

Redes neuronales convolucionales

class Net(nn.Module):
    def __init__(self, num_classes):
        super().__init__()

        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
        )

        self.classifier = nn.Linear(64*16*16, num_classes)


    def forward(self, x):  
        x = self.feature_extractor(x)
        x = self.classifier(x)
        return x
  • feature_extractor: (convolución, activación, agrupación), repetido dos veces y aplanado
  • classifier: capa lineal única
  • forward(): pasar la imagen de entrada a través del extractor de características y el clasificador
Aprendizaje profundo intermedio con PyTorch

Tamaño de salida del extractor de características

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagrama esquemático que muestra cómo las imágenes de entrada de forma 3 por 64 por 64 pasan a través de una capa conv, una capa de agrupación, otra capa conv y otra capa de agrupación.

Aprendizaje profundo intermedio con PyTorch

Tamaño de salida del extractor de características

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagrama esquemático que muestra cómo las imágenes de entrada de forma 3 por 64 por 64 pasan a través de una capa conv, una capa de agrupación, otra capa conv y otra capa de agrupación.

Aprendizaje profundo intermedio con PyTorch

Tamaño de salida del extractor de características

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagrama esquemático que muestra cómo las imágenes de entrada de forma 3 por 64 por 64 pasan a través de una capa conv, una capa de agrupación, otra capa conv y otra capa de agrupación.

Aprendizaje profundo intermedio con PyTorch

Tamaño de salida del extractor de características

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagrama esquemático que muestra cómo las imágenes de entrada de forma 3 por 64 por 64 pasan a través de una capa conv, una capa de agrupación, otra capa conv y otra capa de agrupación.

Aprendizaje profundo intermedio con PyTorch

Tamaño de salida del extractor de características

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Diagrama esquemático que muestra cómo las imágenes de entrada de forma 3 por 64 por 64 pasan a través de una capa conv, una capa de agrupación, otra capa conv y otra capa de agrupación.

Aprendizaje profundo intermedio con PyTorch

¡Vamos a practicar!

Aprendizaje profundo intermedio con PyTorch

Preparing Video For Download...