Backpropagation Explicado para Iniciantes (Parte 1): Construindo a Intuição

Por que backpropagation importa agora?

Em 2026, grandes modelos de linguagem (LLMs) como GPT-4, Claude e Gemini dominam as manchetes. Mas por trás de cada um deles está o mesmo algoritmo fundamental de aprendizado: backpropagation. Se você quer entender como redes neurais realmente aprendem — e não apenas usar APIs prontas — dominar este conceito é essencial.

O que mudou? Há cinco anos, backpropagation era ensinado apenas em cursos avançados de deep learning. Hoje, com frameworks como PyTorch e TensorFlow abstraindo os detalhes, muitos profissionais pulam direto para o model.fit() sem entender o que acontece sob o capô. Mas quando o modelo não converge, o gradiente explode ou o treinamento fica instável, é o conhecimento de backpropagation que separa quem resolve o problema de quem fica travado.

Este tutorial é a Parte 1 de uma série. Vamos construir a intuição por trás do algoritmo — sem pressa, sem matemática desnecessariamente complexa, e sempre conectando cada passo com o que você já sabe de regressão linear.

✅ O que você ganha com este tutorial

• Intuição sólida: entenda o “porquê” de cada etapa, não apenas o “como”
• Conexão com regressão linear: partimos do que você já conhece — derivadas parciais e função de perda MSE
• Domínio da regra da cadeia: a peça central do backpropagation, explicada com exemplos simples antes de aplicar à rede neural
• Derivação manual completa: calculamos ∂L/∂w₁ passo a passo, sem pular etapas
• Base para a Parte 2: preparação para entender o algoritmo completo de forma eficiente

⚠️ O que você NÃO ganha

• Implementação completa do algoritmo de backpropagation (isso fica para a Parte 2)
• Código em Python ou PyTorch neste artigo (o foco aqui é a matemática e a intuição)
• Derivação de todos os 7 parâmetros da rede (apenas ∂L/∂w₁ é derivada manualmente; o resto usa o mesmo padrão)

Pré-requisitos

1. Recapitulando: a rede neural do artigo anterior

O autor construiu, em um artigo anterior, uma rede neural simples com:

• 1 entrada (horas de estudo)
• 1 camada oculta com 2 neurônios e ativação ReLU
• 1 saída (nota prevista na prova)
• 7 parâmetros: w₁, w₂, w₃, w₄, b₁, b₂, b₃

O conjunto de dados é simples: horas estudadas (x) vs. nota na prova (y). Uma reta não basta — os dados têm curvatura. A rede neural resolve isso combinando duas transformações lineares (uma de cada neurônio oculto) após passarem pela ReLU, que introduz não linearidade.

Durante o forward pass, a rede produz uma previsão ŷ para cada x. Mas a curva resultante não se ajusta bem aos dados: para x=1 (1 hora de estudo), a nota real é 55, mas a rede prevê apenas 28.

2. Por que a rede precisa aprender?

A rede neural atual tem parâmetros fixos (inicializados aleatoriamente ou com estimativas iniciais). O resultado é uma curva que não representa bem os dados. Aprender significa ajustar w₁, w₂, w₃, w₄, b₁, b₂, b₃ para reduzir a perda (erro entre ŷ e y real).

Mas como saber qual parâmetro aumentar e qual diminuir? É aqui que entra o cálculo.

3. A analogia com regressão linear

Em regressão linear simples, temos apenas 2 parâmetros (β₀ e β₁). Plotamos a superfície de perda (formato de tigela em 3D) e encontramos o mínimo onde as derivadas parciais se anulam:

∂L/∂β₀ = 0 e ∂L/∂β₁ = 0

Para a rede neural, a função de perda continua sendo o MSE (Mean Squared Error):

L = (1/n) Σ(yᵢ − ŷᵢ)²

Mas agora ŷᵢ é produzido pela rede neural inteira, e a perda depende de 7 parâmetros, não de 2. A superfície de perda existe em 8 dimensões (7 parâmetros + 1 eixo de perda). Não podemos visualizá-la, mas o objetivo é o mesmo: encontrar os valores dos parâmetros que minimizam a perda.

Para isso, precisamos calcular derivadas parciais como:

∂L/∂w₁, ∂L/∂w₂, ∂L/∂w₃, ∂L/∂w₄, ∂L/∂b₁, ∂L/∂b₂, ∂L/∂b₃

Cada uma dessas derivadas nos diz o quanto a perda muda quando aquele parâmetro específico muda — ou seja, se devemos aumentá-lo ou diminuí-lo para reduzir o erro.

4. A regra da cadeia: o fundamento de tudo

Antes de atacar os 7 parâmetros, precisamos entender a regra da cadeia. Ela é a base matemática do backpropagation.

Exemplo simples: Suponha que z = 3y² e y = x². Queremos dz/dx.

Método clássico (substituição): Substitua y na equação de z → z = 3(x²)² = 3x⁴ → dz/dx = 12x³.

Funciona para exemplos pequenos, mas imagine dezenas de variáveis intermediárias. A regra da cadeia resolve isso de forma sistemática:

dz/dx = (dz/dy) · (dy/dx)

dz/dy = 6y (derivada de 3y²)
dy/dx = 2x (derivada de x²)
dz/dx = 6y · 2x = 12xy = 12x(x²) = 12x³ ✓

A beleza está em quebrar o problema em pedaços menores e multiplicar os resultados. É exatamente isso que faremos na rede neural — só que com uma cadeia mais longa.

5. Derivando ∂L/∂w₁ passo a passo

Vamos calcular a derivada parcial da perda em relação ao primeiro peso (w₁) usando o método clássico de diferenciação. O processo completo:

Passo 1: Expandir a função de perda

∂L/∂w₁ = ∂/∂w₁ [(1/n) Σ(yᵢ − ŷᵢ)²]

Como 1/n é constante e a soma é linear, a derivada passa através deles:

∂L/∂w₁ = (1/n) Σ ∂/∂w₁[(yᵢ − ŷᵢ)²]

Passo 2: Aplicar a regra da potência

Pela regra da cadeia: ∂/∂w₁[(yᵢ − ŷᵢ)²] = 2(yᵢ − ŷᵢ) · ∂/∂w₁[yᵢ − ŷᵢ]

Como yᵢ (valor real) é constante: ∂/∂w₁[yᵢ − ŷᵢ] = −∂ŷᵢ/∂w₁

∂L/∂w₁ = (1/n) Σ 2(yᵢ − ŷᵢ)(−∂ŷᵢ/∂w₁) = −(2/n) Σ (yᵢ − ŷᵢ)(∂ŷᵢ/∂w₁)

Passo 3: Expandir ŷᵢ

ŷᵢ = w₃·a₁ + w₄·a₂ + b₃, onde a₁ = ReLU(w₁xᵢ + b₁) e a₂ = ReLU(w₂xᵢ + b₂)

Como w₁ só aparece em a₁, e w₃ é constante em relação a w₁:

∂ŷᵢ/∂w₁ = w₃ · ∂/∂w₁[ReLU(w₁xᵢ + b₁)]

Passo 4: Derivada da ReLU

Seja u = w₁xᵢ + b₁. Pela regra da cadeia:

∂/∂w₁[ReLU(u)] = ReLU'(u) · ∂u/∂w₁ = ReLU'(w₁xᵢ + b₁) · xᵢ

Onde ReLU'(z) = 1 se z > 0, e 0 se z ≤ 0.

Passo 5: Fórmula final

∂L/∂w₁ = −(2/n) Σ (yᵢ − ŷᵢ) · w₃ · ReLU'(w₁xᵢ + b₁) · xᵢ

Cada termo tem um significado intuitivo:

• (yᵢ − ŷᵢ): erro da previsão — quanto maior o erro, maior o ajuste
• w₃: contribuição do neurônio 1 para a saída final
• ReLU'(…): o gradiente “passa” pela ReLU apenas se o neurônio estiver ativo (z > 0)
• xᵢ: magnitude da entrada — entradas maiores causam ajustes maiores

6. E os outros 6 parâmetros?

Você pode estar pensando: “Preciso repetir tudo isso para w₂, w₃, w₄, b₁, b₂, b₃?”

Felizmente, não. O padrão é o mesmo para todos os parâmetros. A diferença está apenas em quais termos da rede cada parâmetro afeta. E é exatamente essa percepção que leva ao algoritmo de backpropagation — uma forma eficiente de organizar esses cálculos usando a regra da cadeia, evitando trabalho redundante.

Na Parte 2, veremos como aplicar a regra da cadeia de forma sistemática para calcular todos os gradientes de uma vez, caminhando da camada de saída de volta para a camada de entrada — daí o nome backpropagation.

Casos de uso reais

• Debug de treinamento: quando a perda não diminui, inspecionar os gradientes revela se o problema é gradiente desaparecendo (ReLU'(z)=0 para muitos neurônios) ou exploding
• Entrevistas técnicas: backpropagation é uma das perguntas mais comuns em entrevistas para MLE e pesquisador de ML
• Implementação de frameworks: se você contribui para PyTorch, JAX ou TinyGrad, entender backpropagation é obrigatório
• Otimização de arquitetura: skip connections (ResNet) e normalização (BatchNorm) foram projetadas para resolver problemas de fluxo de gradiente
• Fine-tuning de LLMs: LoRA e QLoRA manipulam seletivamente quais parâmetros recebem gradientes — conhecimento direto de backprop

Troubleshooting: erros comuns ao estudar backpropagation

• ❌ “As derivadas parciais não fazem sentido” → Volte para a regra da cadeia com um exemplo simples (z = 3y², y = x²). Depois avance para a rede.
• ❌ “Não consigo visualizar 8 dimensões” → Ninguém consegue. A chave é confiar na matemática: se a derivada parcial ∂L/∂w₁ é positiva, aumentar w₁ aumenta a perda — então diminua w₁.
• ❌ “ReLU'(0) é indefinida?” → Na prática, define-se como 0 (ou 0.5) em z=0. O impacto é insignificante no treinamento.
• ❌ “Esqueci de aplicar a regra da cadeia na ReLU” → Erro clássico. Sempre que houver composição de funções (f(g(x))), a derivada é f'(g(x)) · g'(x).
• ❌ “Confundi ŷᵢ com yᵢ na derivação” → ŷᵢ é a previsão (depende dos parâmetros); yᵢ é o valor real (constante). ∂yᵢ/∂w₁ = 0 sempre.

FAQ

Preciso saber derivar tudo manualmente para usar PyTorch?
Não para o dia a dia — o autograd faz isso. Mas para debugar, otimizar e passar em entrevistas, sim.

Por que começar com MSE e não Cross-Entropy?
MSE é mais simples e conecta diretamente com regressão linear. Cross-Entropy vem depois, para classificação.

O que é gradiente desaparecendo (vanishing gradient)?
Quando ReLU'(z) = 0 para muitos neurônios (z ≤ 0), o gradiente se torna zero e o peso para de aprender. É por isso que existem variantes como LeakyReLU.

Quanto tempo leva para dominar backpropagation?
Com estudo focado: 1-2 semanas para a intuição, 1 mês para derivar qualquer arquitetura com confiança.

Este artigo cobre backpropagation completo?
Não — esta é a Parte 1 (intuição e derivação manual). A Parte 2 cobrirá o algoritmo eficiente completo.