Hàm số và Sigmoid: từ cước Grab đến dự đoán khách chốt đơn Shopee

AI

Trong bài này
  1. Chuẩn bị
  2. Hàm số: một "cái máy" nhận số, trả số
  3. Ví dụ đời thường: tiền đi Grab
  4. Từ công thức sang code
  5. Hàm Sigmoid: ép mọi con số về khoảng từ 0 đến 1
  6. Vì sao cần một hàm như vậy?
  7. Tính tay thử ba trường hợp
  8. Viết Sigmoid bằng NumPy
  9. Ghép lại: điểm số z = 𝐰·𝐱 + b rồi cho qua Sigmoid
  10. Thực hành: đoán khách nào sắp "chốt đơn" trên Shopee
  11. Đề bài
  12. Tính tay trước
  13. Khung code: điền vào chỗ ____
  14. Lỗi thường gặp
  15. Tự luyện thêm
  16. Tóm tắt
Series · Bài 3/12 Toán AI thực chiến: học Toán cho AI bằng code Python
  1. Ký hiệu Toán → NumPy & công thức 1 nơ-ron
  2. Ảnh là ma trận & Web App chấm điểm CV
  3. Hàm số & Sigmoid
  4. Khoảng cách, chuẩn hóa & KNN
  5. Mini-App định giá laptop cũ
  6. Vector, tích vô hướng & cosine
  7. Chữ thành vector bằng đếm từ
  8. Embedding, tìm kiếm ngữ nghĩa & RAG
  9. Nhân ma trận, vector riêng & trị riêng
  10. PCA: bản đồ sinh viên 2D & nén ảnh
  11. Đạo hàm, đạo hàm riêng & chain rule
  12. Lan truyền ngược: nơ-ron tự sửa sai
Xem cả series →

Bạn bấm "Đặt xe", app báo ngay 42k. Bạn lướt Shopee, thêm món vào giỏ rồi bỏ đó, ít phút sau app nhắc "Bạn quên thanh toán kìa!". Đằng sau hai chuyện tưởng chẳng liên quan là hai ý Toán rất gọn: hàm số và hàm Sigmoid (xích-moi).

Trong bài này, mình sẽ cùng bạn viết chúng thành hàm Python, vẽ đồ thị, rồi tự làm một mô hình nhỏ đoán xem khách nào sắp "chốt đơn" để gửi thông báo nhắc thanh toán. Không cần nhớ công thức nào trước, chỉ cần biết Python cơ bản.

Đồ thị đường cong chữ S của hàm Sigmoid vẽ bằng Matplotlib trên Google Colab
Đường cong chữ S của hàm Sigmoid: bạn sẽ tự vẽ nó ở giữa bài. Phía trên đồ thị là 5 giá trị σ(z) in ra từ code.

Chuẩn bị

Toàn bộ code của bài nằm trong notebook Colab (cô-láp): mở notebook trên Google Colab. Notebook này dùng chung cho Bài 3, 4 và 5 của series; bài hôm nay dùng ô A1, A2 và Bài tập 1.

  1. Bấm link và đăng nhập tài khoản Google.
  2. Chọn File › Save a copy in Drive để có bản sao của riêng bạn (bản gốc chỉ xem được, không sửa được).
  3. Bấm Connect ở góc phải trên. Thấy dấu ✓ xanh là chạy được. Nhấn Shift + Enter để chạy từng ô.

Thích tự làm từ đầu? Tạo notebook mới (File › New notebook) rồi dán lần lượt từng đoạn code trong bài.

💡 Notebook đã có sẵn ô đáp án (thu gọn, tên bắt đầu bằng 🔑). Hãy tự gõ khung code và điền chỗ trống trước, chỉ mở đáp án khi đã làm xong.

Hàm số: một "cái máy" nhận số, trả số

Ví dụ đời thường: tiền đi Grab

Giả sử Grab tính tiền thế này: mở cửa 12k, mỗi km thêm 10k. Đi 3 km thì trả 10 × 3 + 12 = 42k. Đi 5 km thì 10 × 5 + 12 = 62k. Bạn đưa vào số km, quy tắc trả ra số tiền. Một quy tắc "đưa vào một số, trả ra đúng một số" như vậy chính là hàm số.

f(x) = 10x + 12
(đọc: "f của x bằng mười x cộng mười hai")

Ở đây x là số km (đầu vào), f(x) là số tiền tính bằng nghìn đồng (đầu ra). Dạng tổng quát f(x) = ax + b (đọc: "f của x bằng a x cộng b") gọi là hàm bậc nhất: a là "giá mỗi km", b là "phí mở cửa". Đồ thị của nó luôn là một đường thẳng.

Từ công thức sang code

Một hàm số trong Toán chính là một hàm def trong Python. Thêm vài dòng Matplotlib là vẽ được đồ thị:

# [A1]: Hàm số f(x) = 10x + 12  →  chính là một hàm Python
import numpy as np
import matplotlib.pyplot as plt

def tien_grab(so_km):
    # Tiền Grab (nghìn đồng) = 12k mở cửa + 10k mỗi km
    return 10 * so_km + 12

print("Đi 3 km   →", tien_grab(3), "nghìn đồng")
print("Đi 7.5 km →", tien_grab(7.5), "nghìn đồng")

x = np.linspace(0, 10, 50)          # 50 điểm từ 0 đến 10 km
plt.figure(figsize=(6, 3.2))
plt.plot(x, tien_grab(x), lw=2)
plt.scatter([3], [tien_grab(3)], color="red", zorder=3)
plt.xlabel("Số km (x)"); plt.ylabel("Tiền f(x) — nghìn đồng")
plt.title("f(x) = 10x + 12"); plt.grid(alpha=0.3)
plt.show()

Kết quả:

Đi 3 km   → 42 nghìn đồng
Đi 7.5 km → 87.0 nghìn đồng

Kèm theo là đồ thị một đường thẳng, chấm đỏ là điểm (3, 42).

Để ý một mẹo nhỏ: np.linspace(0, 10, 50) tạo ra 50 con số cách đều nhau từ 0 đến 10. Vì hàm tien_grab chỉ dùng phép nhân và cộng, NumPy tự tính cho cả 50 số cùng lúc, không cần vòng for. Có 50 cặp (x, f(x)) thì Matplotlib nối lại thành đồ thị.

Ô code A1 trên Google Colab: hàm tien_grab và đồ thị đường thẳng f(x) = 10x + 12
Kết quả ô A1. (1) Hàm toán f(x) = 10x + 12 viết thành hàm Python tien_grab. (2) Gọi hàm với 3 km và 7.5 km. (3) Đồ thị là một đường thẳng, chấm đỏ là điểm (3, 42).

Tự kiểm tra: đi 5 km hết bao nhiêu tiền? Gọi tien_grab(5) và so với con số 62 nghìn đồng mình tính tay ở trên.

Hàm Sigmoid: ép mọi con số về khoảng từ 0 đến 1

Vì sao cần một hàm như vậy?

Tưởng tượng app đặt đồ ăn chấm "điểm thèm ăn" của bạn dựa trên giờ giấc, lịch sử đặt món… Điểm đó có thể là −4, 0 hay +4. Con số như vậy khó hiểu: +4 là thèm nhiều cỡ nào? Vì thế app đổi nó về thang từ 0 đến 1: điểm càng cao thì càng gần 1 (gần 100%), điểm càng thấp thì càng gần 0, điểm 0 thì đúng 0.5 (năm mươi – năm mươi).

Hàm làm việc "đổi thang" đó là Sigmoid:

σ(z) = 1 / (1 + e−z)
(đọc: "xích-ma của z bằng một chia cho một cộng e mũ trừ z")

  • σ là chữ Hy Lạp "xích-ma" viết thường. Ở đây nó chỉ là tên của hàm, giống như chữ f ở phần trên.
  • e ≈ 2.718 (đọc: "e xấp xỉ hai phẩy bảy một tám") là một hằng số nổi tiếng trong Toán, giống như π ≈ 3.14.
  • e−z (đọc: "e mũ trừ z") viết trong NumPy là np.exp(-z).

Tính tay thử ba trường hợp

  • z = 0: e0 = 1, nên σ(0) = 1 / (1 + 1) = 0.5.
  • z rất lớn, ví dụ z = 10: e−10 ≈ 0.0000454, gần như bằng 0, nên σ(10) ≈ 1 / 1.0000454 ≈ 0.99995, rất gần 1.
  • z rất âm, ví dụ z = −10: e10 ≈ 22026, rất lớn, nên σ(−10) ≈ 1 / 22027, rất gần 0.

Mẫu số 1 + e−z luôn lớn hơn 1 (vì e−z luôn dương), nên σ(z) luôn lớn hơn 0 và nhỏ hơn 1. Viết gọn: σ(z) ∈ (0, 1) (đọc: "xích-ma của z thuộc khoảng mở từ 0 đến 1"). Dù z là −1000 hay +1000, kết quả vẫn nằm gọn trong khoảng đó.

Viết Sigmoid bằng NumPy

# [A2]: Hàm Sigmoid σ(z) = 1 / (1 + e^(-z))  →  ép MỌI con số về khoảng (0, 1)
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

for z in [-4, -2, 0, 2, 4]:
    print(f"σ({z:>2}) = {sigmoid(z):.3f}")

z = np.linspace(-8, 8, 200)
plt.figure(figsize=(6, 3.2))
plt.plot(z, sigmoid(z), lw=2, color="teal")
plt.axhline(0.5, ls="--", color="gray"); plt.axvline(0, ls="--", color="gray")
plt.xlabel("z"); plt.ylabel("σ(z)"); plt.title("Đường cong chữ S của Sigmoid")
plt.grid(alpha=0.3)
plt.show()

Kết quả:

σ(-4) = 0.018
σ(-2) = 0.119
σ( 0) = 0.500
σ( 2) = 0.881
σ( 4) = 0.982

Đồ thị chính là đường cong chữ S ở đầu bài: z âm nhiều thì σ(z) sát 0, z dương nhiều thì sát 1, và đường cong đi qua đúng điểm (0, 0.5), chỗ hai đường nét đứt cắt nhau. Để ý thêm tính đối xứng: σ(2) = 0.881 và σ(−2) = 0.119, cộng lại đúng bằng 1.

Tự kiểm tra: chạy sigmoid(10) và sigmoid(-10). Bạn sẽ thấy kết quả khớp với phần tính tay: một số rất gần 1 (khoảng 0.99995) và một số rất gần 0.

💡 Vì sao AI thích Sigmoid? Đầu ra luôn nằm trong (0, 1) nên đọc được như "phần trăm khả năng". Ngoài ra đường cong mượt, không gãy khúc, một tính chất rất quan trọng khi mô hình tự học mà bạn sẽ gặp lại ở các bài sau trong series.

Ghép lại: điểm số z = 𝐰·𝐱 + b rồi cho qua Sigmoid

Ở Bài 1 của series, một nơ-ron tính điểm số bằng công thức 𝐰·𝐱 + b (đọc: "w chấm x cộng b"):

  • 𝐱 (chữ x in đậm, đọc: "vector x") là vector (véc-tơ) đặc trưng, tức danh sách các con số mô tả một đối tượng.
  • 𝐰 (đọc: "vector w") là "mức quan trọng" của từng đặc trưng.
  • 𝐰·𝐱 = w1x1 + w2x2 + w3x3: nhân từng cặp rồi cộng lại, trong NumPy là np.dot(w, x).
  • b là một số cộng thêm (độ lệch), giống "phí mở cửa" của Grab.

Vấn đề là điểm số này có thể ra bất kỳ số nào (−3, 1.5, 27…), không đọc được như phần trăm. Giải pháp: cho nó đi qua Sigmoid.

p = σ(𝐰·𝐱 + b)
(đọc: "p bằng xích-ma của w chấm x cộng b")

Giờ p luôn nằm trong (0, 1). Muốn ra quyết định "có / không", ta chọn một ngưỡng, thường là 0.5: nếu p ≥ 0.5 (đọc: "p lớn hơn hoặc bằng không phẩy năm") thì trả lời "có".

💡 Vì σ(0) = 0.5 và Sigmoid luôn đi lên, nên "p ≥ 0.5" tương đương với "z ≥ 0". Nhìn dấu của điểm số z là đoán được quyết định trước khi tính Sigmoid.

Thực hành: đoán khách nào sắp "chốt đơn" trên Shopee

Đề bài

Shop của bạn muốn gửi thông báo "nhắc thanh toán", nhưng chỉ gửi cho khách có khả năng chốt đơn cao để khỏi làm phiền người khác. Mỗi khách được mô tả bằng vector:

𝐱 = [số lần xem sản phẩm, đã thêm vào giỏ (1 = có, 0 = không), có mã giảm giá (1/0)]

Mức quan trọng 𝐰 = [0.5, 2.0, 1.5] và b = −4. Nghĩa là: mỗi lần xem cộng 0.5 điểm, thêm vào giỏ cộng 2 điểm, có mã giảm giá cộng 1.5 điểm, và ai cũng bắt đầu từ −4 điểm.

Tính tay trước

Khách 𝐱 z = 𝐰·𝐱 + b σ(z) Hành động
An [2, 0, 0] 0.5×2 + 0 + 0 − 4 = −3.0 0.047 (4.7%) Chưa cần làm gì
Bình [4, 1, 1] 2 + 2 + 1.5 − 4 = 1.5 0.818 (81.8%) Gửi nhắc thanh toán
Chi [6, 1, 0] 3 + 2 + 0 − 4 = 1.0 0.731 (73.1%) Gửi nhắc thanh toán

Bạn chỉ cần tính tay cột z. Cột σ(z) để code lo, nhưng nhờ mẹo ở trên bạn đã đoán được: An có z âm nên dưới 50%, Bình và Chi có z dương nên trên 50%.

Khung code: điền vào chỗ ____

  1. Hoàn thiện hàm sigmoid(z): điền số mũ của e (gợi ý: -z).
  2. Trong vòng lặp, tính z = np.dot(w, x) + b cho từng khách.
  3. Tính p = sigmoid(z); nếu p ≥ 0.5 thì in "Gửi nhắc thanh toán".
  4. Chạy ô và đối chiếu với bảng tính tay.
# BÀI TẬP 1 — KHUNG CODE: điền vào chỗ ____
import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(____))

w = np.array([0.5, 2.0, 1.5])   # mức quan trọng: lần xem, thêm giỏ, mã giảm giá
b = -4.0

khach_hang = {
    "An":   np.array([2, 0, 0]),
    "Bình": np.array([4, 1, 1]),
    "Chi":  np.array([6, 1, 0]),
}

for ten, x in khach_hang.items():
    z = np.dot(____, ____) + ____
    p = ____(z)
    hanh_dong = "📩 Gửi nhắc thanh toán" if p >= 0.5 else "⏳ Chưa cần làm gì"
    print(f"{ten:5s}: z = {z:5.2f}  →  σ(z) = {p:.3f} ({p*100:.1f}%)  {hanh_dong}")

💡 Nếu chạy khi còn chỗ trống, Colab báo NameError: name '____' is not defined. Đó không phải lỗi gì ghê gớm, chỉ là lời nhắc bạn chưa điền xong.

Xem đáp án
import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

w = np.array([0.5, 2.0, 1.5])
b = -4.0
khach_hang = {"An": np.array([2, 0, 0]), "Bình": np.array([4, 1, 1]), "Chi": np.array([6, 1, 0])}

for ten, x in khach_hang.items():
    z = np.dot(w, x) + b
    p = sigmoid(z)
    hanh_dong = "📩 Gửi nhắc thanh toán" if p >= 0.5 else "⏳ Chưa cần làm gì"
    print(f"{ten:5s}: z = {z:5.2f}  →  σ(z) = {p:.3f} ({p*100:.1f}%)  {hanh_dong}")

Kết quả:

An   : z = -3.00  →  σ(z) = 0.047 (4.7%)  ⏳ Chưa cần làm gì
Bình : z =  1.50  →  σ(z) = 0.818 (81.8%)  📩 Gửi nhắc thanh toán
Chi  : z =  1.00  →  σ(z) = 0.731 (73.1%)  📩 Gửi nhắc thanh toán
Bài tập dự đoán chốt đơn Shopee bằng Sigmoid đã chạy trên Google Colab, in xác suất của 3 khách
Bài tập sau khi điền đủ chỗ trống. (1) Số mũ -z trong hàm Sigmoid. (2) z = np.dot(w, x) + b và p = sigmoid(z). (3) Kết quả khớp bảng tính tay. (4) Ô Đáp án thu gọn trong notebook, bấm Show code để đối chiếu.

Đọc kết quả như một người bán hàng: Chi xem nhiều hơn Bình (6 lần so với 4) nhưng không có mã giảm giá nên khả năng chốt thấp hơn (73.1% so với 81.8%). An mới xem 2 lần, chưa thêm vào giỏ, chỉ 4.7%, gửi thông báo lúc này dễ bị coi là làm phiền.

Chỉ với một tích np.dot và một hàm Sigmoid, bạn vừa làm một mô hình phân loại hai lớp ("chốt" / "chưa chốt"). Ở đây 𝐰 và b do mình đặt tay; trong thực tế, máy sẽ tự học chúng từ dữ liệu, đó là chuyện của những bài sau trong series.

Lỗi thường gặp

Thông báo lỗi Nguyên nhân Cách xử lý
NameError: name '____' is not defined Còn chỗ trống chưa điền Tìm ____ trong ô và điền đủ
NameError: name 'np' is not defined Chưa chạy ô import Chạy ô có import numpy as np trước

Tự luyện thêm

  1. Khách "Dũng": xem 8 lần nhưng chưa thêm vào giỏ, không có mã, tức 𝐱 = [8, 0, 0]. Hãy đoán trước bằng tay rồi thêm Dũng vào khach_hang và chạy lại để kiểm tra.
  2. Đổi ngưỡng: nâng ngưỡng từ 0.5 lên 0.75 (shop muốn gửi ít thông báo hơn). Khách nào không còn được gửi?
Xem đáp án

1. z = 0.5 × 8 + 0 + 0 − 4 = 0, nên σ(0) = 0.5: Dũng đứng đúng trên ngưỡng. Vì code dùng p >= 0.5 (lớn hơn hoặc bằng), Dũng vẫn được gửi thông báo; nếu đổi thành p > 0.5 thì không.

2. Chi (73.1%) rơi xuống dưới 0.75 nên không còn được gửi; chỉ còn Bình (81.8%).

Tóm tắt

  • Hàm số là quy tắc "đưa vào một số, trả ra một số", viết trong Python bằng def.
  • Sigmoid ép mọi số z về khoảng (0, 1): σ(0) = 0.5, z càng lớn càng gần 1, z càng âm càng gần 0.
  • Công thức p = σ(𝐰·𝐱 + b) biến điểm số thành "phần trăm khả năng"; so với ngưỡng 0.5 để ra quyết định có / không.
Ký hiệu Toán Cách đọc Lệnh NumPy
f(x) = ax + b "f của x bằng a x cộng b" def f(x): return a*x + b
e−z "e mũ trừ z" np.exp(-z)
σ(z) = 1 / (1 + e−z) "xích-ma của z bằng một chia cho một cộng e mũ trừ z" 1 / (1 + np.exp(-z))
σ(z) ∈ (0, 1) "xích-ma của z thuộc khoảng mở từ 0 đến 1" (luôn đúng với mọi z)
𝐰·𝐱 + b "w chấm x cộng b" np.dot(w, x) + b
p = σ(𝐰·𝐱 + b) "p bằng xích-ma của w chấm x cộng b" sigmoid(np.dot(w, x) + b)
p ≥ 0.5 "p lớn hơn hoặc bằng không phẩy năm" p >= 0.5

Bài tiếp theo trong series: Khoảng cách, chuẩn hóa và KNN tính tay. Mình sẽ đo xem hai phòng trọ "giống nhau" đến đâu, xem vì sao chỉ đổi đơn vị mà máy chọn sai, rồi dùng thuật toán k láng giềng gần nhất để gợi ý phòng trọ.

Ảnh Nguyễn Hữu Huy

Tác giả

Giảng viên Khoa Công nghệ Thông tin, Cao đẳng FPT Polytechnic

Thầy Huy dạy lập trình tại Cao đẳng FPT Polytechnic, chia sẻ kiến thức về Android, Unity/C#, AI và lập trình backend qua blog dotplays và kênh YouTube Thầy Huy One Champ. Tác giả các ứng dụng dotsave, getvidfb và taptik.