AI, Machine Learning, Deep Learning và LLM khác nhau ở đâu
Xem thửGiao Hàng Anh Tí hứa giao đơn express trong 60 phút và đơn standard trong 120 phút. Trong 50.000 đơn nửa đầu năm 2026, 37,8% đơn express đến muộn hơn lời hứa, trong khi đơn standard chỉ 8,3%. Khi khách gọi tổng đài hỏi "bao lâu nữa hàng tới?", nhân viên trả lời theo một luật do Bình, trưởng nhóm điều phối, viết ra từ kinh nghiệm: 20 phút lấy hàng, mỗi km thêm 8 phút. Đo trên cả 50.000 đơn, luật này sai trung bình 17,7 phút, và chỉ 35,8% số đơn có sai số trong vòng 10 phút.
Minh, lập trình viên backend, đề xuất "dùng AI". Lan, quản lý sản phẩm, hỏi lại ba câu: AI ở đây là cái gì, một chatbot dùng mô hình ngôn ngữ lớn có làm được việc này không, và nó có chắc tốt hơn luật của Bình không.
Trước khi đọc tiếp, hãy ghi ra dự đoán của bạn: nếu giữ nguyên dạng công thức "a + b × km" nhưng để máy tự chọn a và b từ 40.000 đơn cũ, sai số trung bình sẽ giảm từ 17,7 phút xuống khoảng bao nhiêu? Còn nếu máy chỉ được xem 5 đơn thì sao?
Sau bài này, bạn có thể
- Phân biệt luật viết tay và luật học từ dữ liệu trên cùng một bài toán ước thời gian giao, và nói được ai chọn các con số trong mỗi cách.
- Mô tả một mô hình như một hàm có tham số: chỉ ra đầu vào, tham số, đầu ra và cách đo sai số của nó.
- Xếp AI, Machine Learning, Deep Learning và LLM thành các vòng lồng nhau, mỗi vòng có một ví dụ trong Giao Hàng Anh Tí.
Cần biết trước: không. Bạn chỉ cần đọc được code Python đơn giản; bài Chuẩn bị môi trường của chương này hướng dẫn cài đặt để tự chạy lại mọi đoạn code.
Mức độ: Cơ bản · Thời gian: khoảng 20 phút · Từ khóa: AI, machine learning, deep learning, LLM, mô hình, tham số
Hai cách có được một luật
Trí tuệ nhân tạo (Artificial Intelligence, AI) là tên chung cho các hệ thống làm những việc ta thường nghĩ là cần trí thông minh: ước thời gian, xếp lịch, đọc hiểu câu hỏi. AI không bắt buộc phải "học". Luật 20 + 8 × km của Bình cũng là một hệ thống AI dạng luật (rule-based system): con người hiểu nghiệp vụ, rồi tự viết luật bằng tay.
Cách thứ hai là học máy (Machine Learning, ML). Con người vẫn chọn dạng của luật, ví dụ "một con số cố định cộng một con số nhân với km", và chọn dữ liệu. Nhưng hai con số cụ thể do máy chọn, sao cho luật khớp nhất với hàng chục nghìn đơn đã giao.
Luật viết tay không cần dữ liệu nhưng khó viết đúng khi có 15 yếu tố cùng lúc; luật học từ dữ liệu chọn được 15 con số đó, miễn là có đủ đơn kèm đáp án.
Đây là mô hình tư duy thứ nhất của bài: viết luật bằng tay và học luật từ dữ liệu khác nhau ở chỗ ai chọn các con số, không phải ở chỗ có công thức hay không.
Mô hình là một hàm có tham số
Viết luật của Bình dưới dạng một hàm:
eta = f(km; a, b) = a + b × km
Đọc từng phần:
kmlà đầu vào (input): thông tin ta có lúc khách đặt đơn.avàblà tham số (parameter): những con số quyết định hàm cư xử thế nào. Với luật của Bình,a = 20,b = 8.eta(estimated time of arrival, thời gian giao dự kiến) là đầu ra (output).- Sai số (error) của một đơn là trị tuyệt đối của
eta - thời_gian_thật. Sai số tuyệt đối trung bình (mean absolute error, MAE) là trung bình các sai số đó, tính bằng phút nên dễ hiểu.
Mô hình (model) chính là hàm này cùng bộ tham số của nó. Huấn luyện (training) là việc tìm bộ tham số làm sai số nhỏ nhất trên dữ liệu đã biết đáp án. Trong code của bài, hàm np.polyfit tìm a, b sao cho tổng bình phương sai số nhỏ nhất, cách làm gọi là bình phương tối thiểu (least squares). Ta vẫn báo cáo kết quả bằng MAE vì nó nói thẳng "lệch bao nhiêu phút".
Ví dụ số: đơn AT027075 giao 1,53 km, thực tế mất 39,0 phút. Luật của Bình cho 20 + 8 × 1,53 = 32,24 phút, sai 6,76 phút; hàm máy học được ở phần code cho 46,38 phút, sai 7,38 phút. Một đơn không nói được gì, nên mọi so sánh phải làm trên nhiều đơn mà mô hình chưa thấy khi học: ta chia 50.000 đơn thành 40.000 đơn để học (dữ liệu huấn luyện, training data) và 10.000 đơn giữ riêng để đo (dữ liệu kiểm tra, test data).
Đây là mô hình tư duy thứ hai: mô hình là một hàm có tham số; học là chọn tham số, đánh giá là đo sai số trên dữ liệu chưa thấy.
AI, Machine Learning, Deep Learning và LLM: bốn vòng lồng nhau
Bốn thuật ngữ này là bốn vòng tròn, vòng sau nằm trong vòng trước.
| Vòng | Ai chọn tham số | Hàm trông thế nào | Ví dụ ở Giao Hàng Anh Tí | Học ở đâu |
|---|---|---|---|---|
| AI | Người hoặc máy | Bất kỳ luật nào | Luật 20 + 8 × km; luật "hàng trên 20 kg đi xe tải" | Chương này |
| Machine Learning | Máy, từ dữ liệu; người chọn dạng hàm và các cột đầu vào | a + b × km, hồi quy tuyến tính, cây quyết định | Dự báo thời gian giao từ 17 cột | Chương 7 đến 9 |
| Deep Learning | Máy học cả cách kết hợp các cột qua nhiều lớp | Mạng nơ-ron nhiều lớp, từ vài nghìn tới hàng tỉ tham số | Mạng 32 × 32 có 1.665 tham số trong bài này | Chương 10 đến 12 |
| LLM | Máy học từ khối văn bản khổng lồ | Mạng Transformer đoán từ tiếp theo | Trả lời khách "đơn của tôi đâu" | Mô-đun 02 |
Học sâu (Deep Learning) là học máy dùng mạng nơ-ron (neural network) nhiều lớp: nhiều tham số, tự học được những tổ hợp mà người không viết ra. Mô hình ngôn ngữ lớn (Large Language Model, LLM) là một mạng học sâu rất lớn, được huấn luyện để đoán mẩu chữ tiếp theo (token) của một đoạn văn bản. Ví dụ, model qwen3:1.7b mà khóa dùng từ mô-đun 02 có khoảng 1,7 tỉ tham số theo trang mô tả của nhà phát triển.
Ý tưởng "hàm có tham số học từ dữ liệu" áp dụng cả cho chữ. Cột note của bộ dữ liệu chứa ghi chú ngắn như "goi truoc khi giao". Đếm xem từ nào hay đứng sau từ nào là ta đã có một mô hình ngôn ngữ tí hon, với tham số là các tần suất. File next_word.py trong m01/c01/examples làm đúng việc đó trên 33.433 ghi chú ([Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026):
notes used: 33433 distinct words: 16
after 'giao': gio 0.34, <end> 0.33, gap 0.33
after 'goi': chuong 0.51, truoc 0.49
after 'hang': de 1.00
Sau chữ "goi", mô hình tí hon cho "chuong" 0,51 và "truoc" 0,49. Một LLM làm cùng loại việc với ngữ cảnh hàng nghìn token và hàng tỉ tham số; mô-đun 02 đi từ bảng đếm này tới Transformer.
Câu hỏi thực tế hơn là: với một bài toán cụ thể, nên đứng ở vòng nào? Sơ đồ sau là cách ra quyết định mà nhóm của Lan dùng.
Đang tải sơ đồ…
Cách đọc hình: bắt đầu từ ô cyan. Ô cam đầu tiên hỏi luật có được biết chính xác không: giờ hứa giao 60 phút là luật kinh doanh, viết tay (ô tím). Ô cam thứ hai hỏi đã có dữ liệu kèm đáp án chưa; chưa có thì dùng luật viết tay và thu thập dữ liệu. Ô cam thứ ba tách chữ tự do (tin nhắn khiếu nại, hợp với LLM) khỏi các cột của bảng (hợp với học máy). Ô xanh lá nhắc: mô hình mới luôn được đo so với luật cũ.
Animation dưới đây chạy lại các phép đo của bài trên cùng 10.000 đơn kiểm tra. Ở chế độ đầu, máy học từ 40.000 đơn; bấm nút biến thể để xem điều gì xảy ra khi máy chỉ được xem 5 đơn.
Đang tải Animation…
Câu trả lời cho câu hỏi mở bài: với cùng dạng a + b × km, máy chọn 36,7 + 6,33 × km và sai số giảm từ 17,7 xuống 16,0 phút, một cải thiện nhỏ. Cải thiện lớn đến khi đưa thêm thông tin vào hàm (mưa, giờ cao điểm, quận, loại xe): 10,4 phút. Còn khi chỉ học từ 5 đơn, hàm học được sai 25,0 đến 26,6 phút, tệ hơn hẳn luật của Bình.
Làm cùng mình
Các file nằm trong m01/c01/examples của kho lab. Chưa có môi trường thì đọc code và kết quả trước; sau hai bài cuối của chương, quay lại chạy bằng uv run python ten_file.py.
Bước 1: đo luật viết tay của Bình.
from pathlib import Path
import pandas as pd
DATA = Path(__file__).resolve().parents[2] / "data" / "orders.parquet"
orders = pd.read_parquet(DATA)
def eta_rule(distance_km):
# luật Bình viết tay: 20 phút lấy hàng, mỗi km thêm 8 phút
return 20 + 8 * distance_km
pred = eta_rule(orders["distance_km"])
error = (pred - orders["delivery_minutes"]).abs()
print("orders:", len(orders))
print(f"MAE of hand rule: {error.mean():.1f} minutes")
print(f"within 10 minutes: {(error <= 10).mean():.1%}")
for rain, part in error.groupby(orders["is_rain"]):
print(f" is_rain={rain!s:5} MAE {part.mean():.1f} minutes")
| Dòng code | Máy làm gì | Vì sao |
|---|---|---|
def eta_rule(distance_km) | Định nghĩa luật viết tay | Hai tham số 20 và 8 do người chọn |
eta_rule(orders["distance_km"]) | Tính ETA cho cả cột một lần | Phép toán trên cả cột, không cần vòng lặp |
(pred - ...).abs() | Sai số của từng đơn | Trị tuyệt đối để lệch sớm và lệch muộn đều tính |
error.groupby(orders["is_rain"]) | Tách sai số theo trời mưa | Xem luật hỏng ở đâu |
Kết quả [Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026:
orders: 50000
MAE of hand rule: 17.7 minutes
within 10 minutes: 35.8%
is_rain=False MAE 16.4 minutes
is_rain=True MAE 21.8 minutes
Ngày mưa, luật sai 21,8 phút so với 16,4 phút ngày khô. Luật không có chữ nào nói về mưa, nên nó không thể biết.
Bước 2: giữ dạng hàm, để máy chọn tham số.
from pathlib import Path
import numpy as np
import pandas as pd
DATA = Path(__file__).resolve().parents[2] / "data" / "orders.parquet"
orders = pd.read_parquet(DATA)
rng = np.random.default_rng(0)
idx = rng.permutation(len(orders))
train, test = orders.iloc[idx[:40_000]], orders.iloc[idx[40_000:]]
# mô hình f(km) = a + b * km; huấn luyện = tìm a, b làm sai số nhỏ nhất
b, a = np.polyfit(train["distance_km"], train["delivery_minutes"], deg=1)
print(f"learned rule: {a:.1f} + {b:.2f} * km")
def mae(pred, part):
return (pred - part["delivery_minutes"]).abs().mean()
print(f"hand rule test MAE: {mae(20 + 8 * test['distance_km'], test):.1f} minutes")
print(f"learned rule test MAE: {mae(a + b * test['distance_km'], test):.1f} minutes")
| Dòng code | Máy làm gì | Vì sao |
|---|---|---|
rng.permutation(len(orders)) | Xáo thứ tự 50.000 chỉ số với seed 0 | Chia ngẫu nhiên nhưng lần nào chạy cũng giống nhau |
idx[:40_000], idx[40_000:] | 40.000 đơn để học, 10.000 đơn để đo | Không chấm điểm trên chính dữ liệu đã học |
np.polyfit(..., deg=1) | Tìm đường thẳng khớp nhất | Trả về hệ số bậc cao trước: b rồi mới a |
Kết quả [Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026:
learned rule: 36.7 + 6.33 * km
hand rule test MAE: 17.7 minutes
learned rule test MAE: 16.0 minutes
Máy chọn hệ số 6,33 phút mỗi km, thấp hơn con số 8 của Bình, và phần cố định 36,7 phút, cao hơn 20 của Bình. Luật của Bình đánh giá thấp đơn ngắn và đánh giá cao đơn dài.
Bước 3: thêm thông tin đầu vào, rồi thêm tham số.
File function_sizes.py dựng bảng X 17 cột: km, số món, mưa, giờ cao điểm, express, cuối tuần, cộng 11 cột 0 hoặc 1 cho 8 quận và 3 loại xe (pd.get_dummies). Phần học và đo:
linear = LinearRegression().fit(X.iloc[tr], y.iloc[tr])
mlp = make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=(32, 32), early_stopping=True, random_state=0))
mlp.fit(X.iloc[tr], y.iloc[tr])
net = mlp[-1]
print("features:", X.shape[1])
for name, model, n_params in [
("linear model", linear, linear.coef_.size + 1),
("neural net 32x32", mlp, sum(w.size for w in net.coefs_) + sum(b.size for b in net.intercepts_)),
]:
mae = np.abs(model.predict(X.iloc[te]) - y.iloc[te]).mean()
print(f"{name:17} params {n_params:5} test MAE {mae:.1f} minutes")
print("rain coefficient learned by linear model:", round(linear.coef_[X.columns.get_loc("is_rain")], 1), "minutes")
| Dòng code | Máy làm gì | Vì sao |
|---|---|---|
LinearRegression().fit(...) | Chọn 17 hệ số và 1 hằng số | Vẫn là "con số nhân với cột rồi cộng lại" |
MLPRegressor(hidden_layer_sizes=(32, 32)) | Mạng nơ-ron hai lớp ẩn, mỗi lớp 32 nơ-ron | Một hàm có nhiều tham số hơn hẳn |
sum(w.size for w in net.coefs_) | Đếm số trọng số của mạng | So số tham số của hai mô hình |
Kết quả [Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026 (mạng nơ-ron mất vài phút trên CPU):
features: 17
linear model params 18 test MAE 10.4 minutes
neural net 32x32 params 1665 test MAE 10.5 minutes
rain coefficient learned by linear model: 12.3 minutes
Mô hình tuyến tính 18 tham số sai 10,4 phút. Mạng nơ-ron 1.665 tham số sai 10,5 phút, không tốt hơn. Lý do nằm ở cách dữ liệu được sinh ra: thời gian giao gần như là tổng của các phần cộng (bài Bộ dữ liệu xuyên suốt sẽ cho bạn xem quy luật đầy đủ), nên một hàm tuyến tính đã đủ sức diễn tả. Hệ số máy học được cho mưa là 12,3 phút; quy luật sinh dữ liệu cộng 12 phút khi trời mưa. Máy tìm ra con số đó chỉ vì ta đưa cột is_rain vào.
Bước 4: tình huống thất bại, học từ quá ít dữ liệu.
def fit_and_score(n_train, seed):
sample = pool.sample(n=n_train, random_state=seed) # chỉ dùng n_train đơn để học
b, a = np.polyfit(sample["distance_km"], sample["delivery_minutes"], deg=1)
mae = (a + b * test["distance_km"] - test["delivery_minutes"]).abs().mean()
return a, b, mae
Phần còn lại của file gọi hàm này với 5, 20 và 40.000 đơn, mỗi cỡ ba seed.
Kết quả [Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026:
hand rule 20 + 8.00 * km test MAE 17.7
n= 5 seed=1 12.3 + 13.43 * km test MAE 26.6
n= 5 seed=2 39.1 + 9.64 * km test MAE 25.0
n= 5 seed=3 13.0 + 12.98 * km test MAE 25.3
n= 20 seed=1 32.9 + 6.87 * km test MAE 16.1
n= 20 seed=2 44.9 + 5.68 * km test MAE 16.9
n= 20 seed=3 30.5 + 6.87 * km test MAE 16.2
n= 40000 seed=1 36.7 + 6.33 * km test MAE 16.0
n= 40000 seed=2 36.7 + 6.33 * km test MAE 16.0
n= 40000 seed=3 36.7 + 6.33 * km test MAE 16.0
Với 5 đơn, ba mẫu khác nhau cho ba bộ tham số khác hẳn nhau (hệ số km từ 9,64 tới 13,43) và cả ba đều sai trên 25 phút, tệ hơn luật viết tay. Với 20 đơn, tham số còn dao động nhưng đã thắng luật của Bình. Với 40.000 đơn, mẫu nào cũng cho đúng 36,7 + 6,33 × km. Học từ dữ liệu chỉ đáng tin khi dữ liệu đủ nhiều so với số tham số cần chọn.
Áp dụng vào Giao Hàng Anh Tí
Trong cùng một hệ thống, mỗi phần nằm ở một vòng khác nhau:
| Phần của hệ thống | Vòng phù hợp | Lý do |
|---|---|---|
| Giờ hứa giao 60 và 120 phút | Luật viết tay | Công ty quyết định, không có gì để học |
| Thời gian giao dự kiến báo cho khách | Machine Learning | Nhiều yếu tố, có 50.000 đơn kèm đáp án |
| Trả lời tin nhắn "đơn của tôi đâu" | LLM gọi tới mô hình dự báo | Đầu vào là chữ tự do; con số vẫn lấy từ mô hình dự báo |
Dòng cuối là hướng đi của cả chương trình: LLM ở mô-đun 02 gọi mô hình dự báo của mô-đun 01, không thay thế nó, vì chỉ mô hình dự báo đã được đo sai số.
Hiểu lầm thường gặp
Hiểu lầm 1: "AI chính là chatbot LLM." LLM chỉ là vòng trong cùng. Luật 20 + 8 × km và mô hình tuyến tính 18 tham số đều là AI, và với bảng số chúng rẻ hơn, dễ đo hơn.
Hiểu lầm 2: "Học từ dữ liệu luôn tốt hơn luật của chuyên gia." Sai ở chỗ chất lượng phụ thuộc lượng dữ liệu. Học từ 5 đơn cho sai số 26,6 phút, tệ hơn 17,7 phút của luật Bình. Lời khuyên đầu tiên trong bộ quy tắc học máy của Google là đừng ngại ra mắt sản phẩm mà chưa có học máy.
Hiểu lầm 3: "Mô hình càng nhiều tham số càng chính xác." Sai ở chỗ thứ quyết định là thông tin đầu vào và hình dạng thật của quan hệ. Mạng 1.665 tham số sai 10,5 phút, mô hình 18 tham số sai 10,4 phút. Thêm cột mưa, giờ, quận mới là bước giảm sai số từ 16,0 xuống 10,4.
| Triệu chứng | Nguyên nhân | Cách kiểm chứng | Cách sửa |
|---|---|---|---|
| Tham số đổi nhiều mỗi lần học lại | Quá ít dữ liệu | Học lại với vài seed khác nhau rồi so tham số | Thu thêm dữ liệu, hoặc tạm giữ luật viết tay |
| Sai số lớn hẳn trong một nhóm đơn (ngày mưa) | Thiếu cột mô tả nhóm đó | Tách MAE theo nhóm, như 21,8 so với 16,4 | Thêm cột vào đầu vào rồi đo lại |
| Mô hình lớn không tốt hơn mô hình nhỏ | Quan hệ thật đơn giản, hoặc thiếu thông tin | So với mô hình đơn giản trên cùng tập kiểm tra | Giữ mô hình đơn giản hơn |
Tự kiểm tra (có đáp án)
Câu 1 (giải thích). Luật 20 + 8 × km và hàm 36,7 + 6,33 × km giống nhau ở đâu, khác nhau ở đâu?
Đáp án: cùng dạng hàm, cùng một đầu vào là km, cùng hai tham số. Khác nhau ở người chọn tham số: Bình chọn 20 và 8 từ kinh nghiệm, còn máy chọn 36,7 và 6,33 để sai số trên 40.000 đơn nhỏ nhất.
Câu 2 (dự đoán). Minh học lại hàm a + b × km nhưng chỉ dùng các đơn ngày khô, rồi dùng nó báo giờ cho các đơn ngày mưa. ETA của hàm này sẽ thường sớm hơn hay muộn hơn thực tế?
Đáp án: sớm hơn thực tế. Hàm chưa từng thấy ngày mưa, mà theo quy luật của dữ liệu mưa cộng khoảng 12 phút, nên khách ngày mưa thường phải chờ lâu hơn giờ được báo.
Tự tay làm
Làm trên giấy trước, rồi kiểm bằng code. Năm đơn đầu tiên của bộ dữ liệu: AT027075 (1,53 km, 39,0 phút), AT011445 (2,47 km, 62,4 phút), AT024077 (6,51 km, 61,8 phút), AT024138 (7,45 km, 63,1 phút), AT000209 (4,85 km, 49,6 phút).
- Tính sai số của luật
20 + 8 × kmvà hàm36,7 + 6,33 × kmcho từng đơn, rồi lấy trung bình. Làm tương tự với một luật của bạn, ví dụ30 + 6 × km. - Khi có môi trường, chạy
five_orders.pytrongm01/c01/examplesđể đối chiếu, rồi thay hằng số bằng luật của bạn. - Viết hai câu giải thích vì sao trên 5 đơn này luật của Bình thắng, còn trên 10.000 đơn kiểm tra thì hàm học được thắng.
Kết quả mong đợi để tự kiểm ([Đã chạy] Python 3.12, NumPy 2.5, pandas 3.1, scikit-learn 1.9, CPU x86_64, ngày 04/11/2026):
order_id distance_km delivery_minutes rule_20_8 learned err_rule_20_8 err_learned
AT027075 1.53 39.0 32.24 46.38 6.76 7.38
AT011445 2.47 62.4 39.76 52.34 22.64 10.06
AT024077 6.51 61.8 72.08 77.91 10.28 16.11
AT024138 7.45 63.1 79.60 83.86 16.50 20.76
AT000209 4.85 49.6 58.80 67.40 9.20 17.80
mean error: {'err_rule_20_8': 13.1, 'err_learned': 14.4}
Trên 5 đơn, luật của Bình sai trung bình 13,1 phút, hàm học được sai 14,4 phút. Năm đơn quá ít để kết luận.
Điều cần nhớ
- AI là vòng ngoài cùng và bao gồm cả luật viết tay; Machine Learning để máy chọn tham số từ dữ liệu; Deep Learning dùng mạng nhiều lớp; LLM là mạng học sâu rất lớn đoán token tiếp theo.
- Mô hình là một hàm có tham số. Huấn luyện là chọn tham số làm sai số nhỏ trên dữ liệu đã biết đáp án; đánh giá là đo sai số trên dữ liệu mô hình chưa thấy.
- Học từ 40.000 đơn thắng luật viết tay (16,0 so với 17,7 phút), học từ 5 đơn thì thua (26,6 phút). Thông tin đầu vào đúng giảm sai số mạnh hơn thêm tham số (10,4 phút với 18 tham số, 10,5 phút với 1.665 tham số).
- Một mô hình đạt 10,4 phút mới là bước đầu. Bài tiếp theo theo dõi mô hình đó sau khi triển khai và cho thấy vì sao công việc của AI Engineer là một vòng lặp, không dừng ở lúc mô hình đạt điểm.
Nguồn tham khảo
- Google for Developers, Rules of Machine Learning (quy tắc 1: đừng ngại ra mắt sản phẩm khi chưa có học máy): https://developers.google.com/machine-learning/guides/rules-of-ml
- NumPy,
numpy.polyfit: https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html - scikit-learn,
LinearRegression: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html - scikit-learn, Neural network models (supervised): https://scikit-learn.org/stable/modules/neural_networks_supervised.html
- Qwen, trang mô tả model Qwen3-1.7B (số tham số 1,7 tỉ): https://huggingface.co/Qwen/Qwen3-1.7B
- AI Engineering from Scratch (MIT), phase 02, What Is Machine Learning: https://github.com/rohitg00/ai-engineering-from-scratch/tree/main/phases/02-ml-fundamentals/01-what-is-machine-learning