Teoria

Introdução às CNNs

O que são Redes Neurais Convolucionais?

As Redes Neurais Convolucionais (CNNs) são um tipo de rede neural artificial, projetada para processar dados que possuem uma estrutura topológica similar a uma grade, como:

Aplicações comuns:

• Classificação e segmentação de imagens
• Reconhecimento facial e detecção de objetos
• Análise de sinais e séries temporais
• Bioinformática (motivos em DNA/RNA)

Vantagens sobre MLPs

Aspecto	MLP	CNN
Parâmetros	Crescem explosivamente	Muito menos (filtros reutilizados)
Estrutura espacial	Perdida	Preservada
Robustez a deslocamentos	Baixa	Maior (quase invariante a translação)
Compartilhamento de pesos	Não	Sim
Escalabilidade em visão	Limitada	Alta

Arquitetura Geral de uma CNN

Fundamentos Matemáticos

Convolução (Intuição)

A convolução mede o alinhamento entre um pequeno padrão (kernel) e regiões da entrada.

Convolução Contínua:

(f * g)(t) = ∫_{-∞}^{∞} f(τ)g(t-τ)dτ

Convolução Discreta (usada em CNNs):

(f * g)[n] = Σ_{m=-∞}^{∞} f[m]g[n-m]

Convolução 2D para Imagens

Em visão usamos, tecnicamente, correlação cruzada (não invertendo o kernel), mas chamamos de convolução por convenção.

S(i,j) = (I * K)(i,j) = ΣΣ I(i+m, j+n) × K(m,n)
                        m n

Onde:

• I: Imagem de entrada
• K: Kernel (filtro)
• S: Feature map (mapa de características)

Exemplo Prático de Convolução

Imagem 5×5:

1  2  3  0  1
0  1  2  3  1
1  0  1  2  0
2  1  0  1  2
1  0  2  1  0

Kernel 3×3 (Detector de Borda):

-1 -1 -1
-1  8 -1
-1 -1 -1

Resultado (Feature Map):

Posição (1,1): (-1×1) + (-1×2) + (-1×3) + (-1×0) + (8×1) + (-1×2) + (-1×1) + (-1×0) + (-1×1) = -5

Parametros da Camada Convolucional

1. Kernel/Filtro

• Tamanho: Normalmente 3×3, 5×5, 7×7
• Profundidade do kernel: Igual à profundidade da entrada
• Nº de filtros: Hyperparâmetro (32, 64, 128, 256...)
• Pesos: Aprendidos durante treinamento

2. Stride (Passo)

• Definição: Quantos pixels o kernel "pula" a cada operação
• Stride = 1: Sobreposição máxima
• Stride = 2: Reduz dimensão pela metade

3. Padding (Preenchimento)

• Valid: Sem padding (saída menor)
• Same: Padding para manter dimensão
• Causal: Para dados sequenciais

Efeito de padding='valid' com kernel 3×3 e stride=1 em H×W?

Aumenta tamanho

Reduz 2 pixels (1 por borda)

Não altera

Dobra dimensões

Submit

Sem padding, a janela não cobre bordas externas totalmente, reduzindo largura e altura em 1 de cada lado.

Principal efeito de stride=2 em convolução?

Aumentar resolução espacial

Diminuir resolução e custo computacional

Substituir função de ativação

Tornar o kernel maior

Submit

Stride>1 “pula” posições, gerando feature maps menores e operação mais barata.

Tipos de Convoluções

Convolução Standard

# Exemplo com TensorFlow/Keras
layers.Conv2D(filters=32, kernel_size=(3,3), stride=(1,1), padding='same')

Convolução Depthwise Separable

layers.SeparableConv2D(filters=32, kernel_size=(3,3))

- Vantagem: Menos parâmetros (~9x redução) - Uso: MobileNets, Xception

Convolução Dilatada (Atrous)

layers.Conv2D(filters=32, kernel_size=(3,3), dilation_rate=(2,2))

- Vantagem: Campo receptivo maior sem perder resolução - Uso: Segmentação semântica

Convolução Transposta (Deconvolução)

layers.Conv2DTranspose(filters=32, kernel_size=(3,3), strides=(2,2))

- Uso: Upsampling, GANs, Autoencoders

Visualização da Convolução

CNN – Convolução, Ativação e Pooling (interativo)

Entrada (28×28) Limpar Ruído Demo “7”

Dica: desenhe com o mouse (clique e arraste). A imagem é 28×28, mostrada ampliada.

Kernel

Identity Blur (Box) Sharpen Edge (Laplacian) Sobel X Sobel Y Emboss Custom (3×3)

Kernel 3×3 (Custom):

Padding

same valid

Stride

Ativação

None ReLU

Pooling

None Max 2×2 (s=2) Avg 2×2 (s=2)

Aplicar Reset kernel

Saídas:

Conv: — • Pool: —

Resumo: —

Feature map (após conv/ativação)

Pooling (veremos a seguir)

Pooling e Subsampling

Diminui tamanho dos feature maps alem de permitir que pequenas translações não afetem resultado, ajuda na redução de overfitting e acelera o processamento.

Max Pooling

layers.MaxPool2D(pool_size=(2,2), strides=(2,2))

Mantém o valor mais forte (presença de padrão).

Average Pooling

Suaviza (média local), diluindo picos.

layers.AveragePooling2D(pool_size=(2,2))

Global Average Pooling

Resume cada feature map em um único número. Substitui densas finais, reduz parâmetros.

layers.GlobalAveragePooling2D()

Diferença essencial Max vs Average Pooling?

Max reduz canais, Average aumenta canais

Max preserva picos; Average suaviza respostas

Average não é diferenciável

São iguais em prática

Submit

Max enfatiza presença; Average enfatiza contexto médio.

Batch Normalization

A Batch Normalization é uma técnica que normaliza as ativações de uma camada, mantendo a média próxima de 0 e o desvio padrão próximo de 1.

• Acelera o treinamento
• Reduz a sensibilidade à inicialização dos pesos
• Permite usar taxas de aprendizado maiores
• Atua como uma forma leve de regularização

Saiba mais em: https://machinelearningmastery.com/batch-normalization-for-training-of-deep-neural-networks/

layers.BatchNormalization()

Dropout

O Dropout é uma técnica de regularização que desativa aleatoriamente uma fração dos neurônios durante o treinamento. Isso força a rede a não depender de neurônios específicos, promovendo robustez e generalização. Utilize dropout principalmente em redes densas (fully connected).

• Reduz o overfitting
• Simples de implementar
• Funciona bem em redes densas e convolucionais

layers.Dropout(0.5)  # desativa 50% dos neurônios durante o treinamento

Saiba mais em: https://www.deeplearningbook.com.br/capitulo-23-como-funciona-o-dropout/

Arquiteturas Clássicas de CNN

LeNet-5 (1998) - Yann LeCun

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense

model = Sequential([
    Conv2D(6, (5,5), activation='tanh', input_shape=(32,32,1)),
    AveragePooling2D((2,2)),
    Conv2D(16, (5,5), activation='tanh'),
    AveragePooling2D((2,2)),
    Flatten(),
    Dense(120, activation='tanh'),
    Dense(84, activation='tanh'),
    Dense(10, activation='softmax')
])

AlexNet (2012) - Alex Krizhevsky

Primeira grande vitória em ImageNet: ReLU em larga escala, Dropout, Data Augmentation pesado, uso de múltiplas GPUs.

Note

A AlexNet foi um marco pois provou que CNNs profundas funcionavam em datasets massivos e impulsionou a revolução do Deep Learning.

VGGNet (2014) - Oxford

Convoluções pequenas (blocos de conv 3×3 + pooling) e profundas (16/19 camdas).

# Bloco 1
Conv2D(64, (3,3), activation='relu', padding='same')
Conv2D(64, (3,3), activation='relu', padding='same')
MaxPooling2D((2,2), strides=(2,2))

# Bloco 2
Conv2D(128, (3,3), activation='relu', padding='same')
Conv2D(128, (3,3), activation='relu', padding='same')
MaxPooling2D((2,2), strides=(2,2))

# ... continua com blocos similares

ResNet (2015) - Microsoft Research

Resolveu o problema da degradação em redes muito profundas com Conexões Residuais (Skip Connections).

def residual_block(x, filters):
    shortcut = x

    x = Conv2D(filters, (3,3), padding='same')(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    x = Conv2D(filters, (3,3), padding='same')(x)
    x = BatchNormalization()(x)

    x = Add()([x, shortcut]) # concatena
    x = Activation('relu')(x)

    return x

Conexões residuais ajudam principalmente a:

Diminuir o uso de GPU

Facilitar fluxo de gradiente em redes profundas

Remover necessidade de normalização

Eliminar funções de ativação

Submit

O atalho preserva sinais e gradientes, mitigando o problema de degradação.