Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

0. Resumo

Nos conhecemos há muito tempo BatchNorm eLayerNorm, naquela época só se sabia aproximadamente que eles haviam realizado dadosestandardização: $$\mathbf{x}=\frac{\mathbf{x}-\mathbf{\mu }}{\mathbf{\sigma }}$$ É claro que isso é simples, mas os dados reais são mais complicados.Tarefas de currículoEm termos de imagem de dados, os dados de um lote geralmente se parecem com isto: [B, C, H, W]; para Tarefas de PNLEm termos de sentença de dados, os dados de um lote geralmente se parecem com isto: [B, T, D]. Que XXNorm Como é calculado Definitivamente, nem todos os números do lote inteiro são calculados de uma só vez.$\mathbf{\mu }$ e$\mathbf{\sigma }$, e eles são diferentes.

Então verifiquei muitas informações e realmente concordei com as palavras do instrutor: Não leia esses blogs bagunçados, eles não são tão bons quanto você. Os estrangeiros ainda são incríveis, eles conseguem explicar os assuntos com clareza apenas respondendo às perguntas no! área de comentários: 《Por que os transformadores usam a norma de camada em vez da norma de lote?》

1. Como calcular?

Esta seção explica em detalhes as perspectivas teórica e de código BatchNorm eLayerNorm método de cálculo.

1.1 Vamos falar sobre isso teoricamente primeiro, perguntando sobre o significado geral de Qianwen

>>>>> Tongyi Qianwen >>>>>
perguntar: Qual é a diferença entre norma de camada e norma de lote?

responder: Normalização de Camadas (LayerNorm) eNormalização em lote (BatchNorm) são técnicas utilizadas para acelerar o treinamento de redes neurais, através da camada de normalizaçãoInsira ou ative o valor, tornando o aprendizado em rede mais estável e eficiente.ImplementaçãoeCena aplicávelsão diferentes.

Normalização em lote (BatchNorm)
BatchNorm Principalmente durante o treinamentoPara um minilote de dadospara normalizar.alvo principalsimReduzir mudanças de covariáveis ​​internas(deslocamento covariável interno), ou seja, durante o processo de propagação direta da rede, a distribuição de entrada da camada intermediária muda com as iterações de treinamento. BatchNorm via cálculoA média e a variância do minilote atualPara normalizar a entrada, a fórmula é a seguinte:
configurar$\mathbf{x}$ é o vetor de entrada dentro de um minilote,${\mathbf{\mu }}_B$ e${\mathbf{\sigma }}_B^2$ são a média e a variância do minilote, respectivamente, entãoBatchNorm Saída$\mathbf{e}$ Pode ser expresso como:$$\begin{array}{rl}\hat{\mathbf{x}}& =\frac{\mathbf{x}-{\mathbf{\mu }}_B}{\sqrt{{\mathbf{\mu }}_B^2+ϵ}}\\ \hat{\mathbf{e}}& =\gamma \hat{\mathbf{x}}+\beta \end{array}$$ em,$\gamma$ e$\beta$ é um parâmetro que pode ser aprendido,$ϵ$ é uma pequena constante usada para estabilidade numérica.

Normalização de Camadas (LayerNorm)
LayerNorm O objetivo éem cada nível de amostraExecute a normalização sem depender de estatísticas de minilote. LayerNorm Mais adequado para modelos de sequência (comoLSTM ouTransformer), etc., entre os quaisPode haver dependências entre amostrasou o tamanho do minilote pode não ser fixo. LayerNorm calcularA média e a variância de cada recurso da amostra, a fórmula é a seguinte:
configurar$\mathbf{x}$ é o vetor de características de uma única amostra,${\mathbf{\mu }}_{eu}$ e${\mathbf{\sigma }}_{eu}^2$ são a média e a variância das características da amostra, respectivamente, entãoLayerNorm Saída$\mathbf{e}$ Pode ser expresso como:$$\begin{array}{rl}\hat{\mathbf{x}}& =\frac{\mathbf{x}-{\mathbf{\mu }}_{eu}}{\sqrt{{\mathbf{\mu }}_{eu}^2+ϵ}}\\ \hat{\mathbf{e}}& =\gamma \hat{\mathbf{x}}+\beta \end{array}$$ Mesmo aqui,$\gamma$ e$\beta$ é um parâmetro que pode ser aprendido,$ϵ$ é uma pequena constante.

a diferença

• Depende dos dados: BatchNorm depende deestatísticas de minilote, e LayerNorm depende deEstatísticas características de uma única amostra;
• Cenários de aplicação: BatchNorm mais adequado paratarefas de visão computacional, e LayerNorm mais adequado paratarefas de processamento de linguagem natural, especialmente ao lidar com dados de sequência;
• Eficiência computacional: BatchNorm Pode ser mais eficiente na computação paralela porque pode tirar vantagem do paralelismo dentro do minilote, enquantoLayerNorm Os cálculos em cada amostra são independentes e mais adequados para processar dados de sequência de diferentes comprimentos.

Ambos os métodos têm suas próprias vantagens e desvantagens, e qual método escolher geralmente depende do cenário específico da aplicação e das características dos dados.
<<<<<Tongyi Qianwen<<<<

Você está claro? Qual é "a média e a variância do minilote atual"? O que é "a média e a variância de cada recurso de amostra"? A resposta do estrangeiro é melhor:

Vamos primeiro entender os conceitos básicos:

• instância: uma amostra, imagem para CV,frase para PNL;
• elementoo: componentes da amostra, pixel para imagem,palavra para frase;
• recurso: Características do elemento, Valor RGB para pexel,incorporação para palavra.

Isso se reflete nos dados:

• [B, C, H, W] é um lote,[C, H, W] é uma instância,[C] É um pixel, incluindoC recurso.
• [B, T, L] é um lote,[T, L] é uma instância,[L] É uma palavra, incluindoL recurso.

Como mostrado abaixo:

Olhando do lado da dimensão do lote, cada pequeno quadrado estendido para trás representa um elemento, como a longa barra roxa na imagem à esquerda, o recurso RGB de um pixel ou um vetor de palavras.LayerNorm Darcada elemento Calcule a média e a variância, você pode obterBxL média e variância (ouBxHxW). EntãoCada elemento é padronizado de forma independenteA mancha roxa na imagem à direita é um recurso, o primeiro recurso de todas as palavras do lote. BatchNorm DarCada recurso Calcule a média e a variância, você pode obterL média e variância (ouC). EntãoCada recurso é padronizado de forma independente.

Deve-se notar que o Transformer não segue o mencionado acimaLayerNorm calculado, mas dadocada instância Calcule a média e a variância, você pode obterB média e variância, entãoCada instância é padronizada de forma independente. Para ser mais preciso, parece com a imagem abaixo:

1.2 Em PyTorch BatchNorm eLayerNorm

1.2.1 BatchNorm

No PyTorch, BatchNorm apontarnn.BatchNorm1d, nn.BatchNorm2d enn.BatchNorm3d, respectivamente para dados de diferentes dimensões:

• nn.BatchNorm1d: (N, C) ou(N, C, L)
• nn.BatchNorm2d: (N, C, H, W)
• nn.BatchNorm3d: (N, C, D, H, W)

Ver código-fonte:

class BatchNorm1d(_BatchNorm):
	r"""
	Args:
		num_features: number of features or channels `C` of the input

	Shape:
		- Input: `(N, C)` or `(N, C, L)`, where `N` is the batch size,
		  `C` is the number of features or channels, and `L` is the sequence length
		- Output: `(N, C)` or `(N, C, L)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 2 and input.dim() != 3:
			raise ValueError(f"expected 2D or 3D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11
12
13

Exemplos:

>>> m = nn.BatchNorm1d(100)  # C=100	   # With Learnable Parameters
>>> m = nn.BatchNorm1d(100, affine=False)  # Without Learnable Parameters
>>> input = torch.randn(20, 100)  # (N, C)
>>> output = m(input)
>>> # 或者
>>> input = torch.randn(20, 100, 30)  # (N, C, L)
>>> output = m(input)
1
2
3
4
5
6
7

$\mathbf{\gamma },\mathbf{\beta }$ é um parâmetro que pode ser aprendido eshape=(C,), o nome do parâmetro é .weight e.bias:

>>> m = nn.BatchNorm1d(100)
>>> m.weight
Parameter containing:
tensor([1., 1., ..., 1.], requires_grad=True) 
>>> m.weight.shape
torch.Size([100])
>>> m.bias
Parameter containing:
tensor([0., 0., ..., 0.], requires_grad=True)
1
2
3
4
5
6
7
8
9

BatchNorm2d eBatchNorm3d são iguais, a diferença é que_check_input_dim(input):

class BatchNorm2d(_BatchNorm):
	r"""
	Args:
		num_features: `C` from an expected input of size `(N, C, H, W)`
	Shape:
		- Input: :math:`(N, C, H, W)`
		- Output: :math:`(N, C, H, W)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 4:
			raise ValueError(f"expected 4D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11

Exemplos:

>>> m = nn.BatchNorm2d(100)
>>> input = torch.randn(20, 100, 35, 45)
>>> output = m(input)
1
2
3

class BatchNorm3d(_BatchNorm):
	r"""
	Args:
		num_features: `C` from an expected input of size `(N, C, D, H, W)`
	Shape:
		- Input: :math:`(N, C, D, H, W)`
		- Output: :math:`(N, C, D, H, W)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 5:
			raise ValueError(f"expected 5D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11

Exemplos:

>>> m = nn.BatchNorm3d(100)
>>> input = torch.randn(20, 100, 35, 45, 10)
>>> output = m(input)
1
2
3

1.2.2 LayerNorm

diferente de BatchNorm(num_features), LayerNorm(normalized_shape) Os parâmetros sãoinput.shape depoisx individualdim, como [B, T, L] As duas últimas dimensões[T, L], então cada frase será padronizada de forma independente se; L ou[L], então cada vetor de palavras é padronizado de forma independente.

Exemplo de PNL

>>> batch, sentence_length, embedding_dim = 20, 5, 10
>>> embedding = torch.randn(batch, sentence_length, embedding_dim)
>>> layer_norm = nn.LayerNorm(embedding_dim)
>>> layer_norm(embedding)  # Activate module
1
2
3
4

Exemplo de imagem

>>> N, C, H, W = 20, 5, 10, 10
>>> input = torch.randn(N, C, H, W)
>>> # Normalize over the last three dimensions (i.e. the channel and spatial dimensions)
>>> layer_norm = nn.LayerNorm([C, H, W])
>>> output = layer_norm(input)
1
2
3
4
5

Em outras palavras, não inclui apenas os “vários elementoo Padronizar de forma independente” e “Cadainstância normalizado independentemente" e pode calcular qualquernormalizar sobre as últimas x dimensões.

1.3 Investigação do processo de cálculo

import torch
from torch import nn

# >>> 手动计算 BatchNorm2d >>>
weight = torch.ones([1, 3, 1, 1])
bias = torch.zeros([1, 3, 1, 1])

x = 10 * torch.randn(2, 3, 4, 4) + 100
mean = x.mean(dim=[0, 2, 3], keepdim=True)
std = x.std(dim=[0, 2, 3], keepdim=True, unbiased=False)
print(x)
print(mean)
print(std)

y = (x - mean) / std
y = y * weight + bias
print(y)
# <<< 手动计算 BatchNorm2d <<<

# >>> nn.BatchNorm2d >>>
bnm2 = nn.BatchNorm2d(3)
z = bnm2(x)
print(z)
# <<< nn.BatchNorm2d <<<
print(torch.norm(z - y, p=1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Você descobrirá que calcular manualmente e nn.BatchNorm Os cálculos são quase exatamente os mesmos, talvez haja alguns$ϵ$ A influência disso.unbiased=False É importante observar que a documentação oficial explica:

"""
At train time in the forward pass, the standard-deviation is calculated via the biased estimator,
equivalent to `torch.var(input, unbiased=False)`.
However, the value stored in the moving average of the standard-deviation is calculated via
the unbiased  estimator, equivalent to `torch.var(input, unbiased=True)`.

Also by default, during training this layer keeps running estimates of its computed mean and
variance, which are then used for normalization during evaluation.
"""
1
2
3
4
5
6
7
8
9

Eu só quero verificar o processo de cálculo aqui, não focar unbiased. Apenas para mencionar brevemente:

• A etapa de treinamento calcula uma estimativa tendenciosa da variância, enquanto a variância na média móvel com variância é uma estimativa imparcial;
• Durante o treinamento, a média móvel de média e var será salva e usada na fase de teste.