Condivisione della tecnologia

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

0. Riassunto

Incontrato molto tempo fa BatchNorm ELayerNorm, a quel tempo si sapeva solo approssimativamente che avevano eseguito datistandardizzazione: $$\mathbf{X}=\frac{\mathbf{X}-\mathbf{\mu }}{\mathbf{\sigma }}$$ Questo è ovviamente semplice, ma i dati reali sono più complicatiCompiti del CVIn termini di immagine dei dati, i dati di un batch solitamente si presentano così: [B, C, H, W]; per Compiti della PNLIn termini di frase di dati, i dati di un batch solitamente si presentano così: [B, T, D]. Quello XXNorm Come viene calcolato? Sicuramente non tutti i numeri dell'intero lotto vengono calcolati contemporaneamente.$\mathbf{\mu }$ E$\mathbf{\sigma }$, e sono diversi.

Quindi ho controllato molte informazioni e sono davvero d'accordo con le parole dell'istruttore: non leggere quei blog disordinati, non sono bravi come te. Gli stranieri sono comunque fantastici, possono spiegare chiaramente i problemi semplicemente rispondendo alle domande nel area commenti: 《Perché i trasformatori utilizzano la norma a strati invece della norma a lotti?》

1. Come calcolare?

Questa sezione spiega in dettaglio sia dal punto di vista teorico che da quello del codice BatchNorm ELayerNorm metodo di calcolo.

1.1 Parliamone prima teoricamente, chiedendoci il significato generale di Qianwen

>>>>> Tongyi Qianwen >>>>>
chiedere: Qual è la differenza tra norma dello strato e norma del lotto? Fornire una spiegazione della formula.

risposta: Normalizzazione dei livelli (LayerNorm) ENormalizzazione batch (BatchNorm) sono tecniche utilizzate per accelerare l'addestramento della rete neurale, attraverso lo strato di normalizzazioneImmettere o attivare il valore, rendendo l'apprendimento in rete più stabile ed efficienteImplementazioneEScena applicabilesono diversi.

Normalizzazione batch (BatchNorm)
BatchNorm Principalmente durante l'allenamentoPer un mini-batch di datinormalizzareobiettivo principaleSÌRidurre gli spostamenti interni delle covariate(spostamento della covariata interna), ovvero durante il processo di propagazione in avanti della rete, la distribuzione degli input dello strato intermedio cambia con le iterazioni di training. BatchNorm tramite calcoloLa media e la varianza del mini-batch correntePer normalizzare l'input, la formula è la seguente:
impostare$\mathbf{X}$ è il vettore di input all'interno di un mini-batch,${\mathbf{\mu }}_B$ E${\mathbf{\sigma }}_B^2$ sono quindi rispettivamente la media e la varianza del mini-batchBatchNorm Produzione$\mathbf{e}$ Può essere espresso come:$$\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}$$ In,$\gamma$ E$\beta$ è un parametro apprendibile,$ϵ$ è una piccola costante utilizzata per la stabilità numerica.

Normalizzazione dei livelli (LayerNorm)
LayerNorm Lo scopo è quelload ogni livello di campioneEsegui la normalizzazione senza fare affidamento sulle statistiche mini-batch. LayerNorm Più adatto per modelli di sequenza (comeLSTM OTransformer), ecc., tra cuiPotrebbero esserci dipendenze tra i campioniO la dimensione del mini-batch potrebbe non essere fissa. LayerNorm calcolareLa media e la varianza di ciascuna caratteristica del campione, la formula è la seguente:
impostare$\mathbf{X}$ è il vettore delle caratteristiche di un singolo campione,${\mathbf{\mu }}_L$ E${\mathbf{\sigma }}_L^2$ sono rispettivamente la media e la varianza delle caratteristiche del campioneLayerNorm Produzione$\mathbf{e}$ Può essere espresso come:$$\begin{array}{rl}\hat{\mathbf{X}}& =\frac{\mathbf{X}-{\mathbf{\mu }}_L}{\sqrt{{\mathbf{\mu }}_L^2+ϵ}}\\ \hat{\mathbf{e}}& =\gamma \hat{\mathbf{X}}+\beta \end{array}$$ Lo stesso qui,$\gamma$ E$\beta$ è un parametro apprendibile,$ϵ$ è una piccola costante.

la differenza

• Dipende dai dati: BatchNorm dipende dastatistiche mini-batch, E LayerNorm dipende daStatistiche caratteristiche di un singolo campione;
• Scenari applicativi: BatchNorm più adatto acompiti di visione artificiale, E LayerNorm più adatto acompiti di elaborazione del linguaggio naturale, soprattutto quando si ha a che fare con dati di sequenza;
• Efficienza computazionale: BatchNorm Può essere più efficiente nel calcolo parallelo perché può sfruttare il parallelismo all'interno del mini-batchLayerNorm I calcoli su ciascun campione sono indipendenti e più adatti all'elaborazione di dati di sequenze di diversa lunghezza.

Entrambi i metodi presentano vantaggi e svantaggi e il metodo da scegliere dipende solitamente dallo scenario applicativo specifico e dalle caratteristiche dei dati.
<<<<< Tongyi Qianwen<<<<

Sei chiaro? Qual è "la media e la varianza dell'attuale mini-batch"? Qual è "la media e la varianza di ciascuna caratteristica del campione"? La risposta dello straniero è migliore:

Comprendiamo innanzitutto i concetti base:

• esempio: un campione, Immagine per CV,frase per la PNL;
• elementoo: componenti del campione, pixel per immagine,parola per condanna;
• caratteristica: Caratteristiche dell'elemento, Valore RGB per pexel,incorporamento per parola.

Ciò si riflette nei dati:

• [B, C, H, W] è un lotto,[C, H, W] è un esempio,[C] È un pixel, inclusoC caratteristica.
• [B, T, L] è un lotto,[T, L] è un esempio,[L] È una parola, compresoL caratteristica.

Come mostrato di seguito:

Guardando dal lato della dimensione batch, ogni quadratino esteso sul retro rappresenta un elemento, come la lunga barra viola nell'immagine a sinistra, la caratteristica RGB di un pixel o un vettore di parole.LayerNorm Dareogni elemento Calcola la media e la varianza che puoi ottenereBxL media e varianza (oBxHxW). PoiOgni elemento è standardizzato in modo indipendenteLa patch viola nell'immagine a destra è una caratteristica, la prima caratteristica di tutte le parole del batch. Ciascuna di queste patch è una caratteristica. BatchNorm DareOgni caratteristica Calcola la media e la varianza che puoi ottenereL media e varianza (oC). PoiOgni funzionalità è standardizzata in modo indipendente.

Va notato che Transformer non segue quanto sopra menzionatoLayerNorm calcolato, ma datoogni istanza Calcola la media e la varianza che puoi ottenereB media e varianza, quindiOgni istanza è standardizzata in modo indipendentePer essere precisi, assomiglia all'immagine qui sotto:

1.2 In PyTorch BatchNorm ELayerNorm

1.2.1 BatchNorm

In PyTorch, BatchNorm puntonn.BatchNorm1d, nn.BatchNorm2d Enn.BatchNorm3d, rispettivamente per dati di diverse dimensioni:

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

Visualizza il codice sorgente:

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

Esempi:

>>> 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 }$ è un parametro apprendibile eshape=(C,), il nome del parametro è .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 sono uguali, la differenza è questa_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

Esempi:

>>> 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

Esempi:

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

1.2.2 LayerNorm

diverso da BatchNorm(num_features), LayerNorm(normalized_shape) I parametri sonoinput.shape Dopox individualedim, Piace [B, T, L] Le ultime due dimensioni di[T, L], allora ogni frase sarà standardizzata indipendentemente se L O[L], allora ogni vettore di parole è standardizzato in modo indipendente.

Esempio di 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

Esempio di immagine

>>> 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

In altre parole, non comprende solo i “vari elementoo Standardizzare in modo indipendente” e “Ciascunoesempio normalizzato indipendentemente" e può calcolarne qualsiasinormalizzare sulle ultime x dimensioni.

1.3 Studio del processo di calcolo

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

Lo troverai calcolando manualmente e nn.BatchNorm I calcoli sono quasi esattamente gli stessi, forse ce ne sono alcuni$ϵ$ L'influenza di esso. Notalo quiunbiased=False È importante notare, spiega la documentazione ufficiale:

"""
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

Voglio solo verificare il processo di calcolo qui, non concentrarmi su unbiasedSolo per citare brevemente:

• La fase di training calcola una stima distorta della varianza, mentre la varianza nella media mobile con varianza è una stima imparziale;
• Durante l'addestramento, la media mobile di media e var verrà salvata e quindi utilizzata nella fase di test.