Carregando
0x90Lição 10 de 17

Inicialização, normalização e conexões residuais

Preserve sinais e gradientes em redes profundas com inicialização adequada, normalização em lote e em camada e conexões residuais.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Explique ativações e gradientes de desaparecimento e explosão em redes profundas
  • Inicialize pesos com escala Xavier ou He
  • Descrever como a norma do lote, a norma da camada e as conexões residuais tornam as redes profundas treináveis

Empilhe camadas suficientes e algo alarmante acontece. Cada camada multiplica o sinal pelos seus pesos; se essas multiplicações encolherem um pouco, depois de 50 camadas ele desaparecerá; se crescerem um pouco, ele explode. O mesmo acontece com os gradientes na volta. De qualquer forma, o treinamento é interrompido ou interrompido.

Veja isso acontecer com um lote de entradas aleatórias passando por 50 camadas ReLU de 256 unidades:

signal_through_depth.py
1import numpy as np
2
3def spread_after(depth, weight_std, width=256):
4    rng = np.random.default_rng(0)
5    x = rng.normal(size=(100, width))
6    for _ in range(depth):
7        W = rng.normal(0, weight_std, size=(width, width))
8        x = np.maximum(0, x @ W)
9    return x.std()
10
11he = np.sqrt(2 / 256)
12for name, std in [("too small (0.01)", 0.01), ("too big (0.1)", 0.1), (f"He ({he:.3f})", he)]:
13    print(f"{name:<16}", " ".join(f"{spread_after(depth, std):9.2e}" for depth in (1, 10, 50)))
Saída
too small (0.01)  9.25e-02  3.32e-10  2.87e-48
too big (0.1)     9.25e-01  3.32e+00  2.87e+02
He (0.088)        8.18e-01  9.67e-01  6.00e-01

Com pesos minúsculos, o sinal desaparece na camada 10. Com pesos um pouco grandes demais, ele cresce camada após camada e explode - 300 vezes maior na camada 50. A inicialização o mantém aproximadamente do mesmo tamanho em todas as profundidades. A regra prática é dimensionar os pesos aleatórios pelo número de entradas para a camada, ninn_{in}:

InicializaçãoDesvio padrão do pesoUsar com
Xavier / Glorot (2010)1/nin\sqrt{1 / n_{in}}tanh, sigmóide
Ele / Kaiming (2015)2/nin\sqrt{2 / n_{in}}ReLU e amigos - os 2 extras compensam o ReLU zerando metade do sinal

As estruturas escolhem padrões sensatos (o nn.Linear do PyTorch usa um init uniforme no estilo Kaiming), mas quando você mesmo constrói uma camada, esta é a linha que decide se o treinamento profundo funciona. Os preconceitos geralmente começam em zero.

Camadas de normalização

Uma boa inicialização ajuda no início, mas os pesos mudam à medida que o treino avança. Camadas de normalização mantêm as ativações bem dimensionadas o tempo todo: padronize para média 0 e variação 1 e, em seguida, deixe a rede redimensionar com os parâmetros aprendidos γ\gamma (escala) e β\beta (deslocamento):

x^=x−μσ2+ϵ,y=γx^+β\hat{x} = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}}, \qquad y = \gamma \hat{x} + \beta

  • Normalização de lote (2015) calcula μ e σ para cada recurso em todo o lote. É padrão em redes convolucionais. Durante o treinamento ele utiliza as estatísticas do lote e mantém médias; na inferência, ele usa essas médias - e é por isso que os modelos têm modos de treinamento e avaliação separados.
  • Normalização de camada calcula μ e σ para cada exemplo em seus recursos. Não depende em nada do lote, por isso funciona com tamanho de lote 1 e com sequências - é a normalização em cada transformador.
norms.py
1import numpy as np
2
3x = np.array([[1.0, 2.0, 3.0, 4.0],
4              [10.0, 10.0, 20.0, 40.0]])
5eps = 1e-5
6
7batch_norm = (x - x.mean(axis=0)) / np.sqrt(x.var(axis=0) + eps)                                   # per feature
8layer_norm = (x - x.mean(axis=1, keepdims=True)) / np.sqrt(x.var(axis=1, keepdims=True) + eps)    # per example
9print(np.round(batch_norm, 2))
10print(np.round(layer_norm, 2))
Saída
[[-1. -1. -1. -1.]
 [ 1.  1.  1.  1.]]
[[-1.34 -0.45  0.45  1.34]
 [-0.82 -0.82  0.    1.63]]

Conexões residuais

O outro grande avanço de 2015 foi a rede residual (ResNet). Em vez de um bloco de computação y=F(x)y = F(x), ele calcula:

y=x+F(x)y = x + F(x)

O bloco só precisa aprender a mudança em sua entrada, e o + x pular conexão fornece aos gradientes uma rodovia de volta pela rede: a derivada de x+F(x)x + F(x) sempre inclui 1. ResNets treinou 152 camadas quando 20 foram difíceis. Hoje quase todas as arquiteturas profundas – incluindo todos os transformadores – são construídas a partir de blocos residuais.

Principais conclusões

  • Sinais e gradientes encolhem ou explodem em muitas camadas, a menos que os pesos sejam dimensionados com cuidado.

  • Use Xavier (√(1/nᵢₙ)) para tanh/sigmóide e He (√(2/nᵢₙ)) para ReLU.

  • A norma do lote normaliza os recursos em todo o lote (os modos de treinamento/avaliação são diferentes); a norma da camada normaliza cada exemplo.

  • Conexões residuais, y = x + F(x), fornecem aos gradientes um caminho direto e tornam treináveis ​​redes muito profundas.

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

O experimento de inicialização

+25 XP

A entrada é uma profundidade. Envie um lote de 100 entradas aleatórias (largura 128, rng = np.random.default_rng(0), desenhada primeiro) através dessas muitas camadas ReLU, extraindo os pesos de cada camada do mesmo rng, para três inicializações nesta ordem - desvio padrão 0,01, depois 1,0, depois He (2/128\sqrt{2/128}) - reiniciando o rng a partir da semente 0 para cada uma. Imprima cada desvio padrão de ativação final em notação científica com 2 casas decimais ({:.2e}), como std=0.01: 1.23e-45.

  • 10 camadas
  • 30 camadas
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

Normalização da camada de gravação

+25 XP

Implemente layer_norm(x, gamma, beta, eps=1e-5): normalize cada linha (exemplo) para média 0 e variação 1 sobre seus recursos, depois dimensione por gamma e mude por beta (um valor por recurso). Cada linha de entrada é um exemplo. Imprima as linhas normalizadas com 3 casas decimais e, em seguida, a média e o desvio padrão de cada linha de saída com 3 casas decimais.

  • Dois exemplos
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…