O quê

Gradient descent é o algoritmo fundamental que todo modelo de IA moderna usa para aprender. Descrito pela primeira vez por Augustin-Louis Cauchy em 1847 para sistemas de equações, foi adaptado para machine learning em 1951 (Robbins & Monro, stochastic gradient descent), entrou em uso prático em redes neurais em 1986 com Backpropagation (Rumelhart, Hinton, Williams), e segue sendo a base sobre a qual GPT, Claude, Gemini, Llama, Mistral, todos os modelos de fronteira são treinados.

A ideia central, em uma linha: para minimizar uma função de erro, mova os parâmetros do modelo na direção oposta ao gradiente da função em relação a eles.

Em Magik LLM Gathering, gradient descent é tratado como Technique · Training · Common, primitiva universal sem a qual nada acontece.

Como funciona

O setup

Um modelo de IA tem parâmetros (pesos θ). Para uma entrada de treinamento x com saída esperada y, o modelo produz ŷ = f(x; θ). Definimos uma loss function L(ŷ, y) que mede o erro entre predição e verdade — quanto menor L, melhor o modelo.

O gradiente ∇_θ L é o vetor de derivadas parciais de L em relação a cada parâmetro. Ele aponta para a direção de maior aumento de L no espaço de parâmetros.

O update

Gradient descent atualiza os parâmetros na direção oposta ao gradiente, escalado por um learning rate η:

θ_{t+1} = θ_t − η × ∇_θ L(θ_t)

Repetido milhares ou milhões de vezes, isso desce gradualmente para um mínimo local da loss.

Variantes essenciais

Batch GD (clássico)

Calcula gradiente sobre todo o dataset a cada update. Caro mas estável. Inviável para modelos modernos com bilhões de exemplos.

Stochastic GD (SGD)

Calcula gradiente sobre um único exemplo por vez. Barato, mas ruidoso — descida zigue-zagueia.

Mini-batch SGD (padrão)

Calcula sobre um batch de N exemplos (tipicamente 32-2048). Compromisso entre estabilidade e velocidade. É o padrão universal em deep learning prática.

SGD com Momentum

Acumula uma “velocidade” de gradientes recentes. Acelera em direções consistentes, amortece oscilações:

v_{t+1} = β × v_t + ∇_θ L(θ_t)
θ_{t+1} = θ_t − η × v_{t+1}

β tipicamente 0.9. Essa variante destravou ResNet, BigGAN, e praticamente toda CNN moderna pré-2017.

Adam (Kingma & Ba, 2015)

Adaptativo — calcula learning rate por parâmetro baseado em médias móveis de momento e variância:

m_t = β1·m_{t-1} + (1-β1)·g_t       (first moment)
v_t = β2·v_{t-1} + (1-β2)·g_t²      (second moment)
θ_{t+1} = θ_t − η·m̂_t / (√v̂_t + ε)

Funciona “out of the box” sem muito tuning. Virou padrão para LLMs até ~2022.

AdamW (Loshchilov & Hutter, 2019)

Adam com weight decay separado (não absorvido na loss). Reduz overfitting. Hoje é o optimizer padrão para todo LLM em escala. GPT, Claude, Llama, Gemini — todos AdamW.

Outros que circulam em 2026

• Lion (Chen et al., Google, 2023) — usa sinal do gradiente em vez de magnitude; memória menor.
• Sophia (Liu et al., 2023) — segunda-ordem barata, promete acelerar pretraining de LLM.
• Shampoo (Anil et al., 2020) — preconditioner matricial; usado em alguns grandes treinos.

Por que importa

É a primitiva de todo aprendizado profundo. Sem gradient descent + backpropagation, nada do deep learning moderno existe. Cada update de cada modelo de IA atual é gradient descent em alguma forma. Esse é o algoritmo mais executado da história da computação por unidade de FLOP.

Escala notavelmente bem. Algoritmos teóricos elegantes (Newton’s method, quase-Newton) são mais sofisticados mas escalam mal para bilhões de parâmetros. Gradient descent é embaraçosamente paralelizável — pode ser distribuído sobre milhares de GPUs com algoritmos relativamente simples (data parallel, model parallel, pipeline parallel). É o que permite treinar modelos de trilhões de parâmetros.

Adam/AdamW estabilizou treino. Em ~2010-2014, treinar redes profundas era arte negra — convergência exigia tuning fino, divergências eram comuns. Adam tornou treino reproduzível: defaults razoáveis funcionam em muito mais casos. Esse foi um dos catalisadores do explosão de aplicações de DL de 2015 em diante.

Hyperparâmetros de gradient descent são onde mora a magia. Learning rate schedule (warmup + cosine decay), gradient clipping (estabiliza com clip global de norma 1.0), batch size (efetivamente regulariza), weight decay (controla overfitting) — tuning desses parâmetros é diferenciador entre modelo medíocre e modelo state-of-the-art com mesma arquitetura.

Scaling laws assumem gradient descent. As Scaling Laws (Chinchilla) são empíricas mas implicitamente assumem que otimização é eficiente — que descer o gradiente em compute disponível chega perto do ótimo. Se algum dia surgir algoritmo de otimização significativamente mais eficiente (alguns argumentam que técnicas baseadas em segundo-momento ou em landscape geometry vão escalar), scaling laws teriam que ser reescritas.

Tem limitações conhecidas:

• Mínimos locais — em loss landscape complexa, GD pode parar em vales sub-ótimos. Na prática, em deep learning, isso parece não ser problema sério (mínimos locais em alta dimensão tendem a ser bem comportados).
• Saddle points — gradientes pequenos em direções erradas podem retardar.
• Custo de memória — Adam precisa armazenar dois momentos por parâmetro → 3× memória vs SGD. Para LLMs de bilhões de parâmetros, isso é gargalo.
• Sensibilidade a hyperparâmetros — mesmo Adam pode divergir com learning rate errado.

Estado em 2026

• AdamW continua king para LLM pretraining — todos os modelos de fronteira o usam.
• Lion / Sophia ganham tração em uso prático mas ainda não substituíram AdamW como default.
• 8-bit Adam (Dettmers et al.) reduziu pegada de memória dos optimizers — destrava treinar modelos maiores em menos GPUs.
• ZeRO (DeepSpeed, Microsoft) particiona estado do optimizer entre GPUs, viabilizando trainings de trilhões de parâmetros.
• Muon (Keller Jordan, late 2024) — optimizer baseado em ortogonalização que melhorou treino de algumas arquiteturas.
• Pesquisa em segunda-ordem ainda ativa — mas não destronou primeira-ordem em escala.

Tratamento de carta — proposta

Gradient Descent Technique · Training · Neutral · custo

Training.

Quando você joga este Construct, escolha 1 Modelo seu. Você pode pagar até 3 ⚡; para cada ⚡ pago, esse Modelo ganha +1/+1 permanente. Mas o oponente nomeia 1 keyword do Modelo: até o fim da partida, sempre que esse Modelo perder essa keyword (por qualquer razão), você descarta 1 carta da mão.

“Mova os parâmetros na direção oposta do gradiente. Repita milhões de vezes.”

A mecânica encena: você melhora gradualmente o modelo (gain por passos), mas overfitting está sempre próximo (você passou a depender daquela keyword específica).

Veja também

Backpropagation · Transformer · Scaling Laws (Chinchilla) · Knowledge Distillation · LoRA / QLoRA