Fundamentos

Visão geral: o que significa “treinar uma rede neural”

O treinamento (training) de uma rede neural (neural network) é o processo de encontrar parâmetros (parameters) (pesos (weights) e vieses (biases)) que façam as previsões do modelo (model) corresponderem aos alvos desejados (targets) (rótulos (labels)) ou otimizem um objetivo auto-supervisionado (self-supervised objective). A maior parte do treinamento moderno em aprendizado profundo (deep learning) segue um padrão comum:

  1. Definir um modelo (f_\theta(x)) com parâmetros (\theta)
  2. Escolher um objetivo (uma função de perda (loss function)) (L(\theta)) que pontue quão bom é o modelo
  3. Calcular gradientes (\nabla_\theta L) via diferenciação (differentiation)
  4. Atualizar parâmetros usando um otimizador (optimizer) (variantes de descida do gradiente (gradient descent))
  5. Repetir sobre os dados até que o desempenho seja satisfatório

Este artigo cobre os componentes centrais por trás desse ciclo—o que eles fazem, como interagem e o que você precisa, na prática, para tornar o treinamento estável e eficaz.

Para um contexto mais amplo, veja Redes Neurais. Para os detalhes das atualizações baseadas em gradiente, veja Descida do Gradiente.

As peças centrais de um sistema de treinamento

1) Dados: entradas, alvos e o pipeline de dados

Redes neurais aprendem padrões a partir de exemplos. A forma e a qualidade do pipeline de dados (data pipeline) muitas vezes importam tanto quanto a arquitetura (architecture).

Conceitos-chave:

  • Divisão do conjunto de dados: tipicamente treino, validação e teste
    • Conjunto de treinamento: usado para calcular gradientes e atualizar parâmetros
    • Conjunto de validação: usado para ajustar hiperparâmetros e escolher pontos de verificação (checkpoints)
    • Conjunto de teste: usado uma vez no final para relato sem viés
  • Mini-lotes (mini-batches): o treinamento usa lotes pequenos (por exemplo, 32–4096 exemplos) por eficiência e por estimativas de gradiente ruidosas que frequentemente generalizam melhor.
  • Embaralhamento (shuffling): reduz a correlação entre lotes consecutivos, melhorando a estabilidade do treinamento.
  • Pré-processamento (preprocessing):
    • Normalização/padronização (normalization/standardization) (por exemplo, pixels de imagens para ([0,1]), ou normalização por média/desvio padrão)
    • Tokenização (tokenization) para modelos de linguagem
    • Tratamento de valores ausentes para dados tabulares (tabular data)
  • Aumento de dados (data augmentation): altera as entradas sem alterar os rótulos (por exemplo, recortes e espelhamentos em imagens) para melhorar a generalização.

Exemplo prático (conceitual):

  • Em classificação de imagens, você pode recortar e espelhar imagens aleatoriamente durante o treinamento, mas usar um recorte central fixo na validação/teste para medir desempenho de forma consistente.

Aumento e desenho do conjunto de dados se conectam diretamente à generalização e podem ser vistos como um tipo de regularização (regularization); veja Regularização.

2) Modelo: arquitetura e parâmetros

Uma rede neural é uma função parametrizada (f_\theta) composta por camadas (layers). O treinamento ajusta (\theta) para minimizar a perda.

Ingredientes típicos:

  • Transformações lineares (linear transformations) (multiplicação de matriz + viés)
  • Ativações não lineares (nonlinear activations) como ReLU, GELU, sigmoid
  • Estrutura opcional: convolução (convolution), atenção (attention), recorrência (recurrence), normalização (normalization) etc.

As escolhas aqui controlam:

  • Capacidade (capacity) (quão complexa é a função que o modelo pode representar)
  • Viés indutivo (inductive bias) (que tipos de padrões o modelo “prefere”)
  • Comportamento de otimização (optimization behavior) (quão fácil é treinar)

Funções de ativação e cabeças de saída (output heads) estão fortemente acopladas à perda; veja Ativações e Perdas.

3) Objetivo: funções de perda e o que elas otimizam

Uma função de perda transforma saídas do modelo em um objetivo escalar que o treinamento tenta minimizar.

Exemplos supervisionados comuns:

  • Classificação: perda de entropia cruzada (cross-entropy loss) sobre logits (logits) de softmax (softmax)
  • Regressão: erro quadrático médio (MSE, mean squared error), erro absoluto médio (MAE, mean absolute error), perda de Huber (Huber loss)

A função de perda tipicamente inclui:

  • Um termo de dados (ajustar os exemplos de treinamento)
  • Termos de regularização opcionais (por exemplo, decaimento de pesos (weight decay))

Exemplo: entropia cruzada com softmax para um único exemplo com logits (z) e classe verdadeira (y): [ L = -\log \frac{e^{z_y}}{\sum_k e^{z_k}} ]

No aprendizado auto-supervisionado (self-supervised learning), “alvos” podem ser gerados a partir das entradas (tokens mascarados, pares contrastivos etc.). Veja Aprendizado Auto-Supervisionado para entender como objetivos são construídos sem rótulos.

4) Grafos computacionais, diferenciação automática e gradientes

Para atualizar parâmetros, precisamos de derivadas da perda em relação a cada parâmetro: (\nabla_\theta L).

Frameworks modernos (PyTorch, JAX, TensorFlow) constroem um grafo computacional (computation graph) de operações e aplicam diferenciação automática (automatic differentiation) (diferenciação automática (autodiff)) para calcular gradientes de forma eficiente.

  • Passagem para frente (forward pass): calcular previsões e perda
  • Passagem para trás (backward pass): calcular gradientes em relação aos parâmetros

A maior parte do aprendizado profundo usa diferenciação automática em modo reverso (reverse-mode autodiff), que é eficiente quando a saída é uma perda escalar e os parâmetros são muitos.

Veja:

5) Otimização: transformando gradientes em atualizações de parâmetros

A regra de atualização mais simples é a descida do gradiente: [ \theta \leftarrow \theta - \eta \nabla_\theta L ] onde (\eta) é a taxa de aprendizado (learning rate).

Na prática, quase todo treinamento usa variantes como:

  • SGD com momentum
  • Adam / AdamW
  • Métodos adaptativos com taxas de aprendizado por parâmetro

Otimizadores diferem em velocidade de convergência, estabilidade, sensibilidade a hiperparâmetros e comportamento de generalização.

Veja Otimizadores para trade-offs práticos e padrões recomendados.

6) Hiperparâmetros: os “botões” que controlam o treinamento

Hiperparâmetros importantes incluem:

  • Taxa de aprendizado (o mais importante)
  • Tamanho do lote (batch size)
  • Configurações do otimizador (momentum, betas, epsilon)
  • Decaimento de pesos / força de regularização
  • Número de passos de treinamento / épocas (epochs)
  • Agendamento da taxa de aprendizado (learning rate schedule) (aquecimento (warmup), decaimento cosseno (cosine decay), decaimento em degraus (step decay))
  • Esquema de inicialização (initialization) e escolhas de normalização

Alguns deles são “adjacentes à arquitetura” (inicialização, normalização), mas afetam fortemente a dinâmica do treinamento:

O loop de treinamento padrão (conceitual e prático)

Loop conceitual

Em alto nível, o treinamento repete:

  1. Amostrar um mini-lote ((x, y))
  2. Calcular previsões (\hat{y} = f_\theta(x))
  3. Calcular a perda (L(\hat{y}, y))
  4. Calcular gradientes (\nabla_\theta L)
  5. Atualizar parâmetros usando um otimizador
  6. Avaliar periodicamente em dados de validação

Exemplo prático: um passo mínimo de treinamento em PyTorch

Abaixo está um esqueleto típico de loop de treinamento supervisionado (classificação). Ele omite treinamento distribuído (distributed training) e muitos detalhes de produção, mas inclui os componentes essenciais.

import torch
import torch.nn as nn
import torch.optim as optim

model = MyModel()
criterion = nn.CrossEntropyLoss()

# AdamW is a common default for modern networks
optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-2)

model.train()
for x, y in train_loader:
    optimizer.zero_grad(set_to_none=True)

    logits = model(x)              # forward pass
    loss = criterion(logits, y)    # scalar objective

    loss.backward()                # backward pass (autodiff)
    optimizer.step()               # parameter update

O que está acontecendo aqui:

  • model(x) constrói um grafo computacional de passagem para frente.
  • loss.backward() calcula gradientes para todos os parâmetros que contribuíram para a perda.
  • optimizer.step() aplica a regra de atualização escolhida (por exemplo, AdamW).

Adições típicas em treinamentos reais:

  • Clipping de gradiente (gradient clipping) (estabilidade)
  • Agendamentos de taxa de aprendizado
  • Precisão mista (mixed precision) (velocidade)
  • Acumulação de gradientes (gradient accumulation) (simular tamanhos de lote maiores)
  • Média móvel exponencial (EMA, exponential moving average) dos pesos (às vezes melhora a estabilidade na avaliação)

Estabilidade do treinamento: por que a otimização às vezes falha

Redes neurais são otimizadas com objetivos estocásticos e não convexos. Embora frequentemente funcionem de maneira notavelmente boa, o treinamento pode falhar ou se tornar instável.

Gradientes que desaparecem e gradientes explosivos

Redes profundas podem sofrer com gradientes que:

  • Desaparecem: ficam pequenos demais para aprender camadas iniciais
  • Explodem: ficam grandes demais, causando divergência ou NaNs

Mitigações incluem:

  • Inicialização adequada
  • Camadas de normalização (BatchNorm, LayerNorm, RMSNorm)
  • Conexões residuais (residual connections)
  • Clipping de gradiente
  • Ajuste da taxa de aprendizado

Veja Problemas de Gradiente e Inicialização e Normalização.

Taxa de aprendizado e agendamentos: a causa raiz mais comum

Se o treinamento diverge, o primeiro suspeito geralmente é a taxa de aprendizado:

  • Alta demais: a perda vira NaN ou explode
  • Baixa demais: o treinamento é extremamente lento ou fica travado

Agendamentos frequentemente são essenciais:

  • Aquecimento evita instabilidade inicial (especialmente para Transformers (Transformers))
  • Decaimento cosseno é um padrão comum para execuções longas
  • Decaimento em degraus é comum em receitas clássicas de visão

Veja Agendamentos de Taxa de Aprendizado.

Escalonamento da perda, logits e estabilidade numérica

Muitas falhas são, na verdade, numéricas:

  • Softmax sobre logits muito grandes pode causar overflow sem implementações estáveis
  • Precisão mista pode causar underflow nos gradientes (mitigado por escalonamento dinâmico da perda (dynamic loss scaling))
  • Entradas mal escaladas podem produzir ativações saturantes (saturating activations) (por exemplo, sigmoid)

Primitivas do framework geralmente usam versões numericamente estáveis (por exemplo, CrossEntropyLoss combina log-softmax + perda NLL de forma estável), mas código customizado exige cuidado.

Generalização: perda de treinamento vs desempenho real

Um modelo pode minimizar a perda de treinamento e ainda assim performar mal em dados novos. Essa lacuna é o problema de generalização.

Ferramentas comuns para melhorar a generalização:

  • Regularização
    • Decaimento de pesos (especialmente decaimento de pesos desacoplado no estilo AdamW)
    • Dropout
    • Suavização de rótulos (label smoothing) (classificação)
  • Aumento de dados
  • Parada antecipada (early stopping) com base em métricas de validação
  • Ensemblagem (ensembling) ou pesos de média móvel exponencial (melhorias no momento da avaliação)

Veja Regularização.

Observe também a relação com características aprendidas e embeddings (embeddings): uma configuração de treinamento que generaliza tipicamente aprende representações reutilizáveis; veja Aprendizado de Representações.

Avaliação e métricas: sabendo o que otimizar

A perda é o que você otimiza, mas métricas são o que importa.

Exemplos:

  • Classificação: acurácia, acurácia top-k, F1, AUROC
  • Regressão: RMSE, MAE, (R^2)
  • Modelagem de linguagem: perplexidade (perplexity)
  • Recuperação/embedding: recall@k, NDCG

Boas práticas:

  • Acompanhe tanto a perda de treinamento quanto as métricas de validação
  • Observe sobreajuste (overfitting): o treinamento melhora enquanto a validação piora
  • Garanta que as métricas combinem com o objetivo do produto (por exemplo, AUROC vs acurácia para conjuntos de dados desbalanceados)

Checklist prático de depuração (modos de falha comuns)

Quando o treinamento não funciona, a causa muitas vezes é corriqueira. Um checklist sistemático economiza tempo.

Sintomas e causas prováveis

  • A perda é NaN / Inf
    • Taxa de aprendizado alta demais
    • Instabilidade de precisão mista (tente precisão total ou escalonamento dinâmico da perda)
    • Normalização ruim / gradientes explosivos (tente clipping de gradiente)
  • A perda não diminui de jeito nenhum
    • Taxa de aprendizado baixa demais
    • Rótulos errados / bug no pipeline de dados
    • Saídas do modelo incompatíveis com a perda (por exemplo, usar softmax antes de CrossEntropyLoss)
    • Parâmetros congelados sem intenção
  • Acurácia de treinamento alta, validação baixa
    • Sobreajuste: adicione aumento/regularização, reduza a capacidade, pare antecipadamente
    • Descasamento de distribuição entre treino/val
  • Curvas de treinamento instáveis ou muito ruidosas
    • Tamanho do lote pequeno demais
    • Taxa de aprendizado alta demais
    • Problemas na ordem dos dados, embaralhamento insuficiente

Um “teste de sanidade”: sobreajustar um lote minúsculo

Uma técnica clássica:

  1. Pegue 32–256 exemplos.
  2. Treine até que o modelo quase os memorize (perda muito baixa).
  3. Se ele não conseguir, provavelmente há um bug no modelo, na perda ou no pipeline de dados.

Esse teste isola a correção da otimização das preocupações com generalização.

Noções básicas de escalonamento: computação, tamanho do lote e vazão

Mesmo em pequena escala, ajuda entender o que determina a velocidade do treinamento:

  • Custo de computação cresce com o tamanho do modelo, o comprimento de sequência (para Transformers) e o tamanho do lote.
  • Tamanho do lote afeta tanto a otimização quanto a vazão (throughput):
    • Lotes maiores melhoram o uso do hardware, mas podem exigir ajuste da taxa de aprendizado.
    • Lotes muito grandes podem reduzir a generalização a menos que haja compensação (por exemplo, com agendamentos ou regularização).
  • Precisão mista (FP16/BF16) frequentemente acelera o treinamento de forma significativa em GPUs modernas.

Para práticas de engenharia em treinamento distribuído e modelos grandes, veja Treinamento em Escala.

Como os “Básicos” se conectam ao restante de Aprendizado Profundo

Este artigo é o hub de fundamentos de treinamento; aprofundamentos são cobertos nestes tópicos focados:

Resumo: o modelo mental essencial

Treinar uma rede neural é um ciclo repetido de:

  • Passagem para frente para calcular previsões
  • Cálculo da perda para definir o que significa “bom”
  • Passagem para trás para calcular gradientes
  • Passo do otimizador para atualizar parâmetros

A maior parte do sucesso prático vem de acertar as interações:

  • pipeline de dados + aumento
  • arquitetura + inicialização/normalização
  • perda + parametrização da saída
  • otimizador + agendamento da taxa de aprendizado
  • regularização + protocolo de avaliação

Quando esses básicos estão sólidos, métodos avançados (aprendizado curricular (curriculum learning), destilação (distillation), aprendizado multitarefa (multi-task learning), pré-treinamento auto-supervisionado (self-supervised pretraining)) tornam-se muito mais fáceis de aplicar com confiabilidade.