Ajuste de Hiperparâmetros em Redes Neurais

Deep Learning: Ajuste de Hiperparâmetros em Redes Neurais
Aula 13
Laboratório de Práticas
Profª Maristela · TensorFlow/Keras · Experimentação Computacional

O que veremos hoje?
Nesta aula, exploraremos os principais hiperparâmetros que controlam o treinamento de redes neurais — e como ajustá-los de forma sistemática para obter o melhor desempenho.
01
Introdução aos Hiperparâmetros
O que são e por que importam
02
Learning Rate, Batch Size e Epochs
Os três pilares do treinamento
03
Experimentação Prática
Código base com TensorFlow/Keras
04
Comparação de Resultados
Análise e conclusões dos experimentos
O que são Hiperparâmetros?
Hiperparâmetros são configurações definidas pelo programador antes do início do treinamento da rede neural. Ao contrário dos parâmetros internos (pesos e bias), eles não são aprendidos automaticamente — precisam ser escolhidos com cuidado, pois exercem impacto direto no desempenho final do modelo.
⚡ Velocidade de Aprendizado
Quão rápido os pesos são atualizados a cada passo
📦 Volume de Dados
Quantidade de amostras processadas por vez
🔁 Ciclos de Treinamento
Número de vezes que o modelo vê os dados
🏗️ Arquitetura do Modelo
Camadas, neurônios, funções de ativação
Parâmetros vs. Hiperparâmetros
Compreender essa distinção é fundamental: parâmetros são o que a rede aprende; hiperparâmetros são o que nós, como engenheiros, definimos antes do treino.
A escolha adequada de hiperparâmetros pode ser tão decisiva quanto a própria arquitetura do modelo.
Taxa de Aprendizado
O learning rate determina o tamanho do passo dado pelo otimizador a cada atualização dos pesos — é talvez o hiperparâmetro mais crítico em Deep Learning.
Onde η é o learning rate e ∇J(θ) é o gradiente da função de perda.
Valores Comuns
0.1 — Aprendizado Rápido
Passos grandes; risco de instabilidade
0.01 — Equilibrado
Boa relação entre velocidade e estabilidade
0.001 — Mais Estável
Convergência mais lenta, porém consistente
0.0001 — Muito Conservador
Útil em ajustes finos (fine-tuning)
Impacto do Learning Rate no Treinamento
A escolha inadequada do learning rate é uma das causas mais comuns de falha no treinamento. Entender seus efeitos extremos é essencial para diagnosticar problemas.
🔺 Learning Rate Muito Alto
Os passos de atualização são grandes demais e o otimizador "ultrapassa" o mínimo da função de perda. Sintomas: loss oscila violentamente, acurácia não melhora, treinamento diverge.
✅ Learning Rate Ideal
O otimizador converge de forma suave e consistente em direção ao mínimo. Loss decresce progressivamente; acurácia sobe de forma estável. Ponto de equilíbrio a ser encontrado.
🔻 Learning Rate Muito Baixo
Passos minúsculos tornam o treinamento extremamente lento. O modelo pode ficar preso em mínimos locais ou nunca convergir dentro das épocas disponíveis.
Um learning rate inadequado pode desperdiçar horas de treinamento sem produzir resultados úteis.
Visualizando a Convergência
A função de perda descreve uma superfície no espaço de parâmetros. O processo de treinamento é uma descida por essa superfície — e o learning rate controla o tamanho de cada passo dessa descida.
Descida por Gradiente
O objetivo é minimizar a função de perda J(θ) iterativamente. Matematicamente, o comportamento pode ser ilustrado por funções de decaimento exponencial:
Um learning rate alto pula o mínimo; um baixo demais avança devagar demais. A curva ideal mostra redução constante e suave da perda a cada época.
Interpretação Prática
Curva de loss oscilando → learning rate alto demais
Curva de loss quase plana → learning rate baixo demais
Curva de loss decrescendo suavemente → configuração ideal
Batch Size — Tamanho do Lote
O batch size define quantas amostras o modelo processa antes de atualizar os pesos. É um compromisso entre velocidade de treinamento, uso de memória e qualidade da generalização.
16
Batch Pequeno
Mais ruído, melhor generalização
32
Batch Padrão
Equilíbrio entre velocidade e estabilidade
64
Batch Grande
Treinamento rápido, mais memória
128
Batch Muito Grande
Alta eficiência em GPU, risco de overfitting
Efeitos do Batch Size no Treinamento
A escolha do batch size afeta não apenas a velocidade, mas também a qualidade do aprendizado. Batches pequenos introduzem ruído útil; batches grandes trazem eficiência computacional.
A regra prática mais comum é começar com batch size = 32 e ajustar conforme os recursos disponíveis.
Epochs — Número de Épocas
Uma epoch representa uma passagem completa por todo o conjunto de dados de treinamento. Ao final de cada epoch, os pesos foram atualizados com base em todos os exemplos disponíveis.
Cada epoch = cada amostra vista uma vez pelo modelo.
Quantas Épocas Usar?
Não existe número mágico — depende do dataset, arquitetura e learning rate. Os extremos, porém, têm nomes conhecidos:
⚠️ Poucas Epochs → Underfitting
O modelo não aprendeu o suficiente; acurácia baixa tanto em treino quanto em validação.
⚠️ Muitas Epochs → Overfitting
O modelo memorizou os dados de treino; excelente em treino, fraco em dados novos.
Underfitting vs. Overfitting
Esses dois fenômenos são os principais inimigos de um modelo bem treinado. Reconhecê-los pelas curvas de treinamento é uma habilidade essencial do praticante de Deep Learning.
📉 Underfitting
O modelo é simples demais ou treinou por poucas epochs. Sintomas: acurácia baixa em treino e validação; curvas de loss altas e estagnadas. Solução: mais epochs, modelo maior ou learning rate maior.
🎯 Modelo Ideal
Boa acurácia em treino e validação. Curvas de loss próximas e decrescentes. O modelo generalizou o padrão sem memorizar ruídos.
📈 Overfitting
O modelo "decorou" os dados de treino. Sintomas: alta acurácia em treino, baixa em validação; divergência entre as curvas de loss. Solução: dropout, regularização ou menos epochs.
Monitore sempre as curvas de treino e validação em conjunto — elas contam histórias diferentes sobre o aprendizado.
Fluxo do Experimento de Laboratório
O laboratório segue um ciclo sistemático de experimentação. Cada iteração altera um hiperparâmetro por vez, permitindo isolar e medir seu impacto individual no desempenho.
Seguir esse fluxo garante reprodutibilidade e permite conclusões fundamentadas sobre o papel de cada hiperparâmetro no desempenho final do modelo.
Dataset Utilizado: MNIST
O MNIST (Modified National Institute of Standards and Technology) é um dos benchmarks mais clássicos de Deep Learning. Sua simplicidade e tamanho reduzido o tornam ideal para experimentos educacionais, permitindo treinar modelos rapidamente e observar o efeito dos hiperparâmetros com clareza.
70K
Imagens Total
60.000 treino + 10.000 teste
10
Classes
Dígitos de 0 a 9
28x28
Resolução
Pixels em escala de cinza
Código Base — Importações
Começamos importando as bibliotecas necessárias. O TensorFlow fornece o backend de computação; o Keras oferece a API de alto nível para construir e treinar modelos de forma intuitiva.
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Verificar versão instalada
print("TensorFlow version:", tf.__version__)
Certifique-se de ter o TensorFlow 2.x instalado. Use pip install tensorflow ou trabalhe no Google Colab, que já possui o ambiente configurado.
Carregando e Normalizando o Dataset
O Keras disponibiliza o MNIST diretamente via API. Após o carregamento, normalizamos os pixels dividindo por 255.0 — transformando valores de [0, 255] para [0.0, 1.0], o que melhora a estabilidade e a velocidade de convergência.
# Carregamento automático do MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Normalização dos pixels para o intervalo [0, 1]
x_train = x_train / 255.0
x_test  = x_test  / 255.0

print("Treino:", x_train.shape)   # (60000, 28, 28)
print("Teste: ", x_test.shape)    # (10000, 28, 28)
A normalização é uma etapa de pré-processamento essencial — redes neurais convergem muito mais rapidamente quando as entradas estão em uma escala reduzida e uniforme.
Construindo a Arquitetura da Rede
Usamos uma rede totalmente conectada (fully connected / MLP) com três camadas. O Flatten converte a imagem 28×28 em um vetor; a camada Dense com ReLU aprende representações intermediárias; o softmax final produz probabilidades para cada classe.
model = keras.Sequential([
    layers.Flatten(input_shape=(28, 28)),   # 784 entradas
    layers.Dense(128, activation='relu'),   # camada oculta
    layers.Dense(10, activation='softmax')  # 10 classes de saída
])

model.summary()  # Visualizar parâmetros totais
Flatten
784 neurônios de entrada
Dense (ReLU)
128 neurônios ocultos
Dense (Softmax)
10 saídas — uma por dígito
Configurando o Learning Rate
O otimizador Adam (Adaptive Moment Estimation) é amplamente recomendado por combinar as vantagens do RMSProp e do Momentum. O learning rate padrão do Adam é 0.001 — um bom ponto de partida para a maioria dos problemas.
optimizer = keras.optimizers.Adam(
    learning_rate=0.001   # ← altere aqui para experimentar
)

# Alternativas para experimentar:
# keras.optimizers.SGD(learning_rate=0.01)
# keras.optimizers.RMSprop(learning_rate=0.001)
Nos experimentos do laboratório, altere apenas o valor de
Compilando o Modelo
A etapa de compilação conecta o modelo ao otimizador, define a função de perda e especifica as métricas de avaliação. Para classificação multiclasse com labels inteiros, usamos sparse_categorical_crossentropy.
model.compile(
    optimizer=optimizer,
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)
Função de Perda
sparse_categorical_crossentropy é adequada quando os rótulos são inteiros (0–9), sem necessidade de one-hot encoding.
Métrica Principal
accuracy mede a proporção de predições corretas — métrica intuitiva e adequada para datasets balanceados como o MNIST.
Treinando o Modelo
O método model.fit() executa o treinamento. O parâmetro validation_split=0.2 separa automaticamente 20% dos dados de treino para validação, permitindo monitorar overfitting em tempo real.
history = model.fit(
    x_train, y_train,
    epochs=10,          # ← número de épocas
    batch_size=32,      # ← tamanho do lote
    validation_split=0.2
)

# Avaliar no conjunto de teste
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Acurácia no teste: {test_acc:.4f}")
O objeto history retornado armazena as métricas de cada epoch — use-o para plotar as curvas de aprendizado com matplotlib.
Configurações dos Experimentos
A tabela abaixo define quatro configurações para comparação sistemática. Cada experimento varia propositalmente um ou dois hiperparâmetros, permitindo analisar o impacto isolado ou combinado de cada um.
Registre todas as métricas de cada experimento antes de comparar. Anote também o tempo de treinamento — é um critério prático importante.
Comparação de Resultados
Após rodar os quatro experimentos, compare os resultados utilizando as quatro métricas abaixo. O objetivo não é encontrar o "melhor" número isolado, mas entender as trocas (trade-offs) entre os hiperparâmetros.
Accuracy
Proporção de predições corretas no conjunto de validação e teste. Métrica principal de comparação.
Loss
Valor da função de perda ao final do treino. Quanto menor, melhor — mas atenção à divergência entre treino e validação.
Tempo de Treinamento
Duração total em segundos. Importante para avaliar custo computacional de cada configuração.
Estabilidade
Consistência das curvas de loss e accuracy ao longo das epochs. Oscilações indicam instabilidade.
Discussão:
Com base nos experimentos realizados, reflita sobre as seguintes questões. Não existe resposta única — o objetivo é desenvolver intuição prática sobre o comportamento dos hiperparâmetros.
🏆 Qual configuração teve melhor accuracy?
O resultado foi o esperado dado o valor do learning rate? Batch size influenciou?
⚡ Qual treinou mais rápido?
A configuração mais rápida foi também a mais precisa? Vale o trade-off?
📈 Houve overfitting?
Algum experimento mostrou divergência entre a curva de treino e validação?
🔍 Como o LR influenciou?
A curva de loss foi mais suave com LR menor? Houve instabilidade com LR alto?
Atividade Prática — Desafio
Agora é a sua vez! Expanda os experimentos além das quatro configurações sugeridas. O objetivo é desenvolver senso crítico experimental: formule uma hipótese, teste-a e analise os resultados.
3 Learning Rates
Teste ao menos 0.1, 0.01 e 0.0001 além do 0.001 padrão
2 Batch Sizes
Compare um batch pequeno (16) com um grande (128) mantendo o LR fixo
Variação de Epochs
Experimente 5, 15 e 30 epochs para observar under e overfitting
Tabela Comparativa
Registre accuracy, loss e tempo de treino para cada configuração
📋 Produto Final — Entrega
O relatório deve ser entregue via formulário da disciplina até o prazo estabelecido. Priorize a análise crítica sobre a quantidade de experimentos.
Estrutura do Relatório
1
Configurações Utilizadas
Tabela com todos os valores de LR, batch size e epochs testados
2
Evidências Visuais
Prints das curvas de loss/accuracy e outputs do terminal
3
Comparação das Métricas
Tabela com accuracy, loss e tempo de cada experimento
4
Conclusão da Equipe
Qual configuração foi mais eficiente e por quê?
Síntese da Aula
Os hiperparâmetros são os controles fundamentais do treinamento de redes neurais. Não existe fórmula mágica — o que existe é método, observação e iteração constante.
✔ Hiperparâmetros São Decisivos
Learning rate, batch size e epochs influenciam diretamente a velocidade, estabilidade e qualidade do aprendizado do modelo.
✔ Não Existe Configuração Universal
A configuração ideal varia com o dataset, a arquitetura e os recursos computacionais disponíveis. Sempre contextualize.
✔ Experimentação é o Caminho
Praticantes de Deep Learning desenvolvem intuição por meio de muitos experimentos controlados, análise de curvas e iteração sistemática.
Parabéns por concluir a Aula 13! Na próxima aula, exploraremos técnicas de regularização para combater o overfitting de forma sistemática.
Laboratório — Ajuste de Hiperparâmetros
Atividade para Entregar
Compare o desempenho de diferentes configurações de hiperparâmetros em redes neurais usando TensorFlow/Keras. Trabalhe em equipe, divida os experimentos e consolide os resultados em um único relatório.
1
Implementar o Modelo Base
Use o código fornecido na aula como ponto de partida
2
Executar os 4 Experimentos
Seguir as configurações A, B, C e D da tabela
3
Explorar Configurações Extras
Ao menos 3 LRs, 2 batch sizes e variações de epochs
4
Redigir o Relatório Final
Tabela, evidências, comparação e conclusão da equipe