Redes Neurais Convolucionais

Material produzido para a disciplina de Redes Neurais Artificiais do curso de Engenharia de Computação e Software da Universidade Federal Rural do Semi-Árido (UFERSA). Professora: Rosana C. Rego.

As Redes Neurais Convolucionais (CNNs), também conhecidas como ConvNets, são uma classe especializada de redes neurais artificiais desenvolvidas especificamente para processar dados que possuem estrutura espacial ou temporal, com destaque especial para imagens, vídeos e sinais. Inspiradas na organização do córtex visual dos mamíferos, as CNNs revolucionaram o campo da visão computacional a partir de 2012, estabelecendo novos recordes em praticamente todas as tarefas relacionadas ao processamento de imagens.

Diferentemente das redes Perceptron multicamadas (MLPs), que tratam cada elemento de entrada de forma independente e requerem que a imagem seja "achatada" em um vetor unidimensional (descartando informações espaciais valiosas), as CNNs foram projetadas para preservar e explorar a estrutura espacial bidimensional dos dados. Essa característica fundamental permite que as CNNs reconheçam padrões locais como bordas, cantos, texturas e formas em diferentes regiões da imagem, construindo gradualmente representações cada vez mais complexas e abstratas.

Matematicamente, a operação completa de uma CNN pode ser vista como a composição de funções aplicadas sequencialmente em cada camada:

onde $\mathbf{X}$ é a imagem de entrada, $L$ é o número total de camadas, e cada $f^{(l)}$ representa uma camada que pode ser:

• Convolucional: Aplica filtros para extrair características locais
• Ativação: Introduz não-linearidade (ReLU, Sigmoid, etc.)
• Pooling: Reduz dimensionalidade e fornece invariância
• Densa (Fully Connected): Realiza classificação ou regressão final

Nas próximas seções, exploraremos em detalhes cada um desses componentes, entendendo não apenas o que fazem, mas também por que são necessários e como trabalham em conjunto para criar sistemas de visão computacional de alto desempenho.

Arquitetura da CNN

A arquitetura de uma Rede Neural Convolucional é cuidadosamente projetada para processar dados visuais de forma eficiente e hierárquica. Conforme ilustrado na figura abaixo, uma CNN típica é composta por uma sequência de camadas especializadas que trabalham em conjunto para transformar uma imagem bruta em uma predição útil (como a classe de um objeto).

O processo começa com a camada de entrada, que recebe a imagem original. Para imagens em escala de cinza, a entrada é uma matriz bidimensional de pixels onde cada valor representa a intensidade luminosa. Para imagens coloridas (RGB), a entrada é um tensor tridimensional com três canais (vermelho, verde e azul), cada um representando a intensidade de uma cor primária. As dimensões típicas são altura × largura × canais, por exemplo, 32×32×3 para uma imagem RGB de 32 pixels de lado.

Em seguida, essa imagem passa pela camada de convolução 2D (Conv2D), que é o coração de uma CNN. Nesta camada, múltiplos filtros (também chamados de kernels ou núcleos) são aplicados sobre a imagem para extrair características locais relevantes. Cada filtro é uma pequena matriz (tipicamente 3×3, 5×5 ou 7×7) que "desliza" pela imagem, realizando operações matemáticas que destacam padrões específicos como:

• Bordas verticais e horizontais: Transições abruptas de intensidade
• Cantos e vértices: Pontos de intersecção de bordas
• Texturas e padrões: Repetições regulares de estruturas
• Gradientes: Mudanças suaves de cor ou intensidade

Cada filtro produz um mapa de características (feature map) que indica onde e com que intensidade o padrão foi detectado. A camada convolucional é normalmente seguida por uma função de ativação não linear (como ReLU), que introduz a capacidade da rede de modelar relações complexas e não lineares nos dados.

Após a convolução e ativação, vem a camada de pooling (ou sub-amostragem), que desempenha um papel crucial na arquitetura. Esta camada tem dois objetivos principais:

1. Redução de dimensionalidade: Diminui o tamanho espacial dos mapas de características (por exemplo, de 32×32 para 16×16), reduzindo drasticamente o número de parâmetros e o custo computacional nas camadas seguintes.
2. Invariância espacial: Torna a rede mais robusta a pequenas translações, rotações e distorções na imagem. Se um padrão se mover ligeiramente, a rede ainda consegue reconhecê-lo.

A operação de pooling mais comum é o Max Pooling, que divide o mapa de características em regiões não sobrepostas (geralmente 2×2) e seleciona apenas o valor máximo de cada região, descartando os demais. Isso resume eficientemente a informação mais importante.

Essas três operações (convolução → ativação → pooling) são tipicamente repetidas várias vezes, formando blocos convolucionais empilhados. Cada novo bloco trabalha com representações mais abstratas: as primeiras camadas detectam bordas simples, as camadas intermediárias combinam bordas em formas, e as camadas mais profundas reconhecem objetos ou partes de objetos completos.

Após vários blocos convolucionais, a saída ainda possui estrutura espacial bidimensional (por exemplo, um tensor 4×4×256). Para conectar isso às camadas de classificação final, utilizamos a operação Flatten, que literalmente "achata" o tensor multidimensional em um vetor unidimensional. Por exemplo, um tensor 4×4×256 se torna um vetor de 4096 elementos (4 × 4 × 256 = 4096). Essa transformação não perde informação, apenas reorganiza os dados de forma linear.

Finalmente, o vetor achatado serve de entrada para uma ou mais camadas densamente conectadas (também chamadas de fully connected ou MLP - Multi-Layer Perceptron). Estas camadas finais combinam todas as características extraídas pelas camadas convolucionais para produzir a predição final. Por exemplo, em um problema de classificação com 10 classes, a última camada densa terá 10 neurônios, cada um representando a probabilidade de uma classe específica.

Camada de Convolução

Na camada convolucional, diversos filtros, ou kernels, são aplicados sobre a imagem de entrada. Cada filtro é uma pequena matriz que percorre a imagem realizando a operação de convolução: um produto escalar entre os valores do filtro e a região correspondente da imagem.

Seja a entrada da rede uma imagem ou tensor $\mathbf{X} \in \mathbb{R}^{H \times W \times C}$, onde $H$ e $W$ são a altura e largura da imagem, e $C$ o número de canais (por exemplo, 3 para imagens RGB). A operação de convolução consiste em aplicar um filtro $\mathbf{K} \in \mathbb{R}^{k_h \times k_w \times C}$ sobre a entrada para extrair características locais:

onde $i,j$ indicam a posição na saída da convolução. Para múltiplos filtros, a saída da camada convolucional será um tensor $\mathbf{Z} \in \mathbb{R}^{H' \times W' \times F}$, onde $F$ é o número de filtros.

Operação Tensorial em GPU

O estágio de convolução é amplamente paralelizado, especialmente em GPUs, que aceleram o processamento e o ajuste dos parâmetros da rede. A operação tensorial da convolução é dada por:

em que $Z_{i,j,k}$ é a saída da convolução no canal de saída $i$ na posição espacial $(j,k)$, $V_{l, j+m, k+n}$ representa o valor da entrada no canal $l$ na posição deslocada $(j+m,k+n)$, $K_{i,l,m,n}$ é o kernel multidimensional que relaciona o canal de entrada $l$ ao canal de saída $i$, $l$ percorre os canais de entrada, enquanto $m,n$ percorrem a área espacial do filtro.

Função de Ativação

Após a convolução, aplica-se uma função não linear elemento a elemento, geralmente a ReLU (Rectified Linear Unit). Essa função tem o papel crucial de introduzir não linearidade ao modelo.

A função ReLU é aplicada elemento a elemento nos mapas de características:

onde $f = 1, \ldots, F$ representa o índice do filtro, e $Z_{i,j,f}$ é o resultado da convolução na posição $(i,j)$ do filtro $f$.

Camada de Pooling

A camada de pooling, especialmente o max pooling, realiza uma redução espacial nos mapas de ativação. Essa operação divide o mapa em regiões menores (por exemplo, blocos 2×2) e seleciona o valor máximo de cada região.

No max pooling com janela $p \times p$ a seguinte operação matemática é realizada:

onde $A$ é o mapa de ativação de entrada e $P$ é a saída do pooling.

Downsampling

O stride é um parâmetro fundamental nas operações de convolução e pooling em redes CNNs. Ele define de quantos pixels a janela (filtro ou região de pooling) se desloca a cada passo ao percorrer a imagem ou o mapa de ativação.

Para reduzir o custo computacional e extrair características em múltiplas escalas, utiliza-se o downsampling, que pula posições na entrada ao aplicar o filtro, diminuindo a resolução da saída. A fórmula que inclui o passo (stride) $s$ é:

onde $s$ determina o intervalo entre as posições da janela de convolução.

Zero-Padding

Ao aplicar filtros nas bordas do tensor de entrada, perde-se informação porque o filtro não pode ultrapassar os limites. Para evitar a redução das dimensões, utiliza-se o zero-padding, que adiciona linhas e colunas de zeros ao redor do tensor, preservando o tamanho da entrada após a convolução.

Para manter o mesmo tamanho de saída com um filtro de tamanho $k$ e stride $s=1$:

Flatten

A operação Flatten realiza a transformação 2D para 1D. O tensor resultante do pooling é transformado em vetor unidimensional para ser processado pelas camadas densas.

A operação de flatten é definida como:

onde $d$ é o produto das dimensões restantes do tensor $\mathbf{P}$.

Camadas Densas

Além das camadas convolucionais, redes CNN incluem camadas densas, ou fully connected, em que a saída do flatten é processada por uma ou mais camadas densas dada por:

onde $\mathbf{h}^{(0)} = \mathbf{v}$, $\mathbf{W}^{(l)}$ e $\mathbf{b}^{(l)}$ são os pesos e vieses da camada $l$, e $\sigma$ é uma função de ativação (como ReLU ou Softmax).

Aplicações em Visão Computacional

Vamos implementar uma CNN completa para classificação de imagens usando o dataset CIFAR-10. Este exemplo prático demonstra todo o pipeline de uma aplicação real de visão computacional.

# ========================
# Importação de bibliotecas
# ========================
import os
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.model_selection import StratifiedShuffleSplit

# ========================
# Carregamento do dataset CIFAR-10
# ========================
(images_train, labels_train), (images_test, labels_test) = tf.keras.datasets.cifar10.load_data()

# ========================
# Normalização e conversão para escala de cinza
# ========================
images_train = images_train.astype('float32') / 255.0
images_test = images_test.astype('float32') / 255.0

# Conversão RGB para escala de cinza (Y = 0.299R + 0.587G + 0.114B)
images_train_gray = np.dot(images_train[...,:3], [0.299, 0.587, 0.114])
images_test_gray = np.dot(images_test[...,:3], [0.299, 0.587, 0.114])

# Expande a dimensão para canal único (necessário para entrada da rede)
images_train_gray = np.expand_dims(images_train_gray, -1)
images_test_gray = np.expand_dims(images_test_gray, -1)

# ========================
# Construção do modelo CNN
# ========================
model = tf.keras.models.Sequential([
    tf.keras.layers.BatchNormalization(input_shape=(32, 32, 1)),

    tf.keras.layers.Conv2D(64, (5, 5), padding='same', activation='elu'),
    tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2)),
    tf.keras.layers.Dropout(0.25),

    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Conv2D(128, (5, 5), padding='same', activation='elu'),
    tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
    tf.keras.layers.Dropout(0.25),

    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Conv2D(256, (5, 5), padding='same', activation='elu'),
    tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2)),
    tf.keras.layers.Dropout(0.25),

    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(256, activation='elu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10, activation='softmax')
])

# ========================
# Compilação e treinamento
# ========================
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Treinamento do modelo
history = model.fit(
    images_train_gray,
    labels_train,
    epochs=10,
    batch_size=128,
    validation_split=0.2,
    shuffle=True
)

# ========================
# Avaliação do modelo
# ========================
test_loss, test_accuracy = model.evaluate(images_test_gray, labels_test, verbose=0)
print(f"Accuracy no conjunto de teste: {test_accuracy * 100:.2f}%")

Exercícios

Exercício 1: Operação de Convolução Manual

Objetivo: Implementar a operação de convolução 2D sem usar bibliotecas prontas.

import numpy as np

def convolution_2d(input_matrix, kernel, stride=1, padding=0):
    """
    Implementa a operação de convolução 2D.
    
    Args:
        input_matrix: Matriz de entrada (H x W)
        kernel: Filtro de convolução (k_h x k_w)
        stride: Passo da convolução
        padding: Zero-padding aplicado
    
    Returns:
        feature_map: Mapa de características resultante
    """
    # TODO: Implementar a operação de convolução
    pass

# Teste sua implementação:
input_img = np.array([[1, 2, 3, 0],
                      [0, 1, 2, 3],
                      [3, 0, 1, 2],
                      [2, 3, 0, 1]])

edge_kernel = np.array([[-1, -1, -1],
                        [-1,  8, -1],
                        [-1, -1, -1]])

result = convolution_2d(input_img, edge_kernel)
print("Resultado da convolução:")
print(result)

Exercício 2: Max Pooling

Objetivo: Implementar a operação de max pooling.

def max_pooling_2d(input_matrix, pool_size=2, stride=2):
    """
    Implementa max pooling 2D.
    
    Args:
        input_matrix: Matriz de entrada
        pool_size: Tamanho da janela de pooling
        stride: Passo do pooling
    
    Returns:
        pooled_matrix: Matriz após pooling
    """
    # TODO: Implementar max pooling
    pass

# Teste:
test_matrix = np.array([[1, 3, 2, 4],
                        [5, 6, 1, 2],
                        [9, 7, 3, 6],
                        [4, 8, 2, 5]])

pooled = max_pooling_2d(test_matrix)
print("Resultado do max pooling:")
print(pooled)
# Resultado esperado: [[6, 4], [9, 6]]

Exercício 3: Análise de Dimensões

Objetivo: Calcular as dimensões de saída de uma CNN.

def calculate_conv_output_size(input_size, kernel_size, stride=1, padding=0):
    """
    Calcula o tamanho de saída de uma convolução.
    Formula: output_size = (input_size + 2*padding - kernel_size) / stride + 1
    """
    return (input_size + 2*padding - kernel_size) // stride + 1

def calculate_pool_output_size(input_size, pool_size, stride):
    """
    Calcula o tamanho de saída do pooling.
    """
    return input_size // stride

# TODO: Complete a análise das dimensões
print("Análise das dimensões:")
print("Entrada: 32x32x3")

# Após Conv1: 16 filtros 5x5, stride=1, padding='same'
# TODO: Calcular

# Após MaxPool1: 2x2, stride=2
# TODO: Calcular

# Continue para as demais camadas...

Exercício 4: CNN Simples com Keras

Objetivo: Construir e treinar uma CNN simples para classificação binária.

import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np

# Gerar dados sintéticos para classificação binária
def generate_synthetic_data(n_samples=1000):
    """
    Gera dados sintéticos: círculos vs quadrados
    """
    X = np.random.rand(n_samples, 28, 28, 1)
    y = np.random.randint(0, 2, n_samples)
    
    # TODO: Criar padrões mais realistas (círculos e quadrados)
    return X, y

# TODO: Implementar a arquitetura da CNN
def create_simple_cnn():
    model = models.Sequential([
        # TODO: Adicionar camadas convolucionais
        # layers.Conv2D(...),
        # layers.MaxPooling2D(...),
        # TODO: Adicionar mais camadas
        # layers.Flatten(),
        # layers.Dense(...),
    ])
    
    return model

# Treinar o modelo
X_train, y_train = generate_synthetic_data(800)
X_test, y_test = generate_synthetic_data(200)

model = create_simple_cnn()
# TODO: Compilar e treinar o modelo

Exercício 5: Análise de Filtros

Objetivo: Visualizar e analisar os filtros aprendidos por uma CNN.

import matplotlib.pyplot as plt

def visualize_filters(model, layer_name):
    """
    Visualiza os filtros de uma camada convolucional.
    
    Args:
        model: Modelo treinado
        layer_name: Nome da camada a visualizar
    """
    # TODO: Extrair os pesos da camada
    # TODO: Visualizar os filtros em uma grade
    pass

def analyze_feature_maps(model, input_image, layer_name):
    """
    Analisa os mapas de características de uma camada.
    
    Args:
        model: Modelo treinado
        input_image: Imagem de entrada
        layer_name: Nome da camada a analisar
    """
    # TODO: Criar modelo para extrair feature maps
    # TODO: Visualizar os mapas de características
    pass

# TODO: Implementar as funções de visualização

Exercício 6: Comparação de Arquiteturas

Objetivo: Comparar diferentes arquiteturas de CNN.

def create_simple_cnn():
    # TODO: Implementar CNN simples
    pass

def create_deep_cnn():
    # TODO: Implementar CNN profunda
    pass

def create_cnn_with_dropout():
    # TODO: Implementar CNN com dropout
    pass

def create_cnn_with_batch_norm():
    # TODO: Implementar CNN com batch normalization
    pass

def compare_architectures():
    """
    Treina e compara diferentes arquiteturas.
    """
    models = {
        'Simple': create_simple_cnn(),
        'Deep': create_deep_cnn(),
        'Dropout': create_cnn_with_dropout(),
        'BatchNorm': create_cnn_with_batch_norm()
    }
    
    results = {}
    
    for name, model in models.items():
        print(f"Treinando {name}...")
        # TODO: Treinar cada modelo
        # TODO: Avaliar performance
        # results[name] = {'accuracy': ..., 'loss': ...}
    
    return results

# TODO: Executar comparação e plotar resultados

Exercício 7: Data Augmentation

Objetivo: Implementar técnicas de aumento de dados.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

def create_data_augmentation():
    """
    Cria um gerador de aumento de dados.
    """
    datagen = ImageDataGenerator(
        # TODO: Configurar transformações
        # rotation_range=...,
        # width_shift_range=...,
        # height_shift_range=...,
        # horizontal_flip=...,
        # zoom_range=...,
    )
    
    return datagen

def compare_with_without_augmentation():
    """
    Compara performance com e sem data augmentation.
    """
    # TODO: Treinar modelo sem augmentation
    # TODO: Treinar modelo com augmentation
    # TODO: Comparar resultados
    pass

Exercício 8: Transfer Learning

Objetivo: Aplicar transfer learning usando um modelo pré-treinado.

from tensorflow.keras.applications import VGG16
from tensorflow.keras.applications.vgg16 import preprocess_input

def create_transfer_learning_model(num_classes=10):
    """
    Cria modelo usando transfer learning com VGG16.
    """
    # TODO: Carregar VGG16 pré-treinado
    # base_model = VGG16(weights='imagenet', include_top=False, ...)
    
    # TODO: Adicionar camadas de classificação
    # TODO: Configurar camadas treináveis
    
    pass

def fine_tune_model(model, train_data, val_data):
    """
    Fine-tuning do modelo pré-treinado.
    """
    # TODO: Implementar estratégia de fine-tuning
    # 1. Treinar apenas classificador
    # 2. Descongelar algumas camadas
    # 3. Treinar com learning rate menor
    pass

Curiosidades

📚 História das CNNs

🔢 Fatos Numéricos Impressionantes

🎯 Aplicações Surpreendentes

💡 Descobertas Científicas com CNNs

🤖 Limitações Curiosas

🔮 Futuro das CNNs

💰 Impacto Econômico

🎓 Pesquisadores Pioneiros