5Lan truyền ngược và các thuật toán tối ưu#

Huấn luyện một mạng nơ-ron gồm hai việc tách biệt: tính gradient của hàm mất mát theo mọi tham số, và dùng gradient đó để cập nhật tham số. Lan truyền ngược làm việc thứ nhất; SGD, momentum và Adam làm việc thứ hai. Người mới hay gộp hai việc làm một, nói "huấn luyện bằng lan truyền ngược" như thể lan truyền ngược là một thuật toán học. Tách chúng ra giúp trả lời những câu hỏi rất thực tế: vì sao tính gradient của một mô hình hàng tỉ tham số chỉ tốn cỡ ba lần tính hàm mất mát, vì sao huấn luyện tốn bộ nhớ hơn suy luận nhiều, và vì sao Adam phải giữ thêm hai giá trị cho mỗi tham số.

5.1Lan truyền ngược#

Định nghĩa 5.1 (Lan truyền ngược)

Lan truyền ngược (backpropagation) là thuật toán tính gradient của một hàm mất mát vô hướng theo mọi tham số của mạng, bằng cách áp dụng quy tắc dây chuyền theo thứ tự từ đầu ra ngược về đầu vào và dùng lại các giá trị trung gian đã tính ở lượt xuôi.

Lan truyền ngược không phải là thuật toán học. Nó chỉ tính gradient; dùng gradient để cập nhật tham số thế nào là việc của thuật toán tối ưu (Mục 5.4). Hai thành phần độc lập với nhau: cùng một gradient có thể dùng cho SGD hay Adam, và cùng một thuật toán tối ưu nhận được gradient tính bằng lan truyền ngược hay bằng cách khác.

Thuật toán gồm hai lượt. Lượt xuôi tính đầu ra từ đầu vào, lần lượt qua từng lớp, và lưu lại mọi giá trị trung gian: đầu vào của mỗi lớp, giá trị trước và sau hàm kích hoạt. Lượt ngược bắt đầu từ $\partial \mathcal{L}/\partial \mathcal{L} = 1$ và đi ngược qua từng lớp. Với một lớp $z = Wh + b$, $a = \phi(z)$, khi đã có $\delta_a = \partial \mathcal{L}/\partial a$ thì

$$\delta_z = \delta_a \odot \phi'(z), \qquad \frac{\partial \mathcal{L}}{\partial W} = \delta_z\, h^\top, \qquad \frac{\partial \mathcal{L}}{\partial b} = \delta_z, \qquad \delta_h = W^\top \delta_z.$$

Vector $\delta_h$ lại là đầu vào cho lớp phía trước, và mỗi công thức chỉ cần các giá trị $z$, $h$ đã lưu ở lượt xuôi. Rumelhart, Hinton và Williams (1986) phổ biến thuật toán này cho mạng nơ-ron; trong toán học ứng dụng, nó là trường hợp riêng của vi phân tự động chế độ ngược.

Bài giảng CS231n trình bày cùng thuật toán theo một cách dễ hình dung hơn: mỗi phép toán là một cổng, nhận gradient từ phía sau rồi nhân với đạo hàm cục bộ của chính nó. Lấy $f = (a + b)\,c$ với $a = 1$, $b = 2$, $c = -3$. Lượt xuôi cho $q = a + b = 3$ rồi $f = qc = -9$. Lượt ngược bắt đầu từ $\partial f/\partial f = 1$. Cổng nhân đổi chéo: gradient của $c$ là giá trị của đầu vào kia, $q = 3$, còn gradient của $q$ là $c = -3$. Cổng cộng chia đều: $a$ và $b$ cùng nhận nguyên gradient $-3$ của $q$. Cổng max, như trong ReLU, chuyển toàn bộ gradient cho đầu vào lớn hơn và cho đầu vào kia 0. Khi một biến được dùng ở nhiều chỗ, gradient của nó là tổng gradient từ mọi nhánh; Karpathy (2022) minh hoạ bằng $b = a + a$, có đạo hàm 2 chứ không phải 1, và quên cộng dồn là lỗi kinh điển khi tự cài lan truyền ngược.

Ví dụ sau thực hiện đầy đủ một lượt xuôi, một lượt ngược và một bước cập nhật trên mạng nhỏ nhất có lớp ẩn, để thấy từng công thức trên hoạt động thế nào.

Ví dụ 5.1

Mạng có đầu vào $x = (1, 2)$, lớp ẩn 2 đơn vị ReLU và một đầu ra tuyến tính, hàm mất mát $\mathcal{L} = \tfrac12(\hat y - y)^2$ với $y = 1$. Tham số:

$$\begin{gathered} W_1 = \begin{pmatrix} 0{,}1 & 0{,}2 \\ -0{,}3 & 0{,}1 \end{pmatrix}, \quad b_1 = (0, 0), \\ w_2 = (0{,}5;\; -0{,}4), \quad b_2 = 0{,}2. \end{gathered}$$

Lượt xuôi. $z = W_1 x + b_1 = (0{,}1 + 0{,}4;\; -0{,}3 + 0{,}2) = (0{,}5;\; -0{,}1)$. Qua ReLU: $h = (0{,}5;\; 0)$. Đầu ra $\hat y = w_2^\top h + b_2 = 0{,}25 + 0 + 0{,}2 = 0{,}45$. Mất mát $\mathcal{L} = \tfrac12(0{,}45 - 1)^2 = 0{,}15125$.

Lượt ngược. $\partial \mathcal{L}/\partial \hat y = \hat y - y = -0{,}55$. Lớp ra: $\partial \mathcal{L}/\partial w_2 = -0{,}55 \cdot h = (-0{,}275;\; 0)$, $\partial \mathcal{L}/\partial b_2 = -0{,}55$, và $\delta_h = -0{,}55 \cdot w_2 = (-0{,}275;\; 0{,}22)$. Qua ReLU: $\delta_z = \delta_h \odot \mathbb{1}[z > 0] = (-0{,}275;\; 0)$. Lớp ẩn: $\partial \mathcal{L}/\partial W_1 = \delta_z\, x^\top = \begin{pmatrix} -0{,}275 & -0{,}55 \\ 0 & 0 \end{pmatrix}$ và $\partial \mathcal{L}/\partial b_1 = (-0{,}275;\; 0)$.

Kiểm tra bằng sai phân. Tăng rồi giảm $W_1[1,2]$ một lượng $10^{-4}$: mất mát thành $0{,}151195$ và $0{,}151305$, nên đạo hàm xấp xỉ $(0{,}151195 - 0{,}151305)/(2 \cdot 10^{-4}) = -0{,}55$, khớp với lượt ngược.

Cập nhật. Một bước gradient descent với $\eta = 0{,}1$ đưa $\hat y$ từ 0,45 lên 0,606 và mất mát từ 0,151 xuống 0,078.

Ví dụ cho thấy một chi tiết quan trọng: đơn vị ẩn thứ hai có $z_2 = -0{,}1 < 0$, nên đạo hàm của ReLU tại đó bằng 0, và toàn bộ hàng thứ hai của $W_1$ nhận gradient bằng 0. Đơn vị nào không kích hoạt với một đầu vào thì không học được gì từ đầu vào đó. Nếu một đơn vị không kích hoạt với mọi đầu vào, nó không bao giờ được cập nhật nữa; đó chính là đơn vị ReLU chết ở Mục 4.2. Cách kiểm tra bằng sai phân, và cách chọn bước sai phân, được trình bày ở Mục 5.5 của Nền tảng. Khi kiểm tra gradient của cả một mạng, CS231n khuyên dùng sai phân trung tâm như trong ví dụ và so bằng sai số tương đối $|a - n|/\max(|a|, |n|)$ giữa gradient giải tích $a$ và gradient số $n$: dưới $10^{-7}$ là tốt, còn trên $10^{-2}$ thì gần như chắc chắn có lỗi. Phép kiểm tra nên chạy bằng số thực 64 bit, trên vài điểm dữ liệu, và tắt dropout cùng regularization. Với ReLU, các giá trị trước hàm kích hoạt nên cách 0 xa hơn bước sai phân, như $z_2 = -0{,}1$ trong ví dụ, để phép sai phân không vắt qua điểm gãy.

5.2Thứ tự nhân các ma trận Jacobi#

Vì sao phải đi ngược mà không đi xuôi? Theo quy tắc dây chuyền, với mạng $x \to h_1 \to \dots \to h_{L-1} \to \mathcal{L}$ trong đó $\mathcal{L}$ là một số, gradient theo đầu vào là tích các ma trận Jacobi:

$$\frac{\partial \mathcal{L}}{\partial x} = \underbrace{\frac{\partial \mathcal{L}}{\partial h_{L-1}}}_{1 \times m}\;\underbrace{\frac{\partial h_{L-1}}{\partial h_{L-2}}}_{m \times m}\;\cdots\;\underbrace{\frac{\partial h_1}{\partial x}}_{m \times d}.$$

Phép nhân ma trận có tính kết hợp, nên có thể nhân theo bất kỳ thứ tự nào, nhưng chi phí rất khác nhau. Nhân từ trái sang phải, tức chế độ ngược của lan truyền ngược, thì kết quả trung gian luôn là một vector hàng $1 \times m$, và mỗi bước chỉ là một phép nhân vector với ma trận, tốn $O(m^2)$. Nhân từ phải sang trái, tức chế độ xuôi, thì kết quả trung gian là một ma trận $m \times d$, và mỗi bước là một phép nhân ma trận với ma trận, tốn $O(m^2 d)$. Với 10 lớp có $m = d = 1\,000$, chế độ ngược tốn khoảng $10 \times 10^6 = 10^7$ phép nhân, chế độ xuôi khoảng $10 \times 10^9 = 10^{10}$, chênh nhau 1 000 lần, đúng bằng số đầu vào $d$.

Tổng quát hơn, với một hàm từ $n$ đầu vào ra $k$ đầu ra, chế độ ngược tính toàn bộ gradient với chi phí cỡ $k$ lần tính hàm, còn chế độ xuôi cần cỡ $n$ lần (Baydin và cộng sự, 2018). Huấn luyện mạng nơ-ron có $k = 1$, vì hàm mất mát là một số, còn $n$ bằng số tham số, có thể tới hàng tỉ, nên chế độ ngược rẻ hơn hàng tỉ lần. Trên thực tế, một lượt ngược tốn khoảng gấp đôi một lượt xuôi (Mục 12.4), nên tính gradient chỉ tốn cỡ ba lần tính hàm mất mát. Đặt cạnh cách tính bằng sai phân, vốn cần thêm một lượt tính hàm mất mát cho mỗi tham số, tức một triệu lẻ một lượt với một mô hình một triệu tham số (Nielsen, 2015), hai cách chênh nhau hơn trăm nghìn lần.

Ngược lại, khi cần đạo hàm của nhiều đầu ra theo ít đầu vào, chế độ xuôi rẻ hơn. Các thư viện như PyTorch và JAX cài đặt cả hai chế độ.

5.3Bộ nhớ cho lan truyền ngược#

Lượt ngược cần các giá trị trung gian của lượt xuôi, nên chúng phải được giữ trong bộ nhớ cho tới khi lượt ngược dùng xong. Phần bộ nhớ này, gọi là bộ nhớ kích hoạt, tỉ lệ với

$$\text{số lớp} \times \text{kích thước lô} \times \text{độ dài chuỗi} \times \text{bề rộng} \times \text{số byte mỗi số}.$$

Bộ nhớ kích hoạt không tỉ lệ với số tham số mà tỉ lệ với kích thước lô và độ dài chuỗi. Vì vậy khi huấn luyện bị hết bộ nhớ, cách xử lý đầu tiên thường là giảm kích thước lô, không phải thu nhỏ mô hình.

Có hai kỹ thuật đổi thời gian tính lấy bộ nhớ. Gradient checkpointing (Chen và cộng sự, 2016) chỉ lưu giá trị trung gian tại một số lớp mốc; các lớp khác được tính lại từ mốc gần nhất khi lượt ngược cần tới. Đặt mốc cách nhau $\sqrt{L}$ lớp thì bộ nhớ kích hoạt giảm từ $O(L)$ xuống $O(\sqrt L)$, đổi lại phải tính thêm khoảng một lượt xuôi, tức thời gian tăng khoảng một phần ba. Tích luỹ gradient (gradient accumulation) chia một lô lớn thành nhiều lô nhỏ, cộng dồn gradient của các lô nhỏ rồi mới cập nhật một lần. Kết quả tương đương huấn luyện với lô lớn, bộ nhớ chỉ bằng của lô nhỏ, nhưng không nhanh hơn. Có một chi tiết dễ quên: khi mất mát của mỗi lô nhỏ là trung bình trên lô đó, phải chia nó cho số lô nhỏ trước khi cộng dồn, nếu không gradient sẽ lớn gấp từng ấy lần so với khi huấn luyện thật với lô lớn (Karpathy, 2024).

5.4SGD, momentum và Adam#

Có gradient rồi, ta chuyển sang việc thứ hai. Gradient descent cập nhật $\theta_{t+1} = \theta_t - \eta\, g_t$ với $g_t = \nabla_\theta \mathcal{L}(\theta_t)$ (Chương 5 của Nền tảng). Với mạng nơ-ron, $L$ là trung bình trên hàng triệu điểm dữ liệu, nên tính gradient đầy đủ ở mỗi bước là quá đắt. Cách giải quyết là SGD theo mini-batch: ước lượng $g_t$ bằng gradient trên một lô nhỏ $B$ điểm chọn ngẫu nhiên. Ước lượng này không chệch, và phương sai của nó giảm theo $1/B$. Nhiễu của ước lượng không hoàn toàn có hại: nhiều nghiên cứu cho thấy nó giúp tránh một số điểm cực tiểu hẹp và có tác dụng như một dạng regularization, dù cơ chế chính xác vẫn đang được nghiên cứu.

Cải tiến đầu tiên là momentum, giữ một trung bình trượt của các gradient:

$$v_{t+1} = \beta v_t + g_t, \qquad \theta_{t+1} = \theta_t - \eta\, v_{t+1}.$$

Trong một thung lũng hẹp và dài, gradient đổi dấu liên tục theo chiều ngang thung lũng và giữ cùng dấu theo chiều dọc. Trung bình trượt triệt tiêu phần dao động ngang và cộng dồn phần dọc, nên với $\beta = 0{,}9$, bước đi theo hướng ổn định lớn gấp khoảng $1/(1-\beta) = 10$ lần. Mục 5.3 của Nền tảng đã đo được tác dụng này: số vòng lặp giảm từ bậc $\kappa$ xuống bậc $\sqrt\kappa$. CS231n và Andrew Ng cùng dùng hình ảnh một quả bóng lăn xuống dốc có ma sát: gradient đóng vai trò gia tốc, $v$ là vận tốc, còn $\beta$ là hệ số giữ lại vận tốc sau mỗi bước, tức phần bù của ma sát.

Các tài liệu viết momentum theo ba cách sai khác nhau một hệ số. Cách ở trên, $v \leftarrow \beta v + g$, là cách của PyTorch. CS231n viết $v \leftarrow \mu v - \eta g$ rồi cộng thẳng $v$ vào tham số, tương đương với cách trên. Andrew Ng viết $v \leftarrow \beta v + (1 - \beta)\,g$, một trung bình trượt mũ thật sự, nên với cùng $\eta$, bước đi nhỏ hơn $1/(1-\beta)$ lần, tức 10 lần khi $\beta = 0{,}9$. Khi chuyển công thức hay siêu tham số giữa các tài liệu, tốc độ học phải được chỉnh lại theo hệ số đó. Tên "trung bình trượt" cũng có nghĩa cụ thể: với $\beta = 0{,}9$, trọng số của giá trị cách đây 10 bước là $0{,}9^{10} \approx 0{,}35 \approx 1/e$, nên trung bình chủ yếu gồm khoảng $1/(1-\beta) = 10$ giá trị gần nhất.

Adam (Kingma và Ba, 2015) đi xa hơn: giữ trung bình trượt của cả gradient và bình phương gradient, rồi chia từng toạ độ cho căn bậc hai của trung bình bình phương, nên mỗi tham số có một bước đi riêng:

$$m_t = \beta_1 m_{t-1} + (1-\beta_1)\,g_t, \qquad v_t = \beta_2 v_{t-1} + (1-\beta_2)\,g_t^2,$$

$$\hat m_t = \frac{m_t}{1-\beta_1^t}, \qquad \hat v_t = \frac{v_t}{1-\beta_2^t}, \qquad \theta_{t+1} = \theta_t - \eta\,\frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon}.$$

Các giá trị mặc định là $\beta_1 = 0{,}9$, $\beta_2 = 0{,}999$, $\epsilon = 10^{-8}$.

Hai phép chia cho $1 - \beta^t$ gọi là hiệu chỉnh độ chệch (bias correction), và tên gọi này đúng theo nghĩa thống kê của Mục 2.2. Vì khởi tạo $m_0 = 0$, khai triển công thức truy hồi được $m_t = (1-\beta_1)\sum_{i=1}^{t}\beta_1^{t-i} g_i$. Nếu các $g_i$ có cùng kỳ vọng $\mathbb{E}[g]$ thì

$$\mathbb{E}[m_t] = (1-\beta_1)\big(1 + \beta_1 + \dots + \beta_1^{t-1}\big)\,\mathbb{E}[g] = (1 - \beta_1^t)\,\mathbb{E}[g].$$

Như vậy $m_t$ là ước lượng chệch về phía 0 của $\mathbb{E}[g]$, và chia cho $1 - \beta_1^t$ cho ước lượng không chệch. Andrew Ng giảng điều này bằng trung bình trượt của nhiệt độ hằng ngày. Với nhiệt độ ba ngày đầu là 30, 32 và 31 °C và hệ số 0,9, trung bình trượt khởi tạo từ 0 cho 3; 5,9 và 8,41, thấp xa nhiệt độ thật; chia lần lượt cho $1 - 0{,}9 = 0{,}1$, $1 - 0{,}9^2 = 0{,}19$ và $1 - 0{,}9^3 = 0{,}271$ được 30; 31,05 và 31,03. Cùng lập luận cho $\mathbb{E}[v_t] = (1 - \beta_2^t)\,\mathbb{E}[g^2]$. Hai độ chệch này không bù trừ cho nhau, vì $v_t$ bị kéo về 0 mạnh hơn nhiều. Ở bước đầu, $m_1 = 0{,}1\,g_1$ và $v_1 = 0{,}001\,g_1^2$, nên nếu không hiệu chỉnh, bước đi là $\eta \cdot 0{,}1\,g_1/\sqrt{0{,}001\,g_1^2} \approx 3{,}16\,\eta$ theo dấu của $g_1$, trong khi bước đã hiệu chỉnh là đúng $\eta$. Với gradient không đổi, tỉ số giữa hai bước là $(1 - \beta_1^t)/\sqrt{1 - \beta_2^t}$: tăng lên tới khoảng 6,6 quanh bước 12, còn 3,2 ở bước 100 và vẫn còn 1,26 ở bước 1 000, vì $1 - \beta_2^t$ tăng rất chậm. Bỏ hiệu chỉnh vì vậy làm các bước đầu lớn bất thường, không phải nhỏ đi; Kingma và Ba (2015) nêu đúng điều này. Khi $t$ lớn, $\beta^t \to 0$ và phép hiệu chỉnh không còn tác dụng gì.

Cuối cùng, AdamW (Loshchilov và Hutter, 2019) sửa cách Adam xử lý weight decay. Nếu thêm $\lambda\|\theta\|^2$ vào hàm mất mát rồi dùng Adam, gradient của thành phần phạt $2\lambda\theta$ cũng bị chia cho $\sqrt{\hat v_t}$, nên tham số có gradient lớn lại bị phạt ít hơn, ngược với mục đích của regularization. AdamW tách weight decay ra khỏi gradient và trừ trực tiếp $\eta\lambda\theta_t$ ở mỗi bước. AdamW là lựa chọn mặc định khi huấn luyện Transformer. Bảng dưới so sánh hai nhóm thuật toán.

Dòng cuối quan trọng khi huấn luyện mô hình lớn. Adam giữ $m$ và $v$ cho mọi tham số, thường ở FP32. Với mô hình 7 tỉ tham số, riêng trạng thái Adam đã chiếm $7 \times 10^9 \times 2 \times 4 = 56$ GB. Mục 12.5 sẽ tính đầy đủ bộ nhớ huấn luyện.

5.5Lịch tốc độ học#

Tốc độ học là siêu tham số quan trọng nhất khi huấn luyện mạng nơ-ron, và cách thay đổi nó theo thời gian cũng quan trọng gần như vậy. Phần lớn lịch tốc độ học hiện nay bắt đầu bằng warmup: tăng tuyến tính tốc độ học từ gần 0 lên giá trị đích trong vài trăm tới vài nghìn bước đầu. Với Adam, $\hat v_t$ ở các bước đầu được ước lượng từ rất ít gradient nên rất nhiễu, và bước đi có thể lớn bất thường; warmup tránh được những bước như vậy. Warmup cũng cần thiết với Transformer dùng post-LN (Mục 10.2).

Sau warmup, tốc độ học được giảm dần. Lịch phổ biến khi huấn luyện mô hình ngôn ngữ là cosine decay (Loshchilov và Hutter, 2017), giảm tốc độ học theo nửa chu kỳ hàm cosin về gần 0 ở bước cuối. Trong thị giác máy tính, lịch giảm theo bậc thang, tức chia tốc độ học cho 10 tại một số mốc định trước, vẫn còn phổ biến.

Khi tăng kích thước lô lên $k$ lần, gradient ít nhiễu hơn nên có thể dùng tốc độ học lớn hơn. Với SGD, Goyal và cộng sự (2017) dùng quy tắc tuyến tính: nhân tốc độ học với $k$, kèm warmup, và huấn luyện được ResNet-50 trên ImageNet với lô 8 192 ảnh mà không giảm độ chính xác. Với Adam, Malladi và cộng sự (2022) lập luận rằng quy tắc phù hợp là nhân với $\sqrt{k}$. Cả hai là quy tắc kinh nghiệm có cơ sở lý thuyết một phần, và đều không còn đúng khi lô quá lớn.

Một lịch cụ thể cho thấy các thành phần này ghép với nhau ra sao. Khi tái hiện GPT-2 124 triệu tham số, Karpathy (2024) dùng AdamW với $\beta_1 = 0{,}9$, $\beta_2 = 0{,}95$, warmup tuyến tính trong 715 bước lên $6 \times 10^{-4}$, rồi giảm theo cosine xuống $6 \times 10^{-5}$ ở bước 19 073, kèm cắt chuẩn gradient ở 1,0.

Đường mất mát cho biết tốc độ học đang ở mức nào: mất mát gần như không giảm là dấu hiệu tốc độ học quá nhỏ, còn mất mát tăng vọt hoặc thành NaN là dấu hiệu quá lớn. CS231n khuyên theo dõi thêm tỉ số giữa độ lớn của bước cập nhật và độ lớn của tham số, nên ở quanh $10^{-3}$. Và trước khi huấn luyện thật, nên cho mạng khớp hoàn toàn một tập rất nhỏ, chẳng hạn 20 mẫu: một mạng đủ lớn phải đưa được mất mát trên 20 mẫu đó về gần 0, nếu không thì mã có lỗi.

5.6Các hiểu lầm thường gặp#

Bảng dưới gom những hiểu lầm hay gặp về lan truyền ngược và tối ưu.

5.7Tóm tắt#

Lan truyền ngược tính gradient của hàm mất mát theo mọi tham số bằng quy tắc dây chuyền, đi từ đầu ra về đầu vào và dùng lại các giá trị đã lưu ở lượt xuôi; nhìn theo từng cổng, cổng cộng chia đều gradient, cổng nhân đổi chéo, cổng max chuyển gradient cho đầu vào lớn hơn, và gradient của một biến dùng ở nhiều chỗ là tổng các nhánh. Nhân các ma trận Jacobi theo chiều ngược làm mọi kết quả trung gian là vector, nên với hàm mất mát là một số, tính toàn bộ gradient chỉ tốn cỡ ba lần tính hàm. Đổi lại, các giá trị trung gian phải được giữ trong bộ nhớ, và phần bộ nhớ kích hoạt này tăng theo kích thước lô và độ dài chuỗi. Gradient được dùng bởi SGD theo mini-batch, momentum hoặc Adam; Adam chia bước đi theo từng tham số, cần hiệu chỉnh độ chệch ở các bước đầu và giữ hai giá trị trạng thái cho mỗi tham số, còn AdamW tách weight decay khỏi gradient. Momentum được viết theo nhiều quy ước sai khác nhau một hệ số $1/(1-\beta)$, nên phải chỉnh tốc độ học khi đổi quy ước. Tốc độ học thường đi theo lịch warmup rồi giảm dần, và trước khi huấn luyện thật, kiểm tra gradient bằng sai số tương đối và cho mạng khớp một tập rất nhỏ là hai bước kiểm tra rẻ.

Với các công cụ này, ví dụ tính tay đã chạy đúng trên một mạng hai lớp. Khi mạng có hàng chục lớp, một vấn đề mới xuất hiện ngay trong công thức lan truyền ngược: gradient là tích của nhiều ma trận, và tích đó có thể co về 0 hoặc phình ra rất nhanh. Chương 6 xét vấn đề này.