Python từ cơ bản đến nâng cao
& nền tảng AI / Machine Learning

Ý cốt lõi

• Mọi thứ trong Python đều là đối tượng (object) sống trên vùng nhớ heap. Mỗi đối tượng có 3 thứ: định danh (id — địa chỉ), kiểu (type) và giá trị (value).
• Biến chỉ là một cái tên (nhãn) trỏ tới đối tượng — gọi là tham chiếu (reference). Gán biến này cho biến kia = hai nhãn cùng dán lên một đối tượng, không hề sao chép dữ liệu.
• Python là kiểu động (dynamic typing): kiểu thuộc về đối tượng, không thuộc về biến. Cùng một tên có thể trỏ sang số, rồi sang chuỗi, bất cứ lúc nào.
• Phân biệt sống còn: mutable (thay đổi được tại chỗ: list, dict, set) và immutable (không đổi được: int, float, str, tuple). "Thay đổi" một immutable thực ra là tạo đối tượng mới rồi dán lại nhãn.

a = [1, 2, 3]
b = a              # thêm MỘT NHÃN lên cùng list — không hề sao chép dữ liệu
b.append(4)
print(a)           # [1, 2, 3, 4] — sửa qua b mà a cũng đổi, vì là cùng một đối tượng

c = a.copy()       # muốn độc lập phải copy chủ động
print(a == c)      # True  — == so sánh GIÁ TRỊ
print(a is c)      # False — is kiểm tra có phải CÙNG một đối tượng không

x = 42
y = "42"                      # trông giống hệt nhưng là HAI KIỂU khác nhau

print(type(x), type(y))       # int và str — kiểu nằm ở ĐỐI TƯỢNG, không nằm ở tên biến
print(x + 1)                  # 43   — cộng số
print(y + "1")                # "421" — nối chuỗi, KHÔNG phải 43

isinstance(x, int)            # True  — cách kiểm tra kiểu an toàn (tính cả kế thừa)
x is y                        # False — khác đối tượng; x == y cũng False — khác cả giá trị lẫn kiểu

x = "bốn mươi hai"            # cùng TÊN biến, gán lại = đổi sang đối tượng khác kiểu hẳn
print(type(x))                # str — bằng chứng của kiểu động: tên không "giữ" kiểu nào cả

Các kiểu dữ liệu gốc

Ý cốt lõi

• Thụt lề là cú pháp. Python dùng khoảng trắng để chia khối lệnh — thụt sai là sai chương trình. Chuẩn: 4 dấu cách, không trộn tab.
• Rẽ nhánh: if / elif / else; so khớp mẫu match (3.10+) cho nhiều trường hợp theo cấu trúc.
• Vòng lặp: for duyệt qua một dãy/đối tượng duyệt được (iterable); while lặp theo điều kiện. break thoát vòng, continue bỏ qua lượt này, else của vòng lặp chạy khi vòng kết thúc tự nhiên (không bị break).
• Truthiness: mọi đối tượng đều có giá trị đúng/sai ngầm — 0, chuỗi rỗng, list rỗng, None đều là falsy. Nhờ vậy điều kiện viết gọn theo "có dữ liệu hay không".
• Comprehension — cách viết gọn để biến đổi/lọc một dãy thành list/dict/set mới trong một dòng biểu thức. Là "khẩu vị" đặc trưng của Python: thay vòng lặp + append dài dòng.
• Xử lý lỗi bằng try / except / else / finally: tách luồng bình thường khỏi luồng lỗi; finally luôn chạy (để dọn dẹp tài nguyên).

# Cách vòng lặp tường minh
squares = []
for n in range(10):
    if n % 2 == 0:
        squares.append(n * n)

# Comprehension — cùng kết quả, đọc như một câu mô tả
squares = [n * n for n in range(10) if n % 2 == 0]

# Tra cứu bằng dict: O(1), thay cả chuỗi if/elif dài
menu = {"pho": 50_000, "com": 40_000}
total = menu.get("bun", 0)   # .get có giá trị mặc định → không văng lỗi KeyError khi thiếu món

Chọn cấu trúc dữ liệu theo việc

Ý cốt lõi

• Hàm trong Python là đối tượng hạng nhất (first-class): gán cho biến được, truyền làm tham số được, trả về từ hàm khác được, nhét vào list/dict được. Đây là nền của callback, decorator và lập trình hàm.
• Tham số truyền theo cơ chế "truyền tham chiếu của đối tượng" (pass by object reference): hàm nhận cùng đối tượng với bên ngoài — sửa mutable bên trong hàm thì bên ngoài thấy; gán lại tên thì không.
• Các loại tham số: vị trí, theo tên (keyword), giá trị mặc định, *args (gom số lượng tuỳ ý theo vị trí), **kwargs (gom theo tên), và ép buộc keyword-only / positional-only để API rõ ràng.
• Scope LEGB — thứ tự tìm tên khi dùng một biến: Local (trong hàm) → Enclosing (hàm bao ngoài) → Global (cấp module) → Built-in (hàm sẵn có). Không thấy ở cả 4 nơi → lỗi NameError.
• Closure: hàm con "nhớ" được biến của hàm cha ngay cả khi hàm cha đã chạy xong — cơ chế đứng sau decorator và callback giữ trạng thái.

def add(item, box=[]):   # BUG KINH ĐIỂN: giá trị mặc định chỉ tạo MỘT LẦN
    box.append(item)      # rồi dùng chung cho mọi lần gọi sau
    return box

add("a")   # ['a']
add("b")   # ['a', 'b'] — dữ liệu rò rỉ giữa các lần gọi!

def add(item, box=None):  # cách đúng: mặc định None, tạo mới bên trong
    if box is None:
        box = []
    box.append(item)
    return box

def make_counter():
    count = 0                       # biến ENCLOSING — thuộc hàm cha, không phải global

    def step():                     # hàm con
        nonlocal count              # khai báo: tôi sửa biến của hàm CHA (tầng E trong LEGB)
        count += 1
        return count

    return step                     # trả hàm con ra ngoài

c = make_counter()
c()   # 1
c()   # 2 — hàm cha ĐÃ chạy xong từ lâu, nhưng biến count vẫn "sống"
      # trong closure của step. Mỗi lần make_counter() là một count độc lập riêng.

Ý cốt lõi

• Class là bản thiết kế; instance (thể hiện/đối tượng) là sản phẩm theo bản thiết kế đó. Thuộc tính của instance nằm trong từ điển riêng của từng đối tượng; thuộc tính của class dùng chung cho mọi instance.
• Phương thức đặc biệt (dunder, hai gạch dưới) để đối tượng "hoà nhập" với ngôn ngữ: khởi tạo, biểu diễn chuỗi, so sánh, độ dài, toán tử, duyệt, gọi như hàm… Biết đọc dunder là đọc được ý đồ của mọi thư viện.
• Kế thừa (inheritance): class con hưởng lại và mở rộng class cha. Thứ tự tìm phương thức khi có đa kế thừa gọi là MRO — Python tính bằng thuật toán C3, quyết định "bản nào thắng".
• Đa hình (polymorphism) kiểu Python là duck typing: không quan trọng đối tượng "là gì", chỉ cần "làm được việc gì" (có đúng phương thức cần gọi). "Nếu nó đi như vịt, kêu như vịt…"
• Đóng gói trong Python dựa trên quy ước, không cưỡng chế: tên bắt đầu bằng một gạch dưới = "nội bộ, đừng đụng"; hai gạch dưới = name mangling (đổi tên tránh trùng khi kế thừa).
• Dataclass: sinh tự động các phương thức nhàm chán (khởi tạo, so sánh, in) cho class chủ yếu chứa dữ liệu — chuẩn hiện đại thay cho class viết tay dài dòng. Họ hàng: NamedTuple (bản ghi immutable), Enum (tập giá trị cố định có tên).

from dataclasses import dataclass

@dataclass
class Robot:                     # dataclass tự sinh __init__, __repr__, __eq__
    name: str
    battery: float = 100.0       # thuộc tính có giá trị mặc định

    def move(self):              # phương thức: hành vi sống ở class, dùng chung
        return f"{self.name} đang di chuyển với pin {self.battery}%"

r = Robot("PuPu")                # mỗi instance giữ DỮ LIỆU RIÊNG (name, battery)
print(r.move())

Ý cốt lõi

• Module = một file .py; package = một thư mục các module. Import một module = chạy file đó một lần rồi ghi vào bộ nhớ đệm (sys.modules) — import lại lần hai không chạy lại.
• Đoạn khởi động if __name__ == "__main__": phân biệt "file được chạy trực tiếp" với "file được import" — code để trong khối này chỉ chạy khi chạy trực tiếp.
• Thứ tự tìm module khi import: thư mục hiện hành → các đường dẫn trong biến môi trường PYTHONPATH → thư viện chuẩn → site-packages (nơi pip cài). Hiểu thứ tự này là hiểu mọi lỗi "ModuleNotFoundError" và lỗi "import nhầm file trùng tên".
• Import tuyệt đối (đường dẫn đầy đủ từ gốc package) rõ ràng hơn import tương đối (dấu chấm) — chuẩn cộng đồng ưu tiên tuyệt đối.
• Thư viện chuẩn ("batteries included") cần biết mặt: xử lý file/đường dẫn (pathlib), thời gian (datetime), JSON, biểu thức chính quy (re), toán (math/statistics), bộ sưu tập nâng cao (collections), chạy lệnh hệ thống (subprocess), mạng (http/urllib), nén, log (logging)…

# File geometry.py — một module
import math

def circle_area(r):
    return math.pi * r * r

if __name__ == "__main__":
    # Khối này CHỈ chạy khi chạy trực tiếp:  python geometry.py
    # Khi file khác "import geometry", __name__ là "geometry" → khối này bị bỏ qua
    print(circle_area(2))

Ý cốt lõi

• Mỗi đối tượng có một bộ đếm tham chiếu (refcount): có bao nhiêu tên/biến/container đang trỏ tới nó. Đếm về 0 → đối tượng bị huỷ ngay lập tức và trả bộ nhớ. Đây là cơ chế dọn rác chính của CPython.
• Điểm mù của refcount: vòng tham chiếu (A trỏ B, B trỏ A) — đếm không bao giờ về 0 dù không ai dùng nữa. GC thế hệ (generational garbage collector) chạy định kỳ để phát hiện và dọn các vòng này. Vật chứa được chia 3 "thế hệ": càng sống lâu càng ít bị quét — vì đa số đối tượng chết trẻ.
• Interning: số nguyên nhỏ (−5…256) và chuỗi ngắn phổ biến được tạo sẵn và dùng chung — vì vậy is đôi khi "đúng tình cờ" với số nhỏ/chuỗi ngắn. Không bao giờ dựa vào điều đó.
• Copy: shallow copy sao lớp vỏ ngoài, các đối tượng con bên trong vẫn dùng chung; deep copy sao đệ quy toàn bộ cây đối tượng (chậm, nặng). Mặc định của gán là không copy gì cả.
• Weak reference (tham chiếu yếu): trỏ tới đối tượng mà không tăng refcount — dùng cho cache, tránh vòng tham chiếu, tránh giữ đối tượng sống quá lâu.
• Call stack vs heap: mỗi lần gọi hàm tạo một frame trên stack chứa biến cục bộ (là các tham chiếu); đối tượng thật nằm trên heap. Đệ quy sâu → tràn stack (RecursionError, giới hạn mặc định ~1000).

import sys, copy

a = [1, 2, 3]
sys.getrefcount(a)   # có bao nhiêu nhãn/container đang trỏ tới list này
b = a                # refcount +1 — vẫn là MỘT list duy nhất
del b                # refcount −1; khi về 0, đối tượng bị huỷ ngay

shallow = copy.copy(a)      # shallow: sao lớp vỏ ngoài, phần tử con vẫn dùng chung
deep = copy.deepcopy(a)     # deep: sao đệ quy toàn bộ cây đối tượng

Ý cốt lõi

• Iterator: giao thức "lấy phần tử tiếp theo" — mọi vòng for thực chất gọi lặp lại next() cho đến khi nhận tín hiệu hết (StopIteration). Bất cứ thứ gì tuân thủ giao thức này đều duyệt được.
• Generator: hàm dùng yield — không chạy một mạch mà đóng băng tại mỗi yield, trả một giá trị rồi chờ được gọi tiếp, giữ nguyên trạng thái cục bộ. Nhờ vậy tạo ra dãy dữ liệu "lười": sinh từng phần tử khi cần, tốn RAM hằng số dù dãy dài vô hạn.
• Generator expression và nguyên lý lazy evaluation: chỉ tính khi bị ép (bị duyệt/hỏi len/chuyển thành list). Chuỗi xử lý lười = pipeline dữ liệu lớn không tràn RAM.
• Decorator: một hàm nhận một hàm và trả về một hàm (thường là hàm bọc có thêm hành vi: đo thời gian, log, kiểm tra quyền, cache, retry). Cách áp dụng bằng ký hiệu @ chỉ là đường tắt của việc gán lại tên hàm qua hàm bọc. Decorator có tham số = một lớp bọc nữa bên ngoài.
• Context manager (câu lệnh with): giao thức "vào thì mở — ra thì chắc chắn đóng/dọn", kể cả khi có lỗi giữa chừng. Nền tảng cho mở file, khoá thread, giao dịch CSDL, đo thời gian…
• Descriptor & property: cơ chế phía sau thuộc tính "biết tự tính toán/tự kiểm tra" khi được truy cập; metaclass là tầng sâu hơn nữa (class của class) — biết tồn tại, hiếm khi cần tự viết.

def big_lines(path):
    with open(path) as f:      # with: đóng file chắc chắn, kể cả khi có lỗi
        for line in f:
            yield line.strip() # yield: đóng băng tại đây, giữ nguyên trạng thái,
                               # chỉ sinh 1 dòng khi được gọi tiếp → RAM hằng số

for line in big_lines("server.log"):   # duyệt file vài GB cũng không tràn RAM
    ...

import functools, time

def timing(fn):                          # decorator = hàm nhận một hàm, trả về một hàm
    @functools.wraps(fn)                 # giữ nguyên tên + docstring của hàm gốc
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        result = fn(*args, **kwargs)     # chạy hàm gốc
        print(fn.__name__, "mất", round(time.perf_counter() - t0, 3), "giây")
        return result
    return wrapper

@timing                                  # tương đương: process = timing(process)
def process():
    ...

Phân biệt 3 khái niệm hay bị trộn

• Concurrency (đồng thời): nhiều việc tiến triển xen kẽ trong cùng khoảng thời gian — không nhất thiết chạy cùng một tích tắc. Mục tiêu: không để thời gian chờ bị lãng phí.
• Parallelism (song song): nhiều việc chạy đúng cùng lúc trên nhiều nhân CPU. Mục tiêu: tính nhanh hơn.
• Phân loại việc: CPU-bound (giới hạn bởi tính toán: nén ảnh, train model) và I/O-bound (giới hạn bởi chờ: mạng, ổ đĩa, API). Chọn sai công cụ cho loại việc là sai lầm số một.

GIL — "ổ khoá toàn cục" của CPython

• GIL (Global Interpreter Lock) là một ổ khoá duy nhất: tại một thời điểm, chỉ một thread được chạy bytecode Python trong một tiến trình. Các thread thay phiên nhau giữ khoá (chuyển đổi mỗi ~5ms hoặc khi thread chờ I/O).
• Hậu quả: thread không tăng tốc việc CPU-bound bằng Python thuần (thậm chí chậm hơn vì tranh khoá), nhưng rất hiệu quả cho I/O-bound vì khi một thread chờ mạng/đĩa, nó nhả khoá cho thread khác chạy.
• Ngoại lệ: thư viện viết bằng C như NumPy nhả GIL khi tính toán nặng → thread vẫn song song thật được trên phần tính đó. Python 3.13+ có bản dựng free-threaded (bỏ GIL) dạng tuỳ chọn — đang trưởng thành, chưa phải mặc định.

Ba công cụ, ba cơ chế

Vòng đời async — event loop chạy thế nào

• Coroutine là hàm "tạm dừng được": gọi hàm async không chạy ngay mà tạo ra một đối tượng coroutine; nó chỉ chạy khi được await hoặc được giao cho event loop.
• Event loop là người điều phối duy nhất: chạy một coroutine tới điểm await (chờ I/O) thì treo nó lại, chuyển sang coroutine khác đang sẵn sàng; khi I/O xong, I/O đánh thức coroutine cũ quay lại hàng đợi.
• Toàn bộ diễn ra trên một thread: không tranh chấp bộ nhớ, không cần lock — đổi lại, một đoạn tính toán dài không có await sẽ "độc chiếm" vòng lặp và đóng băng mọi tác vụ khác.

Đồng bộ hoá & lỗi kinh điển

• Race condition: kết quả phụ thuộc thứ tự chạy không kiểm soát của các thread khi cùng sửa dữ liệu chung. Phòng bằng Lock (một thread vào vùng tới hạn tại một thời điểm), RLock, Semaphore (giới hạn số lượng), Event/Condition (chờ tín hiệu).
• Deadlock: các thread chờ khoá của nhau thành vòng tròn — không ai nhả, tất cả treo vĩnh viễn. Phòng: luôn lấy nhiều khoá theo cùng một thứ tự cố định, giữ khoá càng ngắn càng tốt.
• Queue là cách chia sẻ an toàn được ưa chuộng nhất giữa thread/process: mô hình nhà sản xuất → hàng đợi → người tiêu thụ, thay vì cùng sờ vào một biến.
• API mức cao nên dùng trước: ThreadPoolExecutor / ProcessPoolExecutor (quản lý sẵn một bể thread/process, giao việc và nhận kết quả dạng Future) thay vì tự tạo/quản thread thủ công.

from concurrent.futures import ThreadPoolExecutor
import requests

urls = ["https://example.com"] * 20     # 20 việc chủ yếu là CHỜ mạng (I/O-bound)

def page_size(url):
    return len(requests.get(url).content)

with ThreadPoolExecutor(max_workers=10) as pool:
    sizes = list(pool.map(page_size, urls))
# Khi một thread chờ mạng, nó NHẢ GIL cho thread khác chạy → tổng thời gian rút mạnh.
# Nếu thay bằng tính toán thuần Python, thread KHÔNG nhanh hơn tuần tự vì GIL.

from concurrent.futures import ProcessPoolExecutor

def heavy(n):
    return sum(i * i for i in range(n))   # tính toán THUẦN Python — việc CPU-bound

if __name__ == "__main__":                 # bắt buộc khi spawn tiến trình con (nhất là trên Windows)
    with ProcessPoolExecutor() as pool:
        results = list(pool.map(heavy, [10**7] * 4))

# Khác thread ở điểm sống còn: mỗi tiến trình có BỘ NHỚ RIÊNG + GIL RIÊNG
# → 4 việc chạy song song THẬT trên 4 nhân CPU. Đổi lại: tham số và kết quả
# phải được pickle (tuần tự hoá) để chuyển qua lại giữa các tiến trình.

import asyncio, aiohttp

async def fetch(session, url):
    async with session.get(url) as resp:   # gặp await → treo task này,
        return len(await resp.read())      # event loop chuyển sang task khác

async def main():
    async with aiohttp.ClientSession() as s:
        sizes = await asyncio.gather(*(fetch(s, u) for u in urls))  # cả loạt chạy đồng thời

asyncio.run(main())   # quên await = coroutine không bao giờ chạy — lỗi async kinh điển

Ý cốt lõi

• Type hint là chú thích kiểu cho biến/tham số/giá trị trả về. Trình thông dịch bỏ qua chúng lúc chạy (trừ vài thư viện dùng để kiểm tra dữ liệu thật); giá trị của chúng là cho: công cụ kiểm tra tĩnh (mypy, pyright), IDE gợi ý, và người đọc code.
• Các khối xây dựng: kiểu gốc, kiểu container có tham số (list của int, dict từ str sang float…), Optional (có thể là None), Union (một trong nhiều kiểu), Literal (chỉ nhận đúng vài giá trị), Any (tắt kiểm tra — dùng càng ít càng tốt).
• Generic (tham số kiểu): viết hàm/class dùng được cho nhiều kiểu mà vẫn giữ liên hệ kiểu giữa đầu vào–đầu ra (ví dụ: hàm nhận list[T] trả về T).
• Protocol = "kiểu cấu trúc": một đối tượng được coi là hợp lệ nếu có đủ phương thức cần thiết, không cần kế thừa khai báo — typing hoà hợp với duck typing nhờ cơ chế này. Ngược lại, ABC (lớp cơ sở trừu tượng) là kiểu danh nghĩa: phải kế thừa mới tính.
• TypedDict / dataclass + thư viện kiểm định (như Pydantic): khi dữ liệu đến từ bên ngoài (API, file, người dùng), typing tĩnh không đủ — cần kiểm tra thật lúc chạy và ép kiểu tại "biên" của hệ thống.

from typing import Optional, Protocol

def find_user(user_id: int) -> Optional[dict[str, str]]:
    # Trả thông tin user — hoặc None nếu không thấy.
    # None NẰM TRONG hợp đồng kiểu → người gọi buộc phải xử lý trường hợp đó.
    ...

class Drawable(Protocol):
    # Protocol = kiểu cấu trúc: đối tượng nào CÓ method draw() đều hợp lệ,
    # không cần kế thừa khai báo — duck typing nhưng có kiểm tra tĩnh
    def draw(self) -> None: ...

Ý cốt lõi

• Kim tự tháp test: nhiều unit test (nhỏ, nhanh, kiểm một hàm/class độc lập) ở đáy; ít hơn integration test (các phần ghép nhau, DB/API thật); rất ít end-to-end test (toàn hệ thống như người dùng thật) ở đỉnh — vì càng lên cao càng chậm, càng dễ vỡ vặt.
• Mỗi test theo nhịp AAA: Arrange (chuẩn bị) → Act (thực hiện) → Assert (khẳng định kết quả). Một test kiểm một hành vi; tên test đọc như một câu mô tả hành vi.
• Fixture (pytest): bộ dựng dữ liệu/môi trường dùng chung, tự dọn dẹp sau test. Parametrize: chạy cùng một test với nhiều bộ dữ liệu — thay cho việc viết nhiều test na ná nhau.
• Mock/double: thay thế phụ thuộc ngoài (API, DB, thời gian, ngẫu nhiên) bằng bản giả có kiểm soát để test nhanh, ổn định, không phụ thuộc mạng. Quy tắc: mock ở biên hệ thống, đừng mock chính logic cần kiểm.
• Coverage (độ phủ) chỉ cho biết code nào chưa từng được chạy bởi test — không đo chất lượng khẳng định. Phủ 100% vẫn có thể đầy bug.
• TDD (viết test trước): đỏ → xanh → tái cấu trúc. Hữu ích nhất cho logic rõ ràng, thuật toán, sửa bug (viết test tái hiện bug trước, sửa sau).

import pytest

@pytest.mark.parametrize("n, expected", [(0, 0), (1, 1), (5, 120)])
def test_factorial(n, expected):   # parametrize: 1 test chạy với nhiều bộ dữ liệu
    assert factorial(n) == expected

@pytest.fixture                    # fixture: dựng môi trường dùng chung, tự dọn sau test
def sample_user():
    return {"name": "An", "age": 20}

def test_is_adult(sample_user):
    assert is_adult(sample_user) is True

Ý cốt lõi

• Môi trường ảo (venv): mỗi project một "hộp" riêng chứa Python + thư viện của riêng nó — tránh xung đột phiên bản giữa các project và với hệ điều hành. Nguyên tắc bất di bất dịch: không bao giờ cài thư viện vào Python hệ thống.
• pip & PyPI: pip là trình cài; PyPI là kho thư viện công cộng. File khai báo phụ thuộc (requirements / pyproject) + lock file ghim đúng phiên bản để mọi máy cài ra y hệt nhau ("reproducible").
• pyproject.toml là trung tâm cấu hình hiện đại của một project Python: metadata gói, phụ thuộc, cấu hình công cụ (format, lint, test) — thay cho rừng file rời ngày xưa.
• Đóng gói: sdist (mã nguồn) và wheel (bản đã build, cài nhanh) là hai định dạng phát hành lên PyPI. Công cụ quản lý hiện đại đáng biết: uv (cài/gói siêu nhanh), Poetry, Hatch.
• Cấu trúc project chuẩn: mã nguồn trong thư mục gói (hoặc layout src/ để tránh import nhầm bản chưa cài), test trong thư mục riêng, README, .gitignore, biến bí mật trong file .env (không commit lên git).

# pyproject.toml — trung tâm cấu hình của một project Python
[project]
name = "my-package"
version = "1.2.0"                    # SemVer: MAJOR.MINOR.PATCH
requires-python = ">=3.11"
dependencies = ["requests>=2.31"]    # thư viện cần khi chạy thật

[project.optional-dependencies]
dev = ["pytest", "ruff"]             # chỉ cần khi phát triển

Ý cốt lõi

• Độ phức tạp thuật toán (Big-O) quan trọng hơn mọi tinh chỉnh nhỏ: O(1) < O(log n) < O(n) < O(n log n) < O(n²). Một vòng lặp lồng nhau trên dữ liệu lớn sẽ giết hiệu năng trước mọi thứ khác.
• Profiling trước, tối ưu sau: dùng profiler để tìm đúng điểm nóng (thường 10% code chiếm 90% thời gian). Đo bằng thời gian thực và bộ nhớ; không tối ưu theo cảm tính.
• Các đòn tăng tốc đúng thứ tự ưu tiên: đổi thuật toán/cấu trúc dữ liệu → dùng thư viện C (NumPy, thư viện chuẩn viết bằng C) → cache (memoization cho hàm thuần đắt) → song song hoá (process pool) → cuối cùng mới tới viết lại bằng ngôn ngữ biên dịch (Cython/Rust qua PyO3).
• Logging thay print: log có cấp độ (DEBUG/INFO/WARNING/ERROR), có thời gian và ngữ cảnh, tắt/bật được mà không sửa code. Exception nên kèm traceback đầy đủ; thông điệp lỗi hướng tới người xử lý, không phải "Error!!!".
• PEP 8 & Zen of Python: chuẩn phong cách cộng đồng — dễ đọc quan trọng hơn ngắn; rõ ràng hơn ngầm ẩn; một cách làm chuẩn cho mỗi việc.

from functools import lru_cache

@lru_cache(maxsize=None)      # memoization: nhớ kết quả của hàm thuần theo đầu vào
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

fib(100)   # không cache: ~2^100 lần gọi đệ quy — không bao giờ xong
           # có cache: chỉ 101 lần gọi — cùng thuật toán, khác hẳn nhờ "nhớ lại"

Bốn mảng toán cốt lõi

• Đại số tuyến tính: dữ liệu = các vector/mảng; phép nhân ma trận là cách mọi mô hình "trộn" các đặc trưng. Trực giác: mỗi mẫu dữ liệu là một điểm trong không gian nhiều chiều.
• Giải tích — đạo hàm & gradient: gradient là "hướng dốc lên nhanh nhất" của hàm lỗi; học máy đi ngược hướng đó để giảm lỗi (Chương 16).
• Xác suất & thống kê: phân phối, kỳ vọng, phương sai; định lý Bayes (cập nhật niềm tin khi có bằng chứng); mọi dự đoán của ML về bản chất là xác suất.
• Tối ưu: gần như mọi bài toán ML rút gọn thành "tìm tham số làm hàm mất mát nhỏ nhất".

Công cụ dữ liệu của Python

import numpy as np
import pandas as pd

a = np.array([1, 2, 3])
a * 10                  # vector hoá: tính CẢ MẢNG bằng một lệnh (vòng lặp chạy trong C)
                        # → array([10, 20, 30])

df = pd.read_csv("sales.csv")
df.groupby("city")["revenue"].mean()   # groupby: chia nhóm → tính gộp — thao tác Pandas kinh điển

Chia dữ liệu — luật bất khả xâm phạm

• Train (học) · Validation (chọn mô hình/tinh chỉnh siêu tham số) · Test (chấm điểm cuối, chỉ mở ra một lần). Test bị "nhìn" nhiều lần trong lúc tinh chỉnh thì nó đã biến thành validation và điểm số không còn đáng tin.
• Data leakage (rò rỉ dữ liệu) — lỗi nghiêm trọng nhất của ML thực hành: thông tin từ tương lai/tập test lọt vào quá trình học (ví dụ tính thống kê chuẩn hoá trên toàn bộ dữ liệu trước khi chia). Mô hình điểm cao chót vót trong phòng lab, chết ngay khi ra thực tế.
• Cross-validation: chia train thành k phần, luân phiên học–kiểm để ước lượng ổn định hơn khi dữ liệu ít.

from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

pipe = Pipeline([
    ("scale", StandardScaler()),   # scaler CHỈ học thống kê trên train → không rò rỉ
    ("model", LogisticRegression()),
])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)          # tập test chỉ mở ra để chấm điểm cuối

Overfitting vs Underfitting — đánh đổi bias/variance

• Underfitting (thiếu khớp, bias cao): mô hình quá đơn giản — tệ cả trên train lẫn test. Khắc phục: mô hình mạnh hơn, thêm đặc trưng, giảm regularization.
• Overfitting (quá khớp, variance cao): mô hình học thuộc cả nhiễu của train — điểm train cao, điểm test thấp, khoảng cách hai đường lỗi nới rộng. Khắc phục: thêm dữ liệu, regularization (phạt độ phức tạp), giảm độ sâu/kích thước mô hình, dừng sớm (early stopping), cross-validation.
• Điểm ngọt nằm giữa: đích đến không phải điểm train cao nhất mà là khả năng tổng quát hoá (generalization) — làm tốt trên dữ liệu chưa từng thấy.

Đo bằng gì — metrics

Ý cốt lõi

• Nơ-ron nhân tạo: một phép tính đơn giản — tổng có trọng số của đầu vào + độ lệch, qua một hàm kích hoạt phi tuyến (ReLU, sigmoid, tanh…). Không có phi tuyến, chồng bao nhiêu tầng cũng chỉ tương đương một phép tuyến tính.
• Các tầng (layer) xếp chồng tạo thành mạng: tầng đầu học đặc trưng thô (cạnh, nét), tầng sâu học khái niệm trừu tượng (khuôn mặt, ngữ nghĩa). Đây là sức mạnh cốt lõi của deep learning: tự học đặc trưng, khỏi cần feature engineering tay.
• Tensor là đơn vị dữ liệu: mảng nhiều chiều có mặt khắp nơi (ảnh = tensor chiều cao × rộng × kênh màu). Mọi tính toán DL là phép toán trên tensor, chạy song song hàng loạt trên GPU.
• Các kiến trúc theo loại dữ liệu: MLP (dữ liệu bảng/véc-tơ), CNN (ảnh — bộ lọc trượt học hoa văn cục bộ), RNN/LSTM (chuỗi — nay lép vế), Transformer (chuỗi/ngôn ngữ — thống trị hiện nay, Chương 17), GAN & Diffusion (sinh dữ liệu/ảnh).

Vòng huấn luyện — trái tim của deep learning

1. Forward pass: đưa một mẻ dữ liệu (batch) qua mạng → ra dự đoán.
2. Tính loss: hàm mất mát đo độ sai giữa dự đoán và đáp án (ví dụ cross-entropy cho phân loại, MSE cho hồi quy).
3. Backpropagation: lan truyền ngược đạo hàm của loss theo quy tắc dây chuyền → biết mỗi trọng số "góp phần gây sai" bao nhiêu (gradient của từng trọng số). Framework (PyTorch) tự làm việc này bằng autograd.
4. Cập nhật: optimizer (SGD, Adam…) dịch mỗi trọng số một bước nhỏ ngược hướng gradient. Độ dài bước = learning rate — siêu tham số quan trọng nhất: quá lớn thì dao động/nổ, quá nhỏ thì học mãi không xong.
5. Lặp lại qua nhiều epoch (lượt quét toàn bộ dữ liệu), theo dõi loss trên validation để dừng đúng lúc (early stopping chống overfitting).

for epoch in range(epochs):
    for x, y in train_loader:        # dữ liệu nạp theo từng mẻ (batch)
        pred = model(x)              # 1. forward pass: đưa dữ liệu qua mạng → dự đoán
        loss = loss_fn(pred, y)      # 2. tính loss: đo độ sai so với đáp án
        optimizer.zero_grad()
        loss.backward()              # 3. backprop: autograd tính gradient của mọi trọng số
        optimizer.step()             # 4. cập nhật: dịch mỗi trọng số ngược hướng gradient
                                     #    một bước dài bằng learning rate

Ý cốt lõi

• Token: văn bản được cắt thành các mảnh nhỏ (token — khoảng ¾ từ tiếng Anh, tiếng Việt tốn token hơn). Mô hình không đọc chữ cái hay từ nguyên vẹn, nó đọc token. Mọi giới hạn "context window" đều tính bằng token.
• Embedding: mỗi token được ánh xạ thành một vector số; token gần nghĩa thì vector gần nhau. "Ngữ nghĩa thành hình học" là nền của tìm kiếm ngữ nghĩa và RAG.
• Attention (cơ chế chú ý): khi xử lý một token, mô hình tự tính xem nên "nhìn" vào những token nào trước đó và với trọng lượng bao nhiêu (qua ba vai Query–Key–Value). Đây là phát minh cốt lõi của Transformer (2017): xử lý toàn bộ chuỗi song song và nắm được phụ thuộc xa, thay cho đọc tuần tự như RNN.
• LLM học bằng cách dự đoán token tiếp theo trên kho văn bản khổng lồ (pretraining — tự giám sát, không cần nhãn tay). Dự đoán-từ-tiếp-theo tưởng đơn giản nhưng ở quy mô lớn sinh ra khả năng suy luận, dịch, tóm tắt, viết code…
• Ba giai đoạn tạo nên một trợ lý AI: pretrain (học ngôn ngữ & tri thức) → instruction tuning/SFT (học làm theo lệnh từ ví dụ người viết) → RLHF/DPO (chỉnh theo sở thích con người: hữu ích, trung thực, an toàn).
• Tham số & suy luận: kích thước mô hình tính bằng tỉ tham số (trọng số). Lúc dùng (inference), hai chỉ số sống còn là độ trễ token đầu và tốc độ token/giây; lượng tử hoá (quantization — giảm độ chính xác số của trọng số, ví dụ xuống 4-bit) giúp chạy mô hình lớn trên phần cứng nhỏ với hao hụt chất lượng chấp nhận được.

Dùng LLM đúng cách: prompt · fine-tune · RAG

import numpy as np

tokens = tokenizer.encode("Học Python thật thú vị")
len(tokens)   # mọi giới hạn "context window" đều tính bằng token — không phải số từ

def cosine(u, v):   # độ tương đồng hướng của 2 vector: càng gần 1, càng gần nghĩa
    return u @ v / (np.linalg.norm(u) * np.linalg.norm(v))

# RAG rút gọn: nhúng câu hỏi thành vector, tìm đoạn tài liệu gần nghĩa nhất
q = embed("Robot học tiếng Anh giá bao nhiêu?")
best = max(chunks, key=lambda c: cosine(q, embed(c)))
# → đoạn "best" được nhét vào prompt để LLM trả lời dựa trên đó, kèm nguồn

Ý cốt lõi

• Phục vụ mô hình (serving): đóng gói mô hình thành API (thường FastAPI — chính là ứng dụng của async ở Chương 8), hoặc suy luận theo lô (batch). Cần quản phiên bản mô hình như quản phiên bản code.
• Trôi dữ liệu (drift): thế giới thay đổi — phân phối dữ liệu thật lệch dần khỏi dữ liệu huấn luyện, mô hình âm thầm tệ đi. Bắt buộc theo dõi: chất lượng đầu vào, phân phối dự đoán, và chỉ số nghiệp vụ; có ngưỡng cảnh báo và kế hoạch huấn luyện lại.
• Thí nghiệm có kỷ luật: ghi lại mọi lần train (dữ liệu phiên bản nào, siêu tham số gì, điểm bao nhiêu) bằng công cụ tracking (MLflow…) — không ghi = không tái lập được kết quả.
• Công bằng & an toàn: kiểm tra mô hình có tệ bất thường với một nhóm người dùng nào không (bias từ dữ liệu lịch sử); dữ liệu cá nhân phải tuân thủ quy định bảo vệ dữ liệu; mô hình sinh nội dung cần rào chắn đầu vào/ra.
• Đường ống tự động (pipeline): thu thập → kiểm định dữ liệu → train → đánh giá cổng chất lượng → triển khai từng phần (canary) → giám sát. Đây là MLOps: DevOps áp cho ML, cộng thêm quản trị dữ liệu và mô hình.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = load_model("fraud-detector", version="1.4.2")  # mô hình cũng có PHIÊN BẢN như code

class Request(BaseModel):     # Pydantic kiểm định dữ liệu tại BIÊN: sai kiểu → từ chối ngay
    amount: float
    country: str

@app.post("/predict")
def predict(req: Request):
    features = to_features(req)        # (bước trích đặc trưng đã rút gọn)
    return {"fraud_score": float(model.predict_proba(features)[1])}

• Python lõi: biến là nhãn tham chiếu tới đối tượng; phân biệt mutable/immutable, ==/is, shallow/deep copy.
• Hàm & scope: LEGB, closure, vì sao không dùng mutable làm giá trị mặc định, hàm là đối tượng hạng nhất.
• OOP: class vs instance, MRO, duck typing, vì sao ưu tiên composition hơn kế thừa, khi nào dùng dataclass.
• Bộ nhớ: refcount huỷ đối tượng thế nào, vòng tham chiếu và vai trò của GC thế hệ, interning là gì.
• Cơ chế nâng cao: iterator/generator và tính lười, decorator là hàm-bọc-hàm, with và giao thức context manager.
• Đồng thời: phân biệt CPU-bound/I/O-bound; GIL làm thread vô dụng cho tính toán nhưng tốt cho I/O; chọn đúng giữa thread/process/async và kể được vòng đời event loop.
• Typing: type hint không chạy lúc runtime; Optional/Union/Generic/Protocol; kiểm định dữ liệu thật tại biên bằng công cụ riêng.
• Testing: kim tự tháp test, AAA, fixture/parametrize/mock đúng chỗ, coverage không bằng chất lượng.
• Packaging: venv cho mọi project, pyproject.toml + lock file, wheel/sdist, SemVer, bí mật không vào git.
• ML quy trình: pipeline 6 bước, luật chia train/validation/test, data leakage là gì, overfitting chữa bằng cách nào.
• ML thuật toán: chọn được baseline và thuật toán phù hợp cho hồi quy/phân loại/cụm/RL; đọc được precision–recall theo giá của sai lầm.
• Deep learning: nơ-ron + hàm kích hoạt, vòng forward → loss → backprop → update, vai trò learning rate, transfer learning.
• LLM: token, embedding, attention, dự đoán token tiếp theo; phân biệt prompt/RAG/fine-tune và khi nào dùng cái nào; hallucination và cách giảm.
• MLOps: drift là gì, vì sao phải tracking thí nghiệm, giám sát và huấn luyện lại là phần việc bắt buộc sau deploy.