Berbagi teknologi

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

0. Abstrak

Bertemu sejak lama BatchNorm DanLayerNorm, pada saat itu hanya diketahui secara kasar bahwa mereka telah melakukan datastandardisasi: $$\mathbf{X}=\frac{\mathbf{X}-\mathbf{\mu }}{\mathbf{\sigma }}$$ Ini tentu saja sederhana, tetapi data sebenarnya lebih rumittugas CVDalam hal gambar data, kumpulan data biasanya terlihat seperti ini: [B, C, H, W]; untuk tugas NLPDari segi kalimat data, data suatu batch biasanya terlihat seperti ini: [B, T, D]. Itu XXNorm Bagaimana cara menghitungnya? Jelas tidak semua angka di seluruh batch dihitung sekaligus.$\mathbf{\mu }$ Dan$\mathbf{\sigma }$, dan mereka berbeda.

Jadi saya cek banyak informasinya, dan saya sangat setuju dengan kata-kata instrukturnya: Jangan baca blog-blog yang berantakan itu, mereka tidak sebaik Anda! Orang asing masih hebat, mereka bisa menjelaskan masalahnya dengan jelas hanya dengan menjawab pertanyaan di area komentar: 《Mengapa transformer menggunakan norma lapisan, bukan norma batch?》

1. Bagaimana cara menghitungnya?

Bagian ini menjelaskan secara rinci dari perspektif teoritis dan kode BatchNorm DanLayerNorm metode kalkulasi.

1.1 Mari kita bahas secara teoritis terlebih dahulu, menanyakan tentang arti umum dari Qianwen

>>>>> Tongyi Qianwen >>>>>
bertanya: Apa perbedaan antara norma lapisan dan norma batch? Berikan penjelasan rumusnya.

menjawab: Normalisasi Lapisan (LayerNorm) DanNormalisasi Batch (BatchNorm) adalah teknik yang digunakan untuk mempercepat pelatihan jaringan saraf, melalui lapisan normalisasiMasukkan atau aktifkan nilai, membuat pembelajaran jaringan lebih stabil dan efisienPenerapanDanAdegan yang berlakuberbeda pada.

Normalisasi Batch (BatchNorm)
BatchNorm Terutama selama pelatihanUntuk kumpulan data keciluntuk menormalkantarget utamaYaMengurangi pergeseran kovariat internal(pergeseran kovariat internal), yaitu, selama proses propagasi maju jaringan, distribusi masukan dari lapisan perantara berubah seiring dengan iterasi pelatihan. BatchNorm melalui perhitunganRata-rata dan varians dari mini-batch saat iniUntuk menormalkan input, rumusnya adalah sebagai berikut:
mempersiapkan$\mathbf{X}$ adalah vektor masukan dalam mini-batch,${\mathbf{\mu }}_B$ Dan${\mathbf{\sigma }}_B^2$ adalah mean dan varians dari mini-batch masing-masingBatchNorm Keluaran$\mathbf{kamu}$ Hal ini dapat dinyatakan sebagai:$$\begin{array}{rl}\hat{\mathbf{X}}& =\frac{\mathbf{X}-{\mathbf{\mu }}_B}{\sqrt{{\mathbf{\mu }}_B^2+ϵ}}\\ \widehat{\mathbf{kamu}}& =\gamma \hat{\mathbf{X}}+\beta \end{array}$$ di dalam,$\gamma$ Dan$\beta$ adalah parameter yang bisa dipelajari,$ϵ$ adalah konstanta kecil yang digunakan untuk stabilitas numerik.

Normalisasi Lapisan (LayerNorm)
LayerNorm Tujuannya adalah untukpada setiap tingkat sampelLakukan normalisasi tanpa bergantung pada statistik mini-batch. LayerNorm Lebih cocok untuk model urutan (sepertiLSTM atauTransformer), dll., di antaranyaMungkin ada ketergantungan antar sampelatau ukuran tumpukan mini mungkin tidak diperbaiki. LayerNorm menghitungRata-rata dan varians setiap fitur sampel, rumusnya adalah sebagai berikut:
mempersiapkan$\mathbf{X}$ adalah vektor fitur dari satu sampel,${\mathbf{\mu }}_{Saya}$ Dan${\mathbf{\sigma }}_{Saya}^2$ adalah mean dan varians dari masing-masing karakteristik sampelLayerNorm Keluaran$\mathbf{kamu}$ Hal ini dapat dinyatakan sebagai:$$\begin{array}{rl}\hat{\mathbf{X}}& =\frac{\mathbf{X}-{\mathbf{\mu }}_{Saya}}{\sqrt{{\mathbf{\mu }}_{Saya}^2+ϵ}}\\ \widehat{\mathbf{kamu}}& =\gamma \hat{\mathbf{X}}+\beta \end{array}$$ Sama disini,$\gamma$ Dan$\beta$ adalah parameter yang bisa dipelajari,$ϵ$ adalah konstanta kecil.

perbedaan

• Tergantung pada datanya: BatchNorm tergantung padastatistik kumpulan mini, Dan LayerNorm tergantung padaStatistik karakteristik dari satu sampel;
• Skenario aplikasi: BatchNorm lebih cocok untuktugas visi komputer, Dan LayerNorm lebih cocok untuktugas pemrosesan bahasa alami, terutama ketika berhadapan dengan data urutan;
• Efisiensi komputasi: BatchNorm Mungkin lebih efisien dalam komputasi paralel karena dapat memanfaatkan paralelisme dalam mini-batchLayerNorm Perhitungan pada setiap sampel bersifat independen dan lebih cocok untuk memproses data urutan dengan panjang yang berbeda.

Kedua metode tersebut memiliki kelebihan dan kekurangan masing-masing, dan metode mana yang dipilih biasanya bergantung pada skenario aplikasi spesifik dan karakteristik data.
<<<<< Tongyi Qianwen<<<<

Apakah kamu jelas? Apa yang dimaksud dengan "rata-rata dan varians dari mini-batch saat ini"? Apa yang dimaksud dengan "rata-rata dan varians dari setiap fitur sampel"? Jawaban orang asing lebih baik:

Mari kita pahami dulu konsep dasarnya:

• contoh: Sebuah sampel, gambar untuk CV,kalimat untuk NLP;
• elemen: komponen sampel, piksel untuk gambar,kata untuk kalimat;
• fitur: Karakteristik elemen, nilai RGB untuk pexel,menanamkan untuk kata.

Hal ini tercermin dalam data:

• [B, C, H, W] adalah kumpulan,[C, H, W] adalah sebuah contoh,[C] Ini adalah piksel, termasukC fitur.
• [B, T, L] adalah kumpulan,[T, L] adalah sebuah contoh,[L] Itu adalah sebuah kata, termasukL fitur.

Seperti yang ditunjukkan di bawah ini:

Dilihat dari sisi Dimensi Batch, setiap kotak kecil yang memanjang ke belakang mewakili sebuah elemen, seperti bilah ungu panjang di gambar kiri, fitur RGB pada piksel, atau vektor kata.LayerNorm Memberisetiap elemen Hitung mean dan varians yang bisa Anda dapatkanBxL mean dan varians (atauBxHxW). KemudianSetiap elemen distandarisasi secara independen.Tambalan ungu pada gambar di sebelah kanan adalah sebuah fitur, fitur pertama dari semua kata dalam kumpulan tersebut. BatchNorm MemberiSetiap fitur Hitung mean dan varians yang bisa Anda dapatkanL mean dan varians (atauC). KemudianSetiap fitur distandarisasi secara independen.

Perlu dicatat bahwa Transformer tidak mengikuti hal yang disebutkan di atasLayerNorm dihitung, tetapi diberikansetiap contoh Hitung mean dan varians yang bisa Anda dapatkanB mean dan varians, laluSetiap contoh distandarisasi secara independenLebih tepatnya tampilannya seperti gambar di bawah ini:

1.2 Di PyTorch BatchNorm DanLayerNorm

1.2.1 BatchNorm

Di PyTorch, BatchNorm titiknn.BatchNorm1d, nn.BatchNorm2d Dannn.BatchNorm3d, masing-masing untuk data dengan dimensi berbeda:

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

Lihat kode sumber:

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

Contoh:

>>> 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 }$ adalah parameter yang dapat dipelajari, danshape=(C,), nama parameternya adalah .weight Dan.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 DanBatchNorm3d sama saja, yang membedakannya adalah_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

Contoh:

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

Contoh:

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

1.2.2 LayerNorm

berbeda dari BatchNorm(num_features), LayerNorm(normalized_shape) Parameternya adalahinput.shape setelahx individudim, menyukai [B, T, L] Dua dimensi terakhir dari[T, L], maka setiap kalimat akan dibakukan secara mandiri; L atau[L], maka setiap vektor kata distandarisasi secara independen.

Contoh NLP

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

Contoh Gambar

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

Dengan kata lain, ini tidak hanya mencakup “berbagai elemen Standarisasi secara mandiri” dan “Masing-masingcontoh "dinormalisasi secara independen" dan dapat menghitung apa punmenormalkan pada dimensi x terakhir.

1.3 Investigasi proses perhitungan

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

Anda akan menemukannya secara manual menghitung dan nn.BatchNorm Perhitungannya hampir sama persis, mungkin ada beberapa$ϵ$ Pengaruhnya. Perhatikan itu di siniunbiased=False Penting untuk diperhatikan, dokumentasi resmi menjelaskan:

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

Saya hanya ingin memverifikasi proses perhitungan di sini, bukan fokus unbiased. Sekadar menyebutkan secara singkat:

• Tahap pelatihan menghitung estimasi varians yang bias, sedangkan varians pada moving average dengan varians merupakan estimasi yang tidak bias;
• Selama pelatihan, rata-rata pergerakan mean dan var akan disimpan dan kemudian digunakan dalam tahap pengujian.