Neural Networks: Zero to Hero của Andrej Karpathy

Thông tin trong bài lấy từ trang karpathy.ai/zero-to-hero.html, README của kho karpathy/nn-zero-to-hero và các kho code đi kèm, đọc ngày 11/11/2026. Số sao kho GitHub ghi theo ngày đó.

Khóa này là gì

README của kho nn-zero-to-hero mô tả đây là khóa về mạng nơ-ron bắt đầu từ những điều cơ bản nhất, dưới dạng loạt video YouTube trong đó tác giả và người xem cùng viết code và huấn luyện mạng nơ-ron. Trang karpathy.ai thêm rằng mô hình ngôn ngữ là chỗ rất tốt để học học sâu, vì phần lớn kỹ năng học được chuyển sang các lĩnh vực khác.

Điểm đặc biệt: không có slide hay công thức dựng sẵn. Mọi thứ được viết từ dòng đầu tiên, từ một bộ tính đạo hàm cho số vô hướng tới một mô hình GPT nhỏ. Sau khóa này, các thư viện như PyTorch không còn là hộp đen.

Tám video

Theo README, mỗi bài có mục tiêu riêng:

• Bài 1 dạy lan truyền ngược và huấn luyện mạng nơ-ron, chỉ giả định biết Python cơ bản và nhớ mang máng giải tích phổ thông.
• Bài 2 làm mô hình ngôn ngữ bigram cấp ký tự, giới thiệu torch.Tensor và khung làm mô hình ngôn ngữ: huấn luyện, lấy mẫu, đánh giá hàm mất mát.
• Bài 3 dựng mạng MLP, kèm nhiều kiến thức nền học máy: chỉnh tốc độ học, siêu tham số, chia tập train/dev/test, quá khớp và dưới khớp.
• Bài 4 soi bên trong mạng nhiều tầng: thống kê của kích hoạt và gradient, cách chẩn đoán mạng "bệnh", và BatchNorm.
• Bài 5 tự lan truyền ngược bằng tay qua cả mạng mà không dùng loss.backward(). README nói video này không nhằm để chỉ ngồi xem, và có bài tập trên Google Colab.
• Bài 6 đến 8 đi tới kiến trúc WaveNet, transformer của GPT và thuật toán tách từ BPE.

Các kho code đi kèm

Mỗi phần của khóa gắn với một kho GitHub của tác giả, đều theo giấy phép MIT (số sao xem ngày 11/11/2026):

• karpathy/nn-zero-to-hero (25.476 sao): notebook Jupyter dựng trong từng video, nằm trong thư mục lectures.
• karpathy/micrograd (18.819 sao): bộ tính đạo hàm tự động cho số vô hướng cùng thư viện mạng nơ-ron nhỏ có API giống PyTorch.
• karpathy/makemore (4.551 sao): mô hình ngôn ngữ cấp ký tự, tự hồi quy, dùng cho bài 2 đến 6.
• karpathy/minbpe (11.028 sao): code gọn cho thuật toán Byte Pair Encoding dùng trong tách từ của mô hình ngôn ngữ lớn.

Sau khóa, nhiều người đọc tiếp nanoGPT; nhưng README của nanoGPT có ghi chú tháng 11/2025 rằng kho đã cũ, không còn phát triển, và chỉ sang kho nanochat. Xem thêm bài những repo AI mã nguồn mở nên biết.

Tự viết lại ý tưởng bài 1

Cách kiểm xem bạn hiểu bài 1 chưa: tự viết lại bộ tính đạo hàm mà không nhìn video. Đoạn Python dưới đây là một bản tự viết rất nhỏ theo đúng ý tưởng đó. Mỗi số nhớ các đầu vào tạo ra nó và một hàm đẩy đạo hàm ngược về chúng; hàm lan_truyen_nguoc sắp các nút theo thứ tự tô-pô rồi đi ngược từ đầu ra. Kết quả được đối chiếu với đạo hàm số tính bằng sai phân (f(x + h) - f(x - h)) / 2h.

"""Bộ tính đạo hàm tự động rất nhỏ cho số vô hướng, theo đúng ý tưởng video đầu của Zero to Hero (micrograd).

Tự viết lại để hiểu lan truyền ngược: mỗi phép tính nhớ các đầu vào và cách đẩy đạo hàm ngược về chúng.
Kiểm kết quả bằng đạo hàm số: (f(x + h) - f(x - h)) / 2h.
"""
import math


class So:
    def __init__(self, gia_tri, cha=(), phep=""):
        self.gia_tri = gia_tri
        self.dao_ham = 0.0
        self._cha = cha
        self._phep = phep
        self._lan_nguoc = lambda: None

    def __add__(self, khac):
        khac = khac if isinstance(khac, So) else So(khac)
        kq = So(self.gia_tri + khac.gia_tri, (self, khac), "+")

        def lan_nguoc():
            self.dao_ham += kq.dao_ham          # d(a+b)/da = 1
            khac.dao_ham += kq.dao_ham
        kq._lan_nguoc = lan_nguoc
        return kq

    def __mul__(self, khac):
        khac = khac if isinstance(khac, So) else So(khac)
        kq = So(self.gia_tri * khac.gia_tri, (self, khac), "*")

        def lan_nguoc():
            self.dao_ham += khac.gia_tri * kq.dao_ham   # d(a*b)/da = b
            khac.dao_ham += self.gia_tri * kq.dao_ham
        kq._lan_nguoc = lan_nguoc
        return kq

    __radd__ = __add__
    __rmul__ = __mul__

    def tanh(self):
        t = math.tanh(self.gia_tri)
        kq = So(t, (self,), "tanh")

        def lan_nguoc():
            self.dao_ham += (1 - t * t) * kq.dao_ham     # d tanh(x)/dx = 1 - tanh(x)^2
        kq._lan_nguoc = lan_nguoc
        return kq

    def lan_truyen_nguoc(self):
        """Sắp xếp các nút theo thứ tự tô-pô rồi đi ngược từ đầu ra về đầu vào."""
        thu_tu, da_tham = [], set()

        def tham(n):
            if n not in da_tham:
                da_tham.add(n)
                for c in n._cha:
                    tham(c)
                thu_tu.append(n)
        tham(self)
        self.dao_ham = 1.0
        for n in reversed(thu_tu):
            n._lan_nguoc()


def no_ron(x1, x2, w1, w2, b):
    """Một nơ-ron: tanh(x1*w1 + x2*w2 + b)."""
    return (x1 * w1 + x2 * w2 + b).tanh()


def dao_ham_so(f, dau_vao, i, h=1e-6):
    cong = list(dau_vao)
    tru = list(dau_vao)
    cong[i] += h
    tru[i] -= h
    return (f(*cong) - f(*tru)) / (2 * h)


def chay_thu():
    vao = [2.0, 0.0, -3.0, 1.0, 6.8813735870195432]
    ten = ["x1", "x2", "w1", "w2", "b"]
    bien = [So(v) for v in vao]
    ra = no_ron(*bien)
    ra.lan_truyen_nguoc()
    f = lambda *v: math.tanh(v[0] * v[2] + v[1] * v[3] + v[4])
    dong = [f"đầu ra = {ra.gia_tri:.4f}"]
    for i, (t, b) in enumerate(zip(ten, bien)):
        dong.append(f"d/d{t:<2} = {b.dao_ham:+.4f}   (đạo hàm số {dao_ham_so(f, vao, i):+.4f})")
    print("\n".join(dong))
    return dong


if __name__ == "__main__":
    chay_thu()

Với một nơ-ron tanh(x1*w1 + x2*w2 + b), đầu ra là 0,7071, và năm đạo hàm do lan truyền ngược tính ra (-1,5; 0,5; 1; 0; 0,5) khớp với đạo hàm số đến bốn chữ số thập phân. Hai chi tiết dễ sai khi tự viết: đạo hàm phải được cộng dồn khi một số được dùng nhiều lần (như a*a + a), và phải đi ngược theo đúng thứ tự tô-pô.

Cần chuẩn bị gì

Trang khóa ghi cần lập trình Python vững và toán nhập môn (đạo hàm, phân phối Gauss). Cụ thể hơn:

• Python: lớp và phương thức, hàm lồng nhau, danh sách, từ điển. Bài 1 dùng nạp chồng toán tử (__add__, __mul__).
• Toán: quy tắc chuỗi của đạo hàm, xác suất cơ bản, nhân ma trận. Bài toán cho AI gom lại các phần này.
• Công cụ: Jupyter hoặc Google Colab; từ bài 2 cần PyTorch.

Nếu chưa học học máy lần nào, có thể học Machine Learning Specialization hoặc một khóa nhập môn trước; xem tài liệu học AI miễn phí. Nhiều người cũng học Zero to Hero song song với một khóa có bài tập được chấm.

Học thế nào cho hiệu quả

1. Gõ lại, không chép. Mở notebook trống, gõ theo video. Khi tác giả sắp viết một đoạn, tạm dừng và tự thử trước.
2. Làm bài tập trong mô tả video. README nói rõ mỗi bài có bài tập; bài 5 còn có notebook Colab riêng.
3. Ghi lại điều mới sau mỗi video: một khái niệm, một lỗi bạn mắc, một mẹo chẩn đoán.
4. Chia nhỏ. Một video hai giờ có thể là ba, bốn buổi học. Dừng ở chỗ code chạy được.
5. Đổi dữ liệu. Bài 2 dùng danh sách tên tiếng Anh; thử thay bằng danh sách tên tiếng Việt hay tên địa danh để xem mô hình sinh ra gì.

Gợi ý kế hoạch 8 tuần

Một kế hoạch cho người học khoảng 6 đến 8 giờ mỗi tuần, mỗi tuần một video và phần tự làm đi kèm:

Phần "tự làm" là gợi ý của bài viết này, không phải bài tập chính thức của khóa; bài tập chính thức nằm trong mô tả từng video. Đến cuối tuần 8, bạn có một dự án nhỏ để đưa lên GitHub.

Câu hỏi thường gặp

Học tiếp

• Toàn cảnh tài liệu học AI theo bậc: tài liệu học AI miễn phí.
• Ôn phần toán dùng trong khóa: toán cho AI.
• Các kho AI nên đọc tiếp: những repo AI mã nguồn mở nên biết.

Nếu bạn muốn học Python và AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Nguồn tham khảo

• Andrej Karpathy: Neural Networks: Zero to Hero
• karpathy/nn-zero-to-hero (notebook các bài)
• karpathy/micrograd
• karpathy/makemore
• karpathy/minbpe