Redes Neurais Convolucionais

Aprendizagem profunda intermediária com PyTorch

Michal Oleszak

Machine Learning Engineer

Por que não usar camadas lineares?

Um quadrado preto representando uma imagem em tons de cinza 256x256.

Aprendizagem profunda intermediária com PyTorch

Por que não usar camadas lineares?

Uma imagem em tons de cinza 256 por 256 tem cerca de 65 mil pixels.

Aprendizagem profunda intermediária com PyTorch

Por que não usar camadas lineares?

Uma camada linear com 1000 neurônios processa os ~65 mil pixels.

Aprendizagem profunda intermediária com PyTorch

Por que não usar camadas lineares?

Existem 65 milhões de conexões entre a imagem e a camada.

Aprendizagem profunda intermediária com PyTorch

Por que não usar camadas lineares?

Com uma imagem RGB, são 200 milhões de conexões.

Aprendizagem profunda intermediária com PyTorch

Por que não usar camadas lineares?

  • Camadas lineares:
    • Treino lento
    • Overfitting
    • Não captam padrões espaciais
  • Melhor alternativa: camadas convolucionais!

Imagem com um gato no canto e os neurônios lendo essa parte da imagem

Aprendizagem profunda intermediária com PyTorch

Camada convolucional

Filtro 3 por 3 desliza sobre entrada 5 por 5 para gerar um mapa de recursos 3 por 3.

  • Deslize filtro(s) de parâmetros sobre a entrada
  • Em cada posição, faça a convolução
  • Mapa de recursos resultante:
    • Preserva padrões espaciais da entrada
    • Usa menos parâmetros que camada linear
  • Um filtro = um mapa de recursos
  • Aplique ativações nos mapas
  • Todos os mapas combinados formam a saída
  • nn.Conv2d(3, 32, kernel_size=3)
Aprendizagem profunda intermediária com PyTorch

Convolução

Duas matrizes 3 por 3 são multiplicadas elemento a elemento e a soma é feita no resultado.

  1. Calcule o produto escalar do trecho da entrada com o filtro
    • Campo superior esquerdo: 2 × 1 = 2
  2. Some o resultado
Aprendizagem profunda intermediária com PyTorch

Zero-padding

Uma imagem 4 por 4 cercada por uma moldura de pixels com valor zero.

  • Adicione molduras de zeros à entrada da camada convolucional
nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)
  • Mantém as dimensões espaciais entre entrada e saída
  • Garante tratamento igual para pixels da borda
Aprendizagem profunda intermediária com PyTorch

Max pooling

Uma matriz 4 por 4, com cada quadrante 2 por 2 em cor diferente, vira 2 por 2 após max pooling.

  • Deslize janelas sem sobreposição sobre a entrada
  • Em cada posição, retenha só o valor máximo
  • Usado após convoluções para reduzir dimensões espaciais
  • nn.MaxPool2d(kernel_size=2)
Aprendizagem profunda intermediária com PyTorch

Rede Neural Convolucional

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: (convolução, ativação, pooling), repetido duas vezes e achatado
  • classifier: uma camada linear
  • forward(): passa a imagem pela extração de recursos e pelo classificador
Aprendizagem profunda intermediária com PyTorch

Tamanho da saída do extrator de recursos

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 mostrando como entradas 3 por 64 por 64 passam por uma conv, um pooling, outra conv e outro pooling.

Aprendizagem profunda intermediária com PyTorch

Tamanho da saída do extrator de recursos

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 mostrando como entradas 3 por 64 por 64 passam por uma conv, um pooling, outra conv e outro pooling.

Aprendizagem profunda intermediária com PyTorch

Tamanho da saída do extrator de recursos

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 mostrando como entradas 3 por 64 por 64 passam por uma conv, um pooling, outra conv e outro pooling.

Aprendizagem profunda intermediária com PyTorch

Tamanho da saída do extrator de recursos

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 mostrando como entradas 3 por 64 por 64 passam por uma conv, um pooling, outra conv e outro pooling.

Aprendizagem profunda intermediária com PyTorch

Tamanho da saída do extrator de recursos

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 mostrando como entradas 3 por 64 por 64 passam por uma conv, um pooling, outra conv e outro pooling.

Aprendizagem profunda intermediária com PyTorch

Vamos praticar!

Aprendizagem profunda intermediária com PyTorch

Preparing Video For Download...