Bỏ qua tới nội dung chính

Trước khi có thị giác máy tính

Thị giác máy tính: tìm ý nghĩa trong một bảng số

Máy tính nhìn ảnh ra sao: điểm ảnh và ánh sáng, cạnh, so khớp đặc trưng, chiều sâu từ hai camera, phát hiện vật, nhận diện khuôn mặt — và học từ đâu.

Ban biên tập OpenER

Cập nhật 18/11/2026 · 20 phút đọc · CC BY 4.0

Tối sinh nhật, bạn giơ điện thoại chụp đứa cháu đang chụm môi thổi nến, bật chế độ chân dung. Ảnh hiện ra: cháu sắc nét, phía sau nhòe đi — kiểu ảnh "xóa phông" ai cũng thích. Ứng dụng Ảnh tự xếp tấm này vào mục có khuôn mặt cháu, cạnh hàng trăm tấm chụp từ hồi cháu mới biết lẫy. Vài tháng sau, bạn gõ "bánh sinh nhật" vào ô tìm kiếm, và tấm ảnh hiện ra, dù chưa ai gắn chữ nào cho nó.

Với người, những việc ấy dễ như không: đứa trẻ hai tuổi nhận ra bà dù bà đội nón lá, đứng ngược sáng hay chỉ ló nửa mặt sau cánh cửa. Nhưng thứ máy tính nhận được từ camera chỉ là một bảng số khổng lồ, trong đó không có chữ "cháu", chữ "bánh", cũng chẳng có chữ "gần" hay "xa". Rút ý nghĩa ra khỏi bảng số là việc của thị giác máy tính (computer vision).

Trước khi có thị giác máy tính

Trước khi máy biết nhìn, việc gì cần đến mắt cũng phải có người: công nhân soi từng chai trên băng chuyền, nhân viên bưu điện đọc địa chỉ trên từng phong bì, người vẽ bản đồ ngồi hàng giờ trước cặp ảnh chụp từ máy bay để dò từng đường đồng mức.

Máy tính tập nhìn qua mấy bước:

  1. Ảnh thành con số — năm 1957. Ở Cục Tiêu chuẩn Quốc gia Mỹ, nhóm của Russell Kirsch đưa được một tấm ảnh vào máy tính SEAC: ảnh cậu con trai ba tháng tuổi của ông, 176 × 176 điểm, mỗi điểm chỉ đen hoặc trắng.
  2. "Một mùa hè là đủ" — năm 1966. Seymour Papert ở MIT viết bản ghi nhớ "The Summer Vision Project": giao cho sinh viên làm hè dựng "một phần đáng kể của một hệ thị giác" — tách vật khỏi nền, rồi gọi tên từng vật. Mùa hè ấy qua đi; sáu mươi năm sau, bài toán vẫn còn mở.
  3. Nhìn là tính toán — năm 1982. Cuốn Vision của David Marr, in sau khi ông mất ở tuổi 35, coi thị giác là một chuỗi bước tính: từ ảnh ra nét cạnh, từ nét cạnh ra bề mặt và độ xa, rồi mới tới hình khối 3D.
  4. Đặc trưng bền vững, kho ảnh lớn — 1999 đến 2009. SIFT của David Lowe (1999) tìm lại được cùng một điểm trong hai ảnh dù ảnh bị xoay hay phóng to. Bộ phát hiện khuôn mặt của Paul Viola và Michael Jones (2001) chạy kịp thời gian thực. Năm 2009, nhóm của Fei-Fei Li công bố kho ảnh gán nhãn ImageNet, mà bài Học máy đã kể.
  5. Học sâu tìm vật — 2014 đến 2016. R-CNN (2014) của Ross Girshick và cộng sự dùng mạng nơ-ron để tìm và gọi tên vật trong ảnh; YOLO (2016) của Joseph Redmon và cộng sự làm việc ấy trong một lượt nhìn, đủ nhanh cho video.
  6. Học từ ảnh kèm lời — năm 2021. CLIP của OpenAI học từ khoảng 400 triệu cặp ảnh và dòng chữ đi kèm lấy trên mạng, không cần ai gán nhãn từng ảnh.

Đặt cạnh nhau:

Chưa có thị giác máy tính
Có thị giác máy tính
Tìm một tấm ảnh cũ
Lật từng cuốn album, nhớ theo ngày ghi sau ảnh
Gõ "bánh sinh nhật" hay tên một người
Soi hàng trên dây chuyền
Công nhân nhìn bằng mắt, mỏi dần sau vài giờ
Camera soi từng sản phẩm, đều tay cả ngày đêm
Bản đồ từ ảnh máy bay
Người dò từng đường qua kính nhìn nổi
Máy dựng mô hình 3D từ hàng nghìn ảnh

Ngày nay vẫn rất nhiều camera sống như thời chưa có thị giác máy tính. Camera trước cửa một tiệm tạp hóa ghi hình suốt ngày đêm rồi ghi đè lên đoạn cũ; chỉ khi mất đồ, chủ tiệm mới ngồi tua lại từng đoạn. Có mắt mà không thấy. Camera đời mới báo "có người trước cổng" thay vì "có gì đó chuyển động" — một chiếc lá bay qua cũng làm đổi điểm ảnh — là bước từ ghi sang nhìn.

Môn này trả lời câu hỏi gì

Thị giác máy tính trả lời câu hỏi: từ một bảng điểm ảnh, làm sao biết trong ảnh có gì, ở đâu, cách bao xa và đang chuyển động ra sao?

Đây là bài toán ngược của đồ họa máy tính: đồ họa đi từ thế giới mô tả bằng con số tới bức ảnh, thị giác đi từ bức ảnh về thế giới. Chiều ngược khó hơn nhiều, vì lúc chụp đã mất một chiều không gian: chiếc ô tô đồ chơi đặt gần và chiếc ô tô thật đỗ xa có thể cho đúng một ảnh. Từ bảng số, máy phải đoán thế giới nào đã sinh ra nó.

Việc người thấy dễ nhất lại hóa khó nhất với máy — nghịch lý Moravec (Moravec's paradox) mà bài Robot học kể. Ta nhìn giỏi tới mức không biết mình đang làm gì, nên cũng chẳng biết dạy máy từ đâu.

Vì sao nên học? Camera là một trong những cảm biến vừa rẻ vừa giàu thông tin nhất, có mặt trên điện thoại, ô tô, dây chuyền. Hiểu môn này giúp bạn làm ra những hệ thống ấy — và biết chúng sai ở đâu, sai với ai.

Năm ý tưởng cốt lõi

1. Ảnh là một bảng số, và ánh sáng làm đổi mọi con số

Một ảnh xám là một bảng số, mỗi số là độ sáng của một điểm ảnh, từ 0 (đen) tới 255 (trắng); ảnh màu có ba số mỗi điểm, như bài Nhập môn khoa học máy tính đã kể. Thoạt nghe, nhận ra một vật chỉ cần so bảng số với bảng số mẫu. Thử xem cách đó vỡ ở đâu, với chữ O và chữ C vẽ bút dạ trên giấy, chụp thành ảnh 5 × 5:

python
O = ["#####",
     "#...#",
     "#...#",
     "#...#",
     "#####"]
C = ["#####",
     "#....",
     "#....",
     "#....",
     "#####"]

def chup(hinh, den):
    """Chụp hình vẽ bút dạ trên giấy: mực phản xạ 40, giấy 220 (thang 0–255),
    nhân với độ sáng của đèn rọi vào từng cột. Trả về 25 con số."""
    return [(40 if o == "#" else 220) * den[cot]
            for hang in hinh for cot, o in enumerate(hang)]

def lech(a, b):                          # trung bình độ chênh của từng cặp điểm ảnh
    return sum(abs(x - y) for x, y in zip(a, b)) / len(a)

def chuan_hoa(a):                        # trừ độ sáng trung bình, chia cho độ tản
    tb = sum(a) / len(a)
    tan = (sum((x - tb) ** 2 for x in a) / len(a)) ** 0.5
    return [(x - tb) / tan for x in a]

den_ban  = [1.0] * 5                     # đèn bàn rọi đều
tat_den  = [0.5] * 5                     # tắt đèn, chỉ còn ánh sáng cửa sổ
bong_tay = [0.25, 0.25, 0.5, 1.0, 1.0]   # bóng bàn tay che nửa bên trái

goc = chup(O, den_ban)
print("So với chữ O dưới đèn bàn:")
for ten, anh in [("chữ C, cùng đèn bàn", chup(C, den_ban)),
                 ("chữ O, lúc tắt đèn", chup(O, tat_den)),
                 ("chữ O, bị bóng tay", chup(O, bong_tay))]:
    print(f"  {ten:20} lệch {lech(goc, anh):4.1f}   "
          f"sau chuẩn hóa {lech(chuan_hoa(goc), chuan_hoa(anh)):.2f}")
text
So với chữ O dưới đèn bàn:
  chữ C, cùng đèn bàn  lệch 21.6   sau chuẩn hóa 0.43
  chữ O, lúc tắt đèn   lệch 52.4   sau chuẩn hóa 0.00
  chữ O, bị bóng tay   lệch 43.0   sau chuẩn hóa 0.51

Chữ O và chữ C chỉ khác nhau ba điểm ảnh, nên lệch 21,6. Còn cùng chữ O, chỉ tắt đèn bàn, thì mọi con số đều đổi và độ lệch vọt lên 52,4: so bảng số, máy sẽ thấy chữ O lúc tối giống chữ C hơn giống chính nó. Mẹo chuẩn hóa (normalization) — trừ độ sáng trung bình, chia cho độ tản — chữa được kiểu "cả ảnh tối đi". Nhưng bóng một bàn tay che nửa tờ giấy lại đẩy độ lệch lên 0,51, xa hơn cả khoảng cách giữa O và C.

Ngoài đời, ánh sáng đổi theo giờ, theo mây; vật còn xoay, còn bị che — không mẹo sửa tay nào theo kịp. Cả môn học có thể kể như chuỗi câu trả lời cho câu hỏi: nếu không so điểm ảnh, thì so cái gì?

2. Cạnh: chỗ con số đổi đột ngột

Câu trả lời đầu tiên: so chỗ thay đổi thay vì so độ sáng. Mép tờ giấy, viền khuôn mặt, vạch kẻ làn đường là những chỗ độ sáng nhảy vọt giữa hai điểm ảnh cạnh nhau, gọi là cạnh (edge), đo bằng gradient — độ dốc của độ sáng theo chiều ngang và chiều dọc. Cách đo kinh điển là toán tử Sobel (Sobel operator), do Irwin Sobel và Gary Feldman trình bày năm 1968 ở phòng thí nghiệm trí tuệ nhân tạo của Stanford: trong ô 3 × 3 quanh mỗi điểm, lấy cột phải trừ cột trái (hàng giữa nhân đôi), rồi lấy hàng dưới trừ hàng trên. Thử với ảnh một tờ giấy trắng trên mặt bàn gỗ tối:

python
# Ảnh xám 10 × 24: tờ giấy trắng (độ sáng 220) nằm trên mặt bàn gỗ tối (70)
anh = [[220 if 2 <= y <= 7 and 4 <= x <= 18 else 70 for x in range(24)] for y in range(10)]

def sobel(a, y, x):
    """Độ dốc sáng tối theo chiều ngang (gx) và chiều dọc (gy) quanh điểm (y, x)."""
    gx = (a[y-1][x+1] + 2 * a[y][x+1] + a[y+1][x+1]) - (a[y-1][x-1] + 2 * a[y][x-1] + a[y+1][x-1])
    gy = (a[y+1][x-1] + 2 * a[y+1][x] + a[y+1][x+1]) - (a[y-1][x-1] + 2 * a[y-1][x] + a[y-1][x+1])
    return gx, gy

def ve_canh(a, nguong=100):
    dong = []
    for y in range(1, len(a) - 1):
        s = ""
        for x in range(1, len(a[0]) - 1):
            gx, gy = sobel(a, y, x)
            ngang, doc = abs(gx) >= nguong, abs(gy) >= nguong
            s += "+" if ngang and doc else "|" if ngang else "-" if doc else "."
        dong.append(s)
    return dong

print("\n".join(ve_canh(anh)))
sang = [[v + 40 for v in hang] for hang in anh]    # cả ảnh sáng thêm 40, như kéo thanh độ sáng
print(ve_canh(sang) == ve_canh(anh))
text
..++-------------++...
..++-------------++...
..||.............||...
..||.............||...
..||.............||...
..||.............||...
..++-------------++...
..++-------------++...
True

Bốn mép tờ giấy hiện ra: mép đứng thành |, mép nằm thành -, còn ở góc độ sáng đổi theo cả hai chiều nên thành + — góc là loại điểm dễ nhận lại nhất. Chữ True cho biết khi cả ảnh sáng thêm 40, bản đồ cạnh không đổi chút nào: phép trừ giữa hai điểm ảnh tự triệt tiêu phần sáng thêm. Tắt bớt đèn thì khác: mọi độ dốc nhỏ đi theo, và khi độ tương phản còn dưới một phần sáu, cả khung cạnh lọt dưới ngưỡng 100. Bộ phát hiện cạnh chuẩn đến nay, của John Canny (1986), làm kỹ hơn: làm mượt ảnh cho bớt nhiễu, và dùng hai ngưỡng thay cho một để giữ những đoạn cạnh mờ nối liền với cạnh rõ. Bóng đổ thì vẫn sinh ra "cạnh giả": mép bóng cũng là chỗ độ sáng nhảy vọt.

Cạnh không chỉ là mẹo kỹ thuật. Vỏ não thị giác của mèo có những tế bào chỉ phản ứng với nét theo một hướng — phát hiện của Hubel và Wiesel mà bài Học sâu kể — và lớp đầu tiên của các mạng nơ-ron nhận dạng ảnh cũng tự học được những bộ lọc dò cạnh theo từng hướng, na ná Sobel. Phép trượt một ô nhỏ qua khắp ảnh như trên chính là tích chập (convolution): ở đây bộ lọc do người đặt sẵn, còn trong mạng tích chập, máy tự học hàng trăm bộ lọc như thế — bài Học sâu giải thích kỹ.

3. Tìm lại cùng một điểm: ghép ảnh toàn cảnh và đo chiều sâu

Ở chế độ chụp toàn cảnh (panorama), bạn xoay điện thoại, máy chụp nhiều tấm chồng lên nhau một phần rồi khâu thành một dải liền. Muốn khâu, máy phải biết điểm nào ở tấm này là điểm nào ở tấm kia. SIFT làm việc đó qua ba bước:

  1. Tìm điểm đặc trưng (keypoint): chỗ dễ nhận lại, như góc một biển hiệu — không phải giữa bức tường trắng, nơi điểm nào cũng như điểm nào.
  2. Tả mỗi điểm bằng một vector (descriptor): chia vùng quanh điểm thành 4 × 4 ô, mỗi ô cộng độ mạnh của cạnh theo 8 hướng, được 128 con số. Vì dùng hướng cạnh thay cho độ sáng, lại chia vector cho độ dài của nó, nên ảnh tối đi vẫn ra gần như cùng một vector; vùng quanh điểm lại được xoay và co giãn theo hướng, cỡ riêng của điểm, nên ảnh xoay hay phóng to cũng vậy.
  3. So khớp: mỗi điểm ở ảnh trái tìm điểm có vector gần nhất ở ảnh phải.

Bước 3 có bẫy: một dãy cửa sổ giống hệt nhau thì điểm nào cũng "gần" cả chục điểm. Lowe đề xuất phép thử tỉ số (ratio test): chỉ nhận khi khoảng cách tới điểm gần nhất nhỏ hơn 0,8 lần khoảng cách tới điểm gần nhì:

python
import math

# Mỗi điểm đặc trưng được tả bằng một vector: ở đây 8 con số, cộng độ mạnh của các cạnh
# quanh điểm đó theo từng hướng trong 8 hướng (SIFT dùng 128 con số theo cùng ý).
anh_trai = {
    "góc biển hiệu":  [9, 1, 0, 0, 7, 1, 0, 0],
    "cửa sổ tầng 2":  [5, 0, 5, 0, 5, 0, 5, 0],
    "ngọn cây bàng":  [2, 3, 2, 3, 2, 3, 2, 3],   # cây này nằm ngoài ảnh bên phải
}
anh_phai = {
    "A": [5, 1, 4, 0, 5, 0, 6, 1],   # một ô cửa sổ
    "B": [8, 1, 1, 0, 7, 0, 0, 1],   # góc biển hiệu, chụp lệch đi một chút
    "C": [4, 0, 5, 1, 5, 0, 5, 1],   # ô cửa sổ bên cạnh, y hệt ô kia
    "D": [0, 0, 6, 6, 0, 0, 1, 1],   # mép mái tôn
}

for ten, v in anh_trai.items():
    xa = sorted((math.dist(v, w), k) for k, w in anh_phai.items())
    (d1, gan_nhat), (d2, _) = xa[0], xa[1]
    ti_so = d1 / d2
    ket_luan = f"nhận, khớp với {gan_nhat}" if ti_so < 0.8 else "bỏ"
    print(f"{ten:14} gần nhất {gan_nhat} ({d1:.1f}), gần nhì ({d2:.1f}), tỉ số {ti_so:.2f}: {ket_luan}")
text
góc biển hiệu  gần nhất B (2.0), gần nhì (8.6), tỉ số 0.23: nhận, khớp với B
cửa sổ tầng 2  gần nhất C (1.7), gần nhì (2.0), tỉ số 0.87: bỏ
ngọn cây bàng  gần nhất D (7.5), gần nhì (7.5), tỉ số 0.99: bỏ

Góc biển hiệu được nhận ngay. Ô cửa sổ bị bỏ dù khớp rất sát, vì ô bên cạnh cũng sát chẳng kém. Ngọn cây bàng nằm ngoài ảnh phải nên chẳng điểm nào thật sự giống, và cũng bị bỏ. Các cặp còn lại vẫn có thể lẫn cặp sai, nên máy dùng RANSAC (Fischler và Bolles, 1981): bốc ngẫu nhiên bốn cặp, tính phép biến đổi ghép hai ảnh, đếm xem bao nhiêu cặp khác đồng ý; lặp vài trăm lần, giữ phép biến đổi được nhiều phiếu nhất.

Cũng phép so khớp ấy cho ta chiều sâu. Giơ một ngón tay trước mặt, nhắm lần lượt từng mắt: ngón tay nhảy qua lại so với bức tường phía sau, đưa càng gần thì nhảy càng xa. Hai mắt nhìn vật từ hai chỗ hơi khác nhau, và não dùng độ lệch ấy để biết xa gần — điều Charles Wheatstone mô tả năm 1838, khi chế ra kính nhìn nổi (stereoscope). Hai camera đặt song song làm y như vậy: tìm cùng một điểm trong hai ảnh, đo độ lệch (disparity) d tính bằng điểm ảnh, rồi tính khoảng cách Z = f · B / d, với B là khoảng cách giữa hai camera, f là tiêu cự — chỉ là hai tam giác đồng dạng:

python
f = 700      # tiêu cự của camera, tính bằng điểm ảnh
B = 0.12     # hai camera đặt song song, cách nhau 12 cm

for Z in [1, 2, 4, 10]:                    # vật cách camera bao nhiêu mét
    d = f * B / Z                          # độ lệch của vật giữa ảnh trái và ảnh phải
    Z_sai = f * B / (d - 1)                # nếu so khớp lệch đi 1 điểm ảnh
    print(f"cách {Z:2d} m: lệch {d:4.1f} điểm ảnh; khớp sai 1 điểm ảnh thì ra {Z_sai:5.2f} m")
text
cách  1 m: lệch 84.0 điểm ảnh; khớp sai 1 điểm ảnh thì ra  1.01 m
cách  2 m: lệch 42.0 điểm ảnh; khớp sai 1 điểm ảnh thì ra  2.05 m
cách  4 m: lệch 21.0 điểm ảnh; khớp sai 1 điểm ảnh thì ra  4.20 m
cách 10 m: lệch  8.4 điểm ảnh; khớp sai 1 điểm ảnh thì ra 11.35 m

Độ lệch tỉ lệ nghịch với khoảng cách, nên đo gần thì chuẩn, đo xa thì kém: khớp sai một điểm ảnh làm lệch chừng 1 cm ở khoảng cách 1 m, nhưng lệch 1,35 m ở 10 m. Đó là một lý do xe tự lái còn mang thêm radar hay lidar; còn chụp xóa phông chỉ cần đo những thứ ở gần: chiếc Pixel 2 của Google (2017) làm được với một camera, nhờ mỗi điểm ảnh chia đôi thành một cặp "mắt" cách nhau chưa tới 1 mm, cộng một mạng nơ-ron tách người khỏi nền. Với hàng trăm ảnh chụp từ nhiều chỗ, cùng ý tưởng dựng được mô hình 3D của cả một tòa nhà — gọi là dựng cấu trúc từ chuyển động (structure from motion).

4. Nhận dạng và phát hiện: có gì, và ở đâu

Ba câu hỏi khó dần: phân loại ảnh (image classification) — ảnh này có mèo không; phát hiện vật (object detection) — mỗi con mèo, mỗi chiếc xe máy nằm ở đâu, trả lời bằng khung chữ nhật quanh từng vật; phân vùng (segmentation) — từng điểm ảnh thuộc vật nào, câu mà chế độ xóa phông cần, tới từng sợi tóc.

Cách phát hiện cổ điển là cửa sổ trượt (sliding window): trượt một khung qua khắp ảnh, ở mọi vị trí và mọi cỡ, hỏi bộ phân loại "khung này có phải mặt người không?" — hàng chục nghìn câu hỏi cho mỗi ảnh. Viola và Jones chạy được 15 khung hình mỗi giây năm 2001 nhờ xếp bộ phân loại thành tầng: tầng đầu rất rẻ, gạt ngay những khung chắc chắn không phải mặt. Thời học sâu bỏ dần cách trượt mò: R-CNN chọn trước khoảng hai nghìn vùng đáng ngờ rồi cho mạng nơ-ron xét từng vùng; YOLO chia ảnh thành lưới, mỗi ô tự đoán khung, chỉ trong một lượt chạy mạng.

Đoán ra khung rồi, chấm thế nào? Thước đo chuẩn là IoU (intersection over union): diện tích phần chung của khung đoán và khung đáp án, chia cho diện tích phần gộp. Bộ dữ liệu PASCAL VOC chỉ tính là đoán đúng khi IoU trên 0,5:

python
def iou(a, b):
    """Khung viết dạng (trái, trên, phải, dưới), tính bằng điểm ảnh."""
    rong = max(0, min(a[2], b[2]) - max(a[0], b[0]))     # bề ngang phần chung
    cao = max(0, min(a[3], b[3]) - max(a[1], b[1]))      # chiều cao phần chung
    giao = rong * cao
    hop = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - giao
    return giao / hop

dap_an = (100, 80, 300, 230)        # khung người gán nhãn vẽ quanh chiếc xe máy
doan = {
    "gần khít":             (110, 85, 305, 235),
    "lệch sang nửa thân":   (200, 80, 400, 230),
    "to gấp đôi, trùm hết": (60, 40, 340, 270),
    "chỉ ôm bánh trước":    (220, 150, 300, 230),
}
for ten, khung in doan.items():
    diem = iou(dap_an, khung)
    print(f"{ten:22} IoU = {diem:.2f}  {'tính là đúng' if diem > 0.5 else 'tính là sai'}")
text
gần khít               IoU = 0.87  tính là đúng
lệch sang nửa thân     IoU = 0.33  tính là sai
to gấp đôi, trùm hết   IoU = 0.47  tính là sai
chỉ ôm bánh trước      IoU = 0.21  tính là sai

Khung "to gấp đôi" chứa trọn chiếc xe mà vẫn bị tính sai: IoU phạt cả khung quá rộng lẫn khung lệch. Mô hình cũng thường đoán vài khung chồng lên cùng một vật; khung nào trùng nhiều với một khung chắc chắn hơn thì bị bỏ — bước loại khung trùng (non-maximum suppression), cũng dùng IoU.

Bước ngoặt gần đây là bỏ danh sách nhãn cố định. Một bộ phân loại học trên ImageNet chỉ biết đúng một nghìn loại vật. CLIP thì đặt ảnh và câu chữ vào cùng một không gian vector: ảnh nào nằm gần câu "bánh sinh nhật cắm nến" là ảnh có bánh sinh nhật, dù chưa từng có nhãn ấy. Không học thêm gì, CLIP đã chính xác ngang mạng ResNet-50 trên ImageNet — mạng được học từ 1,28 triệu ảnh có nhãn của chính kho đó. Hướng học tự giám sát (self-supervised learning) đi xa hơn: máy tự ra câu đố từ ảnh chưa gán nhãn, như che một phần ảnh rồi đoán lại.

5. Khi thứ được nhìn là con người

Nhận diện khuôn mặt ghép những ý ở trên: phát hiện khuôn mặt, xoay cho thẳng, biến nó thành một vector — FaceNet của Google (2015) dùng 128 con số — rồi so khoảng cách với vector đã lưu, như phép so khớp ở ý 3. Ngưỡng chặt thì hay từ chối nhầm chủ máy; ngưỡng lỏng thì hay nhận nhầm người lạ.

Có hai kiểu dùng rất khác nhau. Xác minh một – một: bạn có phải chủ chiếc điện thoại này, người trong tấm thẻ căn cước này không — việc ứng dụng ngân hàng làm khi bạn chuyển khoản lớn, như bài Tương tác người – máy đã nhắc. Nhận dạng một – nhiều: người trong ảnh là ai giữa hàng triệu người — việc của camera giám sát. Kiểu thứ hai rơi đúng vào bẫy xác suất nền của bài Xác suất và thống kê: một hệ thống chỉ nhận nhầm một lần trong một triệu lần so, đem dò trong kho mười triệu khuôn mặt, trung bình vẫn chỉ ra khoảng mười người vô can mỗi lần tìm. Tháng 1/2020, cảnh sát Detroit (Mỹ) bắt ông Robert Williams sau khi phần mềm khớp nhầm ảnh ông với ảnh trong camera của một cửa hàng bị trộm; năm 2024, thành phố bồi thường và cảnh sát không được bắt người chỉ dựa vào kết quả nhận diện nữa.

Sai số cũng không chia đều. Năm 2018, nghiên cứu Gender Shades của Joy Buolamwini và Timnit Gebru thử ba hệ thống đoán giới tính từ ảnh khuôn mặt của IBM, Microsoft và Face++: với đàn ông da sáng, tỷ lệ sai cao nhất chỉ 0,8%; với phụ nữ da sẫm, có hệ thống sai tới 34,7%. Hai bộ ảnh chuẩn hay dùng để đo độ chính xác khi ấy có tới 80–86% người da sáng, nên điểm số đẹp che mất chỗ sai. Mô hình chỉ giỏi với những gương mặt nó gặp nhiều — chuyện "rác vào, rác ra" của bài Học máy.

Vì vậy nhiều nơi đặt luật riêng. Đạo luật AI của Liên minh châu Âu cấm dựng kho ảnh khuôn mặt bằng cách gom tràn lan trên mạng, và giới hạn chặt việc cảnh sát nhận diện từ xa, tức thời, ở nơi công cộng. Ở Việt Nam, Luật Bảo vệ dữ liệu cá nhân năm 2025 có điều khoản riêng cho dữ liệu sinh trắc học. Năm 2020, Joseph Redmon, tác giả chính của YOLO, còn viết trên mạng xã hội rằng ông đã thôi nghiên cứu thị giác máy tính vì không thể làm ngơ trước những ứng dụng quân sự và nỗi lo về quyền riêng tư. Với người viết phần mềm, câu hỏi cụ thể hơn: xử lý ngay trên máy được không, đã thử mô hình trên đủ các nhóm người chưa, và có người thật xét lại những quyết định hệ trọng không.

Thị giác máy tính nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, thị giác máy tính nằm ở tầng ứng dụng, nối thẳng xuống cảm biến:

  • Dưới cùng: cảm biến ảnh biến ánh sáng thành số; bộ xử lý tín hiệu ảnh (image signal processor — ISP) khử nhiễu, cân màu trước khi phần mềm thấy ảnh — xem bài Tính toán di động và cảm biến.
  • Ở giữa: OpenCV cho xử lý cổ điển, PyTorch cho mạng nơ-ron, chạy trên GPU hay chip AI của điện thoại; trong camera giám sát, mô hình phải chạy trên hệ thống nhúng chỉ vài watt.
  • Trên cùng: xóa phông, quét giấy tờ, xe tự lái, robot tự tìm đường và cầm nắm.

Đưa lên

Những câu trả lời có nghĩa về bức ảnh — trong ảnh có gì, ở đâu, cách bao xa, đang chuyển động ra sao — kèm mức độ chắc chắn.

Giấu đi

Hàng triệu con số đổi theo từng đám mây, bóng đổ, góc chụp. Và cả việc mọi câu trả lời chỉ là phỏng đoán về thế giới đã sinh ra bức ảnh.

Học trước và học sau

· 6 môn

Đại số tuyến tính

Linear Algebra

Ảnh là ma trận, camera là một phép chiếu, ghép ảnh là giải hệ phương trình. Nên học trước.

Xem chủ đề trên OpenER: Linear Algebra

Học máy

Machine Learning

Học có giám sát, quá khớp, tập kiểm tra — nền cho mọi bộ nhận dạng ảnh. Nên học trước.

Xem chủ đề trên OpenER: Machine Learning

Học sâu

Deep Learning

Mạng tích chập và transformer cho ảnh, nền của thị giác máy tính hôm nay. Nên học trước hoặc song song.

Xem chủ đề trên OpenER: Deep Learning

Đồ họa máy tính

Computer Graphics

Bài toán xuôi, từ thế giới ra ảnh; mô hình camera và phép chiếu dùng chung.

Xem chủ đề trên OpenER: Computer Graphics

Robot học

Robotics

Robot dùng thị giác để biết mình ở đâu, tránh vật cản, cầm nắm.

Xem chủ đề trên OpenER: Robotics

Tính toán di động và cảm biến

Mobile and Sensor Computing

Camera trong điện thoại, trộn ảnh với cảm biến chuyển động cho thực tế tăng cường, và giới hạn pin.

Xem chủ đề trên OpenER: Mobile and Sensor Computing

Ứng dụng thật và nghề nghiệp

  • Điện thoại: xóa phông, chụp đêm, quét giấy tờ, dịch chữ trên biển hiệu qua camera, mở khóa bằng khuôn mặt.
  • Nhà máy và nông nghiệp: soi lỗi sản phẩm, phân loại trái cây theo cỡ và màu, máy bay không người lái theo dõi ruộng đồng.
  • Giao thông: cảnh báo lệch làn, phanh khẩn cấp, xe tự lái.
  • Y tế: hỗ trợ đọc ảnh X-quang, ảnh đáy mắt, tiêu bản — bác sĩ vẫn quyết định cuối cùng.
  • Bản đồ và thực tế tăng cường: dựng mô hình 3D từ ảnh chụp, đặt đồ vật ảo lên mặt bàn thật.

Nghề liên quan: kỹ sư thị giác máy tính, kỹ sư học máy mảng ảnh, kỹ sư nhúng đưa mô hình xuống thiết bị nhỏ, người xây dựng dữ liệu ảnh, nhà nghiên cứu.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • giải thích ảnh số hình thành ra sao, và vì sao ánh sáng, góc chụp làm việc nhận dạng khó;
  • tự cài phép lọc, phát hiện cạnh và góc, không cần hàm có sẵn;
  • ghép ảnh toàn cảnh từ ảnh tự chụp, tính chiều sâu từ một cặp ảnh;
  • huấn luyện một mạng tích chập nhỏ, chạy mô hình phát hiện vật có sẵn trên video tự quay và chấm nó bằng IoU;
  • hỏi đúng câu trước một hệ thống nhận diện: đã thử trên ai, sai với ai, ảnh đi đâu.

Nên biết trước: lập trình Python, đại số tuyến tính, học máy nhập môn; học sâu nên học trước hoặc song song.

Bắt đầu trên OpenER: trang chủ đề Computer Vision có các khóa học đã chọn lọc, và hướng dẫn học đi qua sáu bước: hình thành ảnh và lọc ảnh, đặc trưng và ghép ảnh, mạng tích chập, phát hiện vật và phân vùng, dựng 3D, rồi một dự án tổng hợp. Khóa chính là CS5670 Introduction to Computer Vision của Cornell Tech do Noah Snavely giảng, đọc theo sách của Szeliski, cân bằng thị giác cổ điển với học sâu, học bằng cách tự cài từng thuật toán. Muốn chuyên về học sâu cho ảnh có Stanford CS231n hay khóa video của IIT Hyderabad trên NPTEL; MIT 6.801 Machine Vision của Berthold Horn đi vào phần vật lý của sự tạo ảnh. Lời khuyên cho môn này: dùng ảnh của chính mình. Chụp góc phòng lúc trưa và lúc tối, đọc thành bảng số bằng một thư viện như Pillow, cho chạy qua đoạn Sobel ở trên — bạn sẽ thấy tận mắt vì sao "nhìn" lại khó đến thế.

Tài liệu tham khảo

  • Richard Szeliski — Computer Vision: Algorithms and Applications, ấn bản thứ 2 (Springer, 2022), bản PDF miễn phí tại szeliski.org/Book.
  • Aston Zhang, Zachary C. Lipton, Mu Li, Alexander J. Smola — Dive into Deep Learning (Cambridge University Press, 2023), đọc miễn phí tại d2l.ai: các chương mạng tích chập và thị giác máy tính.
  • Cornell CS5670 Introduction to Computer Vision, Spring 2024 (Noah Snavely).
  • Stanford CS231n Deep Learning for Computer Vision.
  • NPTEL — Deep Learning for Computer Vision (Vineeth N Balasubramanian, IIT Hyderabad).
  • MIT 6.801 Machine Vision (Fall 2020, Berthold Horn) — MIT OpenCourseWare.
  • David Marr — Vision (W. H. Freeman, 1982).
  • David G. Lowe — "Distinctive Image Features from Scale-Invariant Keypoints", International Journal of Computer Vision 60(2), 2004.
  • Joy Buolamwini, Timnit Gebru — "Gender Shades: Intersectional Accuracy Disparities in Commercial Gender Classification", Proceedings of Machine Learning Research 81, 2018.

Ban biên tập OpenER, “Thị giác máy tính: tìm ý nghĩa trong một bảng số”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.