---
title: "Giải tích và tối ưu hóa cho AI Engineer - gradient, chain rule, autodiff, Hessian, gradient descent và Adam"
description: "Đạo hàm, gradient và chain rule là phần toán của mỗi bước train; khóa giải tích này đi từ đó tới autodiff, Hessian, gradient descent, Adam, hàm lồi và lỗi số học của fp16. Học xong, bạn kiểm tra được hàm backward, tính tay SGD và Adam, chọn learning rate có căn cứ và tìm ra vì sao loss thành NaN."
canonical: "https://200lab.io/courses/calculus-and-optimization-for-ai-engineers"
type: "course"
course_type: "course"
learning_type: "free_form"
published: "2026-10-22T02:51:18Z"
students: 1
---

## Khóa học này mang lại gì cho bạn

Ở mỗi bước train model, thư viện tính loss, tính gradient của loss theo từng weight, rồi sửa weight theo update rule (quy tắc cập nhật). Loss là con số đo model sai bao xa, còn gradient cho biết loss đổi bao nhiêu khi nhích riêng từng weight. Khóa học giải thích phần toán đứng sau cả ba việc ấy, từ đạo hàm của hàm một biến tới update rule của Adam, và nói rõ từng kết quả cần điều kiện gì để đúng.

- **Dùng đạo hàm để đo độ nhạy** — Bạn tính đạo hàm, đọc đơn vị của nó và dùng nó để đoán loss đổi bao nhiêu khi weight nhích một chút: với L(w) = w² tại w = 3, nhích w thêm **0,01** thì loss tăng chừng **0,06**, còn mức tăng đúng là **0,0601**. Bạn biết ReLU không có đạo hàm tại 0, và con số mà thư viện trả về tại đó chỉ là quy ước.
- **Đọc gradient của ma trận weight** — Bạn biết gradient có cùng shape với ma trận weight, mỗi ô là đạo hàm riêng theo đúng một weight. Khi loss khả vi tại điểm đang xét và gradient tại đó khác 0, đi ngược hướng gradient là cách làm loss giảm nhanh nhất ở gần điểm ấy, so với mọi hướng đi khác có cùng độ dài.
- **Lần theo mọi đường từ weight tới loss** — Bạn áp dụng chain rule trên graph nhỏ có nhánh: nhân đạo hàm cục bộ dọc mỗi đường rồi cộng kết quả của các đường lại, và cộng dồn gradient ở nút dùng chung thay vì ghi đè. Bạn biết vì sao một lượt backward đã cho gradient của mọi weight khi chỉ có một loss.
- **Kiểm tra hàm backward tự viết** — Bạn so sánh số mà hàm backward trả về với central difference (sai phân trung tâm, độ dốc của đường nối hai điểm nằm hai bên điểm cần kiểm tra, mỗi điểm cách nó một khoảng h) bằng sai lệch tương đối. Bạn chọn tolerance (ngưỡng chấp nhận) có lý do, và biết vì sao h quá nhỏ lại làm kết quả xấu đi.
- **Phân loại điểm dừng bằng Hessian** — Tại điểm có gradient bằng 0, bạn tính Hessian, tức bảng **2** × **2** các đạo hàm riêng bậc hai, từ công thức của loss. Bạn xem các eigenvalue âm hay dương để biết điểm ấy là cực tiểu cục bộ, cực đại cục bộ hay điểm yên ngựa, và ghi “chưa kết luận được” khi có eigenvalue bằng 0.
- **Tính tay từng bước của SGD và Adam** — Bạn tính vài bước gradient descent, tìm ngưỡng learning rate từ độ cong, ước lượng độ nhiễu của gradient theo batch size, tính một bước Adam, rồi đọc lịch warmup và cosine decay.
- **Tìm nguyên nhân khi loss thành NaN** — Bạn biết phép tính nào làm số bị tràn, bị làm tròn về 0 hoặc cho ra NaN, tính softmax bằng log-sum-exp, rồi xét cả dữ liệu, hàm mục tiêu và update rule trước khi đổi kiểu số.

Lần train thật của bạn có nhiều weight hơn hẳn các ví dụ trong khóa và chạy trên framework nào cũng được, nhưng số trong cấu hình optimizer, trên dòng log train hay do hàm backward trả về vẫn đến từ đúng những phép tính vừa kể.

## Khóa học cung cấp những nền tảng nào

Loss đổi bao nhiêu khi một weight nhích đi một chút? Con số trả lời câu hỏi ấy là đạo hàm, và cả bốn chương dựng trên nó. Gradient gom các đạo hàm riêng theo từng weight thành một vector, chain rule tính chúng qua từng bước của phép tính, còn optimizer dùng chúng để chọn bước sửa weight. Mọi điều gradient cho biết chỉ được bảo đảm ở gần điểm đang xét, nên khi weight đã đi xa khỏi điểm ấy, gradient phải được tính lại.

Giáo trình mở [Calculus của Gilbert Strang trên MIT OpenCourseWare](https://ocw.mit.edu/courses/res-18-001-calculus-fall-2023/pages/open-textbook) trình bày đạo hàm, độ dốc và gradient. Bài tổng quan của Baydin và cộng sự, [Automatic Differentiation in Machine Learning: a Survey](https://arxiv.org/abs/1502.05767), trình bày computational graph và autodiff, còn [paper Adam của Kingma và Ba](https://arxiv.org/abs/1412.6980) trình bày Adam cùng bộ hệ số mặc định mà nhiều cấu hình mẫu vẫn dùng.

### 1. Đạo hàm, đạo hàm riêng và gradient

Chiếc ô tô bắt đầu chạy từ chỗ đứng yên và đi được 2t² mét sau t giây. Từ giây 3 tới giây 4, xe đi thêm **14** m, nhưng đồng hồ tốc độ tại giây 3 chỉ **12** m/s. Độ dốc trên những đoạn thời gian ngắn dần quanh giây 3 dồn về đúng con số ấy, và con số ấy là đạo hàm, luôn mang đơn vị của đầu ra trên một đơn vị của đầu vào.

Ở phần tương tác của chủ đề đạo hàm, bạn kéo khoảng thời gian h tính từ giây 3 ngắn dần và thấy đường nối hai điểm trên đồ thị quãng đường xoay quanh điểm giây 3. Đạo hàm chỉ có khi độ dốc ấy dồn về một số duy nhất. Hàm có đồ thị gãy góc tại một điểm thì không khả vi tại điểm ấy, tức là không có đạo hàm ở đó, như ReLU tại 0: độ dốc bên trái là 0, bên phải là 1.

Trên bản đồ địa hình của một quả đồi giả định, bạn đứng ở chỗ mà theo hướng đông, độ dốc là **−40** m/km, còn theo hướng bắc là **−80** m/km. Hai độ dốc ấy là hai đạo hàm riêng, ghép lại thành mũi tên gradient.

Tại chỗ đứng, độ dốc lên khi đi thẳng về đỉnh là xấp xỉ **84,9** m/km, còn khi đi theo mũi tên gradient là xấp xỉ **89,4** m/km. Ở phần tương tác, bạn xoay hướng đi trên bản đồ đường đồng mức để thấy độ dốc lớn nhất nằm đúng theo mũi tên ấy.

Trong model, gradient mà thư viện trả về là một ma trận cùng shape với ma trận weight, như **768** × **3.072**, và mỗi ô là độ dốc của loss khi chỉ nhích đúng weight ở ô ấy. Độ dốc này còn đổi theo đơn vị đo của đầu vào được nhân với weight ấy.

### 2. Chain rule, computational graph và autodiff

Khi trời nóng thêm **1**°C, điều hòa của một ngôi nhà giả định làm hóa đơn mỗi ngày tăng **1.800** đồng, còn tủ lạnh thêm **150** đồng. Chain rule nhân độ nhạy của từng khâu dọc đường qua điều hòa và qua tủ lạnh, rồi cộng hai kết quả thành **1.950** đồng/°C. Với loss (3w + 1)² tại w = 1, weight có mặt ở cả hai thừa số, nên gradient là 12 + 12 = 24; chỉ lần theo một thừa số thì thiếu mất một nửa.

Trong bảng tính tiền làm thêm, ô tổng tính từ số giờ làm và lương theo giờ. Đi xuôi từ từng ô đầu vào, bạn cần **2** lượt tính để có độ nhạy của ô tổng theo hai ô; đi ngược từ ô tổng, chỉ **1** lượt là đủ. Computational graph là cách vẽ phép tính thành các nút nối với nhau; lượt forward tính giá trị, lượt backward truyền đạo hàm ngược về, và nút dùng ở hai chỗ phải cộng dồn gradient của hai nhánh.

Với ma trận weight **768** × **3.072**, forward mode, tức đi xuôi, cần **2.359.296** lượt cho một bước train, còn reverse mode, tức đi ngược, chỉ cần một lượt backward. Lượt ấy tốn cỡ vài lần thời gian của một lượt forward và phải giữ các giá trị trung gian, nhưng vẫn rẻ hơn forward mode rất nhiều. Ở phần tương tác, bạn kéo một đầu vào của graph có ReLU và xem giá trị chạy xuôi, gradient chạy ngược qua từng nút.

Gradient check giống việc dùng chiếc xô **10** lít để kiểm tra đồng hồ nước: vạch xô chỉ chính xác tới **0,05** lít, nên đồng hồ báo **10,04** lít thì chưa kết luận được gì. Nếu hàm backward của x³ bị viết nhầm thành 3x, nó trả về 6 tại x = 2, trong khi central difference cho xấp xỉ 12. Sai lệch tương đối giữa hai số là **0,5**, gấp xấp xỉ **50.000** lần tolerance 10⁻⁵ mà đoạn Python thuần trong bài chọn.

### 3. Hessian, gradient descent, SGD và Adam

Loss w₁² + 3w₁w₂ + w₂² có gradient bằng 0 tại (0, 0), và hai ô trên đường chéo của Hessian đều dương. Vậy mà Hessian có hai eigenvalue **5** và **−1**, nên (0, 0) là điểm yên ngựa: tại (0,1; −0,1), loss đã là −0,01, thấp hơn loss tại chính điểm dừng. Ở phần tương tác, bạn xoay góc nhìn quanh một mặt yên ngựa đơn giản hơn mặt của loss này và thấy mặt ấy cong lên dọc trục này, cong xuống dọc trục kia.

Vòi sen trong ví dụ này là mô hình giả định: nhiệt độ của nước luôn bằng đúng số trên núm nước nóng, ngay sau mỗi lần vặn. Núm đang ở vạch 30, còn bạn cần nước **38**°C, và độ khó chịu khi núm ở vạch w được đo bằng L(w) = (w − 38)².

Mỗi lần, bạn vặn núm một đoạn bằng η nhân độ dốc của L tại vạch đang đứng, theo chiều làm độ khó chịu giảm: η = 0,5 đưa núm tới đúng 38 sau một lần vặn, η = 1 làm núm nhảy qua lại mãi, còn η = 1,1 đẩy núm ra xa dần. Cách vặn ấy chính là gradient descent, và η là learning rate.

Với loss 5w₁² + w₂², độ cong lớn nhất là 10, nên ngưỡng của learning rate là 2/10 = 0,2: η = 0,19 còn hội tụ dù weight đi zigzag, η = 0,21 đã phân kỳ. Ngưỡng này chỉ bảo đảm hội tụ cho hàm bậc hai có cực tiểu và Hessian xác định dương; với loss khác, nó chỉ là ước lượng quanh điểm đang đứng. Bạn kéo thanh learning rate để xem đường đi của weight đổi từ gần như thẳng sang zigzag, rồi văng ra ngoài.

Nếm **4** thìa canh thay vì **1** chỉ làm độ lệch chuẩn của độ mặn trung bình còn một nửa, khi các thìa độc lập với nhau. Gradient tính trên mini-batch cũng vậy: muốn độ nhiễu chỉ còn một nửa so với khi dùng batch **32**, bạn cần batch **128**.

Momentum giữ một trung bình động hàm mũ của gradient, tức mỗi bước giữ phần lớn trung bình cũ và lấy thêm một phần nhỏ của gradient mới, rồi sửa weight theo trung bình ấy. Adam giữ thêm một trung bình như vậy cho bình phương gradient, riêng cho từng weight. Paper Adam đề xuất giữ lại phần **0,9** của trung bình thứ nhất và phần **0,999** của trung bình thứ hai sau mỗi bước, và ghi hai hệ số ấy là β₁ và β₂.

Hai trung bình bắt đầu từ 0 nên lúc đầu bị kéo nhỏ đi, và bias correction là phép chia bù cho việc ấy: ở bước **1.000**, với β₂ = 0,999, hệ số bù vẫn nhân trung bình của bình phương gradient lên xấp xỉ **1,58** lần. Sau bias correction, Adam chia trung bình của gradient cho căn bậc hai của trung bình của bình phương gradient cộng ε, số nhỏ giữ cho mẫu số không quá gần 0, mà paper đề xuất là **10⁻⁸**.

### 4. Hàm lồi, constraint và lỗi số học của số dấu phẩy động

Con chó bị buộc bằng sợi dây **1** m vào cọc ở (0, 0), còn bát thức ăn ở (3, 4), tính bằng mét. Viết giới hạn của sợi dây thành constraint (ràng buộc) x² + y² ≤ 1, thì chỗ gần bát nhất mà con chó tới được là (0,6; 0,8).

Tại đó, gradient của x² + y² phải nhân lên **4** lần mới cân bằng được gradient của bình phương khoảng cách tới bát, và số 4 ấy là nhân tử Lagrange. Ở phần tương tác, bạn kéo dài sợi dây và xem điểm ấy cùng nhân tử đổi theo.

Điểm giữa (0, 0) của hai điểm (1, 1) và (−1, −1) cho thấy loss (w₁w₂ − 1)² không lồi: loss bằng 0 ở hai đầu nhưng bằng 1 ở giữa. Loss của neural network có rất nhiều chỗ weight nhân với weight nên nói chung cũng không lồi, và tính chất “cực tiểu cục bộ là cực tiểu toàn cục” của hàm lồi không dùng được cho loss ấy.

Phạt L2 là cộng thêm vào loss hệ số regularization nhân với bình phương độ dài của vector weight, còn weight decay là mỗi bước nhân weight với một số nhỏ hơn 1 một chút. Hai cách này trùng nhau khi train bằng SGD thông thường, nhưng không trùng khi train bằng Adam, vì phần phạt L2 đi cùng gradient qua phép chia của Adam; AdamW tách weight decay ra khỏi bước Adam.

Trên chiếc máy tính bỏ túi chỉ giữ được **8** chữ số, (10.000.000 + 0,1) − 10.000.000 ra 0, nhưng (10.000.000 − 10.000.000) + 0,1 lại ra 0,1. fp16 cũng chỉ giữ được ít chữ số như thế, và còn có một giới hạn khác: số lớn nhất nó lưu được là **65.504**.

Với ba logit 10, 11, 12, e¹² xấp xỉ **162.755** đã vượt giới hạn ấy và thành inf, nên softmax tính thẳng ở fp16 ra NaN. Nếu trừ logit lớn nhất khỏi cả ba logit rồi mới lấy e mũ, softmax đúng của ba logit là xấp xỉ 0,090; 0,245; 0,665, và đoạn code numpy trong bài làm theo cách ấy ở fp16 thì không còn ra NaN.

## Vì sao 200Lab tạo ra khóa học này

Khi bạn train hoặc fine-tune một model, gần như mọi phép tính đạo hàm đều đã được làm thay. Thư viện tự tính gradient cho từng weight, cấu hình mẫu điền sẵn learning rate và các hệ số của Adam, và bạn có thể chạy xong nhiều lần train mà chưa viết một đạo hàm nào.

Phần toán bị giấu ấy chỉ lộ ra khi một lần train không chạy như mong đợi, hoặc khi bạn phải tự viết hàm backward cho một phép tính mà thư viện chưa có. Lúc ấy, quyết định sửa gì nằm trong tay bạn. Nếu chưa biết con số trên log train đến từ phép tính nào, bạn chỉ còn cách đổi một dòng cấu hình, chạy lại, rồi chờ xem.

Mỗi lần đổi như vậy tốn thêm một lần train. Lần chạy sau trông ổn chưa chắc là nhờ lỗi đã được sửa, nên lỗi cũ có thể theo bạn sang cả những lần train sau. Khi tự tính được gradient, biết ngưỡng của learning rate đến từ đâu và phép tính nào sinh ra NaN, bạn đi ngược từ triệu chứng về đúng phép tính gây ra nó, rồi mới quyết định sửa ở đâu.

200Lab xây dựng khóa học để phần toán ấy không còn nằm khuất sau thư viện và cấu hình mặc định. Với mỗi khái niệm, bạn tự tính tay trên một hàm nhỏ, như loss chỉ có hai weight, để thấy từng bước mà thư viện vẫn làm thay bạn, và bước nào cũng đi kèm điều kiện để kết quả của nó đúng.

## Những vấn đề thường gặp khi tính gradient và cập nhật weight

Khi một lần train có vấn đề, việc dễ làm nhất là chỉnh một dòng cấu hình theo quy tắc ai cũng nhắc, như tăng batch size, đổi optimizer hay đổi kiểu số. Những quy tắc ấy đúng trong vài trường hợp nên nghe rất chắc chắn, còn điều kiện để chúng đúng thì ít khi được nhắc kèm.

- Gradient check khớp ở ba điểm x = 1, 2, 3, và hàm backward được coi là đúng ở mọi điểm — mỗi lần kiểm tra chỉ nói về điểm đã chọn: backward của x³ bị viết thành 3x × |x| khớp ở cả ba điểm ấy, nhưng tại x = −1 trả về −3 thay vì 3.
- Update rule giữ weight đứng yên vì gradient bằng 0, và ghi chú viết weight đã tới cực tiểu — gradient bằng 0 chỉ cho biết đó là điểm dừng; với L(w) = w³, weight đứng yên ở 0, vậy mà loss tại −0,1 là −0,001, thấp hơn loss tại 0.
- Learning rate được tăng lên để loss tới đáy nhanh hơn — với L(w) = w² và weight xuất phát từ w = 3, learning rate 0,1 cho loss 9; 5,76; 3,6864, còn learning rate 1,1 cho 9; 12,96; 18,6624, tức weight đổi dấu và đi xa dần sau mỗi bước.
- Batch size được tăng từ **32** lên **256** để gradient bớt nhiễu đi tám lần — khi các mẫu độc lập, độ lệch chuẩn của gradient chỉ giảm √8 lần, tức xấp xỉ **2,83** lần, còn lượng tính toán mỗi bước tăng khoảng **8** lần nếu chi phí tỉ lệ với số mẫu.
- Learning rate được để nguyên giá trị mẫu vì đã dùng Adam, như thể Adam tự chọn độ dài bước — η vẫn quyết định độ dài bước: ở bước đầu, khi độ lớn gradient của một weight lớn hơn ε nhiều lần, bước Adam của weight ấy dài xấp xỉ η (chưa tính weight decay), nên η gấp đôi thì bước cũng gấp đôi.
- Phạt L1 được thêm vào loss để chắc chắn có weight về đúng 0 — weight có về đúng 0 hay không còn tùy hàm mục tiêu và hệ số phạt: với hai weight x, y và hàm mục tiêu (x − 3)² + (y − 2)², hệ số phạt L1 bằng 1 cho nghiệm (2,5; 1,5), không weight nào bằng 0.
- Loss thành `nan`, và việc đầu tiên người ta làm là đổi từ fp16 sang fp32 — NaN còn đến từ dữ liệu có sẵn giá trị NaN, từ hàm mục tiêu khi xác suất bằng 0 làm ln ra âm vô cùng, loss thành inf rồi một phép như 0 × inf ra NaN, hoặc từ learning rate quá lớn làm weight lớn dần tới khi tràn. Đổi sang fp32 không sửa được hai nguyên nhân đầu, còn với nguyên nhân cuối thì chỉ dời lỗi tới một bước muộn hơn.

Trước khi làm theo một quy tắc nào trong số này, bạn sẽ biết hỏi quy tắc ấy cần điều kiện gì, và điều kiện ấy có đúng với lần train của mình không.

## Bạn sẽ học theo cách nào

- **Đoán trước, rồi mới tính** — Trước mỗi phép tính, bài đặt một câu hỏi để bạn đoán, như chiếc ô tô chạy nhanh cỡ nào ở giây 3 hay phải nếm mấy thìa canh để độ lệch chuẩn còn một nửa. Đoán xong, bạn tính trên số nhỏ để xem câu đoán đúng tới đâu.
- **Đổi một đại lượng, so với phép tính tay** — Ở mỗi phần tương tác, bạn đổi đúng một đại lượng bằng thanh kéo hoặc tay nắm xoay, như h, hướng đi, một đầu vào của graph, góc nhìn, learning rate hay độ dài sợi dây, rồi so hình và số cạnh hình với phép tính vừa làm tay.
- **Định nghĩa đi cùng điều kiện** — Câu định nghĩa nêu luôn điều kiện, như hàm khả vi tại điểm đang xét hay gradient khác 0. Phần cuối bài là vài việc bạn làm trên cấu hình hoặc log train của chính mình.
- **Tự kiểm tra bằng quiz** — Các bài học, trừ bài mở đầu, đều có quiz ở cuối bài.
- **Hai bài mượn từ khóa khác** — Bài về hàm số và đồ thị của khóa Toán học cơ bản cho AI Engineer đứng trước bài đạo hàm, bài về eigenvalue và độ cong của khóa Đại số tuyến tính cho AI Engineer đứng trước bài Hessian, vì bài ngay sau dùng tới chúng. Bạn nên học khóa Toán học cơ bản cho AI Engineer trước; nếu đã học hai khóa ấy, bạn sẽ thấy hai bài này đã hoàn thành.

## Khóa học dành cho ai

1. **AI Engineer** — Đọc update rule trong paper, kiểm tra gradient của hàm tự viết, giải thích vì sao loss dao động, phân kỳ hoặc thành NaN: nghề này đòi những việc ấy từ cả developer mới chuyển sang lẫn sinh viên còn đang học.
2. **Vibe coder muốn đi sâu** — Lúc phải tự đọc log train của một lần fine-tune, bạn sẽ quay lại chương 1 về gradient và chương 3 về optimizer nhiều hơn các chương khác.
3. **AI/Agent Builder** — Khi fine-tune model cho agent, có lúc bạn phải đọc update rule và lịch learning rate viết bằng ký hiệu trong paper về fine-tune hay optimizer; ở chương 3, bạn tính từng công thức ấy bằng số cụ thể.

## Những điều cần lưu ý

- **Dừng ở hàm hai biến và graph vài nút** — Các bài toán đạo hàm, gradient và Hessian tính tay dừng ở hàm tối đa hai biến và graph vài nút; khóa học không có tích phân hay chứng minh hội tụ, cũng không có backprop qua các layer. Thứ bạn nắm chắc là chain rule, gradient và update rule, phần mà backprop qua nhiều layer cũng dùng tới.
- **Kiến thức cần có trước** — Khóa Toán học cơ bản cho AI Engineer đã có đủ phần toán mà khóa học cần, từ lũy thừa, log, eˣ và softmax của **3** điểm số, phương sai của tối đa **5** số, tích vô hướng và độ dài ở **2-3** chiều, phép nhân hai ma trận tối đa **3** × **3**, tới hàm số và đồ thị.
- **Hai khóa có ích nhưng không bắt buộc** — Khóa Đại số tuyến tính cho AI Engineer giúp bạn nắm chắc eigenvalue và condition number, khóa Xác suất thống kê cho AI Engineer giúp bạn nắm chắc standard error. Bài nào cần tới các khái niệm ấy đều nhắc lại chúng tại chỗ.
- **Đọc code, không cần chạy** — Bài gradient check có một đoạn Python thuần, bài softmax ở fp16 có một đoạn numpy, và bạn chỉ cần đọc, không cần chạy hay viết code. Các số về model trong bài là số giả định; khi bạn thay vào số của lần train của mình, phép tính vẫn y nguyên.

## Bắt đầu từ đâu

Loss tăng bao nhiêu lần sau một bước, và learning rate đang là bao nhiêu ở bước **500** của warmup? Bài đầu tiên trả lời hai câu ấy trên một trang ghi chép train giả định, có `lr=3e-4` và loss nhảy từ **2,31** lên **7,95** rồi thành `nan`: loss tăng xấp xỉ **3,44** lần, còn learning rate là 7,5 × 10⁻⁵. Người chưa từng học giải tích vẫn đọc trọn được bài này, vì mọi số trong đó đều tự tính lại được trên giấy.

## Chương trình

- Đạo hàm, gradient và các số liệu trong log train model (miễn phí)

### Đạo hàm, đạo hàm riêng và gradient

- Hàm số, đồ thị và những đường thẳng, đường cong bên trong model · quiz
- Đạo hàm và độ nhạy của loss khi một weight thay đổi (miễn phí) · quiz
- Đạo hàm riêng, gradient và hướng làm loss giảm nhanh nhất (miễn phí) · quiz

### Chain rule, computational graph và autodiff

- Chain rule và cách tính xem một weight ảnh hưởng tới loss bao nhiêu (miễn phí) · quiz
- Computational graph và reverse mode khi tính gradient cho hàng triệu weight · quiz
- Autodiff, gradient check và cách kiểm tra hàm backward bạn tự viết · quiz

### Hessian, gradient descent, SGD và Adam

- Eigenvalue, eigenvector, ma trận đối xứng và độ cong của bề mặt loss · quiz
- Xấp xỉ Taylor, Hessian và điểm yên ngựa trên bề mặt loss · quiz
- Gradient descent và learning rate làm loss giảm, dao động hoặc phân kỳ · quiz
- Stochastic gradient, mini-batch và độ nhiễu của gradient theo batch size · quiz
- Momentum, Adam và bước cập nhật riêng cho từng weight · quiz
- Learning rate schedule, warmup và quyết định dừng train · quiz

### Hàm lồi, constraint và lỗi số học của số dấu phẩy động

- Hàm lồi, constraint và regularization trong loss của model · quiz
- Overflow, underflow, NaN và log-sum-exp khi loss bỗng thành inf giữa lúc train · quiz