Carregando
0x70Lição 8 de 17

Descida de gradiente e otimizadores

Transforme gradientes em atualizações de peso com SGD, momentum e Adam e ajuste a taxa de aprendizado.

28 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Explique a descida gradiente e o papel da taxa de aprendizagem
  • Compare a descida gradiente de lote completo, estocástica e minilote
  • Implemente momentum e Adam e escolha um cronograma de taxa de aprendizagem

Os gradientes apontam para cima - a direção em que a perda cresce mais rapidamente. Então, para aprender, vá para o outro lado:

θ←θ−η ∇θL\theta \leftarrow \theta - \eta \, \nabla_\theta L

onde θ\theta representa todos os parâmetros e η\eta (eta) é a taxa de aprendizagem. É a configuração mais importante no aprendizado profundo: muito pequeno e rastreamentos de treinamento; muito grande e a perda salta ou explode.

Experimente

Até 15 XP

Role a bola morro abaixo

Experimente várias taxas de aprendizagem. Encontre um que convirja suavemente, um que rasteje e um que salte para frente e para trás - ou voe.

x = -1.50
Perda = 11.13
Gradiente = -4.50
passos realizados: 0

Quantos dados por etapa?

  • Lote completo A descida gradiente usa todo o conjunto de dados para cada etapa: precisa, mas lenta.
  • A descida gradiente estocástica (SGD) usa um exemplo: rápido, muito barulhento.
  • Minilote - 32 a alguns milhares de exemplos - é o que todo mundo realmente faz. Seu ruído ajuda até a fugir de regiões pobres. (É confuso, as pessoas também chamam isso de “SGD”.)

Uma passagem por todo o conjunto de dados é uma época.

Momento e Adão

A descida em gradiente plano ziguezagueia em vales longos e estreitos: a direção íngreme faz com que salte, a direção rasa o faz rastejar. Momentum mantém a velocidade de corrida, de modo que direções consistentes aumentam a velocidade e os ziguezagues se cancelam:

v←βv+∇L,θ←θ−ηvv \leftarrow \beta v + \nabla L, \qquad \theta \leftarrow \theta - \eta v (normalmente β=0.9\beta = 0.9)

Adam (2014), o padrão mais popular, também dá a cada parâmetro seu próprio tamanho de passo, reduzido onde os gradientes são grandes:

m←β1m+(1−β1)g,s←β2s+(1−β2)g2m \leftarrow \beta_1 m + (1 - \beta_1) g, \qquad s \leftarrow \beta_2 s + (1 - \beta_2) g^2

m^=m1−β1t,s^=s1−β2t,θ←θ−ηm^s^+ϵ\hat{m} = \frac{m}{1 - \beta_1^t}, \quad \hat{s} = \frac{s}{1 - \beta_2^t}, \qquad \theta \leftarrow \theta - \eta \frac{\hat{m}}{\sqrt{\hat{s}} + \epsilon}

com β1=0.9,β2=0.999,ϵ=10−8\beta_1 = 0.9, \beta_2 = 0.999, \epsilon = 10^{-8}. Os chapéus são correções de viés: m e s começam em zero, o que tornaria os primeiros passos muito pequenos. AdamW adiciona decaimento dos pesos desacoplada e é o padrão para transformadores de treinamento.

race.py
1import numpy as np
2
3def gradient(p):                      # a long, narrow valley: f = 0.5 (x² + 25 y²)
4    return np.array([p[0], 25 * p[1]])
5
6def loss(p):
7    return 0.5 * (p[0] ** 2 + 25 * p[1] ** 2)
8
9def run(lr, beta=0.0):                # beta = 0 is plain gradient descent
10    p, v = np.array([10.0, 1.0]), np.zeros(2)
11    for step in range(1, 1001):
12        v = beta * v + gradient(p)
13        p = p - lr * v
14        if loss(p) > 1e6:
15            return "diverged"
16        if loss(p) < 1e-6:
17            return step
18    return "too slow"
19
20print("SGD at its best, lr 0.077:   ", run(0.077))
21print("SGD, lr 0.09:                ", run(0.09))
22print("momentum 0.5, lr 0.1:        ", run(0.1, beta=0.5))
23print("momentum 0.9, lr 0.1:        ", run(0.1, beta=0.9))
Saída
SGD at its best, lr 0.077:    113
SGD, lr 0.09:                 diverged
momentum 0.5, lr 0.1:         28
momentum 0.9, lr 0.1:         160

A descida gradiente simples não pode aumentar sua taxa de aprendizado além de 0,08 - a direção y íngreme explodiria - então a direção x suave rasteja: 113 passos no máximo. Com impulso 0,5 são necessários 28. Mas o impulso também é uma configuração: em 0,9, a velocidade aumenta tanto que a bola ultrapassa e circula o mínimo por 160 passos. O popular 0,9 brilha em problemas grandes e barulhentos; em um pequeno e limpo como este, menos é mais.

Cronogramas de taxa de aprendizagem

A melhor taxa de aprendizagem muda durante o treinamento: grandes passos no início para progredir, pequenos passos no final para atingir o mínimo. Programações comuns:

  • Decaimento gradual: divida por 10 a cada N épocas.
  • Decaimento de cosseno: deslize suavemente da taxa inicial até próximo de zero.
  • Aquecimento: comece aos poucos e acelere nas primeiras centenas de passos, depois decaia. Os transformadores quase sempre usam aquecimento, porque as atualizações iniciais em pesos aleatórios são instáveis.

Principais conclusões

  • Etapas de descida do gradiente contra o gradiente: θ ← θ − η∇L; a taxa de aprendizagem é a configuração principal.

  • A descida gradiente em minilote equilibra velocidade e ruído; uma época é uma passagem pelos dados.

  • O momento acumula velocidade; Adam adiciona tamanhos de passo por parâmetro com correção de polarização.

  • Os horários - aquecimento e depois decaimento - adaptam a taxa de aprendizagem durante o treinamento.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

A corrida do impulso

+25 XP

Cada linha de entrada é sgd lr ou momentum lr beta. Começando em (10, 1) em f(x,y)=0.5(x2+25y2)f(x, y) = 0.5(x^2 + 25y^2), conte os passos até que a perda caia abaixo de 1e-6 (no máximo 1000 passos). Imprima sgd lr=0.077: 113 steps, ou momentum lr=0.1 beta=0.5: 28 steps, ou diverged em vez das etapas se a perda exceder 1e6, ou too slow se 1000 etapas não forem suficientes.

  • Cinco pilotos
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Implementar Adam

+25 XP

Minimize f(θ)=(θ−3)2f(\theta) = (\theta - 3)^2 com Adam (β1 = 0,9, β2 = 0,999, ε = 1e-8). A entrada tem o θ inicial e a taxa de aprendizagem. Imprima θ com 4 casas decimais após as etapas 1, 2, 3 e após a etapa 200, como step 1: theta=0.1000.

  • De 0 com lr 0,1
  • De 10 com lr 0,5
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…