⭐ Vision Engineer · Chặng 12Bài 5/8Bài học~75 phút

Grad-CAM: mô hình AI vision đang thật sự nhìn vào đâu?

Mô hình học lối tắt: validation 100% nhưng bỏ sót gần hết lỗi thật. Dùng Grad-CAM và occlusion map tìm nguyên nhân, sửa dữ liệu rồi kiểm chứng lại.

Grad-CAM: mô hình AI vision đang thật sự nhìn vào đâu?

Học xong bài này, bạn sẽ

  • Nhận ra mô hình học lối tắt dù validation cao
  • Tính Grad-CAM bằng autograd và bằng thư viện
  • Kiểm chứng bằng occlusion map
  • Sửa dữ liệu và đo lại trên ảnh sản xuất

Nên học trước: Khi thiếu ảnh lỗi: augmentation và dữ liệu tổng hợp

Nội dung bài viết
  1. 1. Thí nghiệm: một dataset có đường tắt
  2. 2. Grad-CAM: mô hình chú ý vào đâu?
  3. 3. Phép che: kiểm chứng nhân quả
  4. 4. Sửa dữ liệu, không sửa mô hình
  5. 5. Grad-CAM trong thực tế
  6. Tóm tắt
  7. Bài tập

Mô hình phân loại OK/NG đạt 100% trên tập validation. Trưởng phòng QC hỏi: "Nó nhìn vào đâu để nói NG?" Câu hỏi đó không phải tò mò: một mô hình có thể đạt điểm tuyệt đối bằng cách học một đường tắt (shortcut), một dấu hiệu tình cờ đi kèm nhãn trong dữ liệu huấn luyện nhưng không liên quan gì tới lỗi: ảnh NG chụp ở trạm sửa chữa có đèn khác, có in dấu ngày giờ, có thước đo đặt cạnh. Ra sản xuất, dấu hiệu đó biến mất và mô hình sụp đổ. Bài này tạo đúng tình huống đó, dùng Grad-CAM để xem mô hình chú ý vào đâu, kiểm chứng bằng phép che (occlusion), sửa dữ liệu, và chứng minh bằng số rằng mô hình sau khi sửa nhìn đúng chỗ.

Cần PyTorch, NumPy; mục 6 dùng thêm thư viện grad-cam. Các khối code nối tiếp nhau trong cùng một file. Nên học trước: mạng nơ-ron và CNN, dự án phân loại OK/NG (ở đó Grad-CAM được nhắc tới như một bước kiểm tra), tự xây dataset ảnh công nghiệp.

1. Thí nghiệm: một dataset có đường tắt

Ảnh 64 × 64 bề mặt nắp nhựa; ảnh NG có một vết xước mờ ở vị trí ngẫu nhiên. Trong dữ liệu huấn luyện và validation, mọi ảnh NG được chụp ở trạm sửa chữa, nơi camera in một dấu ngày giờ sáng ở góc dưới phải; ảnh OK lấy từ dây chuyền không có dấu. Dữ liệu "sản xuất" lấy từ trạm mới: không ảnh nào có dấu. Tình huống này hoàn toàn có thật: ảnh NG thường hiếm, nên người ta gom từ nơi khác (trạm sửa chữa, phòng thí nghiệm, một camera khác), và đường tắt đi theo.

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)
torch.set_num_threads(4)
S = 64


def tao_anh(n, hat, ty_le_ng=0.5, dau_goc_ng=1.0, dau_goc_ok=0.0):
    """Ảnh 64×64 bề mặt nắp nhựa. NG có một vết xước tối ngắn ở vị trí ngẫu nhiên.
    'Dấu góc' là con dấu ngày giờ sáng ở góc dưới phải, do trạm chụp in lên: dau_goc_ng / dau_goc_ok là
    xác suất ảnh NG / OK có dấu này."""
    g = np.random.default_rng(hat)
    yy, xx = np.mgrid[0:S, 0:S]
    anh = 0.55 + 0.05 * g.standard_normal((n, S, S))
    anh += 0.04 * np.sin((xx + yy)[None] / g.uniform(2, 4, (n, 1, 1)))              # vân bề mặt
    nhan = (g.random(n) < ty_le_ng).astype(np.int64)
    vi_tri = np.zeros((n, 2))
    for i in range(n):
        if nhan[i]:
            cx, cy, goc = g.uniform(12, 44), g.uniform(12, 44), g.uniform(0, np.pi)
            t = np.linspace(-6, 6, 40)
            for k in t:                                                               # vết xước dài 12 px
                x, y = int(round(cx + k * np.cos(goc))), int(round(cy + k * np.sin(goc)))
                anh[i, y - 1:y + 1, x - 1:x + 1] -= 0.08
            vi_tri[i] = cx, cy
        if g.random() < (dau_goc_ng if nhan[i] else dau_goc_ok):
            anh[i, 54:61, 48:61] = 0.95                                               # dấu ngày giờ
    return torch.tensor(anh[:, None], dtype=torch.float32), torch.tensor(nhan), vi_tri


# dữ liệu huấn luyện và validation lấy từ cùng một nguồn: mọi ảnh NG đều chụp ở trạm sửa chữa có in dấu góc
X_tr, y_tr, _ = tao_anh(1200, 1)
X_va, y_va, _ = tao_anh(400, 2)
# dữ liệu sản xuất thật: trạm mới không in dấu nào
X_sx, y_sx, vt_sx = tao_anh(400, 3, dau_goc_ng=0.0)
print("train:", tuple(X_tr.shape), "NG:", int(y_tr.sum()), "| val NG:", int(y_va.sum()), "| sản xuất NG:", int(y_sx.sum()))


class MangOkNg(nn.Module):
    def __init__(self):
        super().__init__()
        self.dac_trung = nn.Sequential(                                              # ảnh → bản đồ đặc trưng 8×8
            nn.Conv2d(1, 16, 3, padding=1), nn.BatchNorm2d(16), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(16, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2))
        self.phan_loai = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(64, 2))

    def forward(self, x):
        return self.phan_loai(self.dac_trung(x))


def huan_luyen(X, y, epoch=8):
    torch.manual_seed(0)
    mh = MangOkNg()
    opt = torch.optim.Adam(mh.parameters(), lr=3e-3)
    for _ in range(epoch):
        for i in torch.randperm(len(X)).split(64):
            loss = F.cross_entropy(mh(X[i]), y[i])
            opt.zero_grad()
            loss.backward()
            opt.step()
    return mh.eval()


def danh_gia(mh, X, y):
    with torch.no_grad():
        du = mh(X).argmax(1)
    return (du == y).float().mean().item(), (du[y == 1] == 1).float().mean().item()


mo_hinh = huan_luyen(X_tr, y_tr)
for ten, X, y in (("validation", X_va, y_va), ("sản xuất", X_sx, y_sx)):
    acc, recall = danh_gia(mo_hinh, X, y)
    print(f"{ten:10s}: accuracy {100 * acc:5.1f}%, recall NG {100 * recall:5.1f}%")
train: (1200, 1, 64, 64) NG: 608 | val NG: 223 | sản xuất NG: 180
validation: accuracy 100.0%, recall NG 100.0%
sản xuất  : accuracy  55.3%, recall NG   0.6%

Validation hoàn hảo, sản xuất gần như không bắt được ảnh NG nào. Vì validation được chia từ cùng nguồn với train, nó mang cùng đường tắt và không cảnh báo được gì; chỉ dữ liệu từ đúng nơi mô hình sẽ chạy mới lộ ra vấn đề (bài chia train/val/test không rò rỉ). Nhưng trước khi có dữ liệu sản xuất, làm sao nghi ngờ được?

2. Grad-CAM: mô hình chú ý vào đâu?

Grad-CAM (Gradient-weighted Class Activation Mapping) dựa trên bản đồ đặc trưng của lớp tích chập cuối, nơi mỗi kênh Ak còn giữ thông tin vị trí (ở đây lưới 8 × 8). Mức quan trọng của kênh k đối với lớp c là trung bình gradient của điểm lớp đó theo kênh:

\[ \alpha_k^c = \frac{1}{Z}\sum_{i,j}\frac{\partial y^c}{\partial A^k_{ij}}, \qquad L^c_{\text{Grad-CAM}} = \mathrm{ReLU}\Big(\sum_k \alpha_k^c A^k\Big) \]

ReLU giữ lại những vùng làm tăng điểm của lớp c. Bản đồ 8 × 8 rồi được phóng to lên kích thước ảnh để xem. Cài đặt bằng torch.autograd.grad chỉ vài dòng; ta chuẩn hóa bản đồ để tổng bằng 1, rồi đo tỉ lệ "năng lượng" rơi vào góc có dấu và vào vùng quanh vết xước:

def grad_cam(mh, x, lop=1):
    """Grad-CAM: trọng số mỗi kênh = trung bình gradient của điểm lớp theo kênh đó; CAM = ReLU(Σ trọng số · kênh)."""
    A = mh.dac_trung(x)                                   # (N, 64, 8, 8): bản đồ đặc trưng lớp tích chập cuối
    diem = mh.phan_loai(A)[:, lop]                        # điểm (logit) của lớp NG
    grad, = torch.autograd.grad(diem.sum(), A)
    w = grad.mean(dim=(2, 3), keepdim=True)               # (N, 64, 1, 1)
    cam = F.relu((w * A).sum(dim=1))                      # (N, 8, 8)
    cam = cam / cam.flatten(1).sum(1).clamp_min(1e-12)[:, None, None]    # chuẩn hóa: tổng = 1
    return cam.detach()


def phan_tram_vung(cam, vi_tri):
    """Tỉ lệ 'năng lượng' CAM ở ô góc dưới phải (nơi có dấu) và ở các ô quanh vết xước."""
    goc = cam[:, 6:8, 6:8].flatten(1).sum(1)
    quanh_loi = torch.zeros(len(cam))
    for i, (cx, cy) in enumerate(vi_tri):
        c, r = int(cx // 8), int(cy // 8)
        quanh_loi[i] = cam[i, max(r - 1, 0):r + 2, max(c - 1, 0):c + 2].sum()
    return 100 * goc.mean().item(), 100 * quanh_loi.mean().item()


X_va2, y_va2, vt_va2 = tao_anh(400, 2)                    # lấy lại vị trí vết xước của tập validation
ng = y_va2 == 1
cam_va = grad_cam(mo_hinh, X_va2[ng])
g, q = phan_tram_vung(cam_va, vt_va2[ng.numpy()])
print(f"ảnh NG của validation: CAM ở góc có dấu {g:.0f}%, quanh vết xước {q:.0f}% (diện tích: góc 6%, quanh lỗi ~14%)")

i0 = int(torch.nonzero(ng)[0])
print(f"bản đồ Grad-CAM ảnh NG số {i0} (vết xước ở ô hàng {int(vt_va2[i0][1] // 8)}, cột {int(vt_va2[i0][0] // 8)}), thang 0–9:")
c = cam_va[0]
for hang in (9 * c / c.max()).round().int().tolist():
    print("   " + " ".join(str(v) for v in hang))
ảnh NG của validation: CAM ở góc có dấu 38%, quanh vết xước 36% (diện tích: góc 6%, quanh lỗi ~14%)
bản đồ Grad-CAM ảnh NG số 0 (vết xước ở ô hàng 2, cột 3), thang 0–9:
   0 0 0 0 0 0 0 0
   0 3 9 9 2 0 0 0
   0 2 6 5 1 0 0 0
   0 1 2 2 0 0 0 0
   0 0 0 0 0 0 0 0
   0 0 0 0 0 3 6 4
   0 0 0 0 0 6 9 8
   0 0 0 0 0 5 8 8

Góc có dấu chỉ chiếm 6% diện tích ảnh nhưng nhận khoảng 38% năng lượng CAM: mô hình đang dùng dấu ngày giờ. Bản đồ của ảnh mẫu (in theo thang 0–9) có hai điểm nóng: quanh vết xước ở hàng 1–2, cột 2–3, và ở góc dưới phải. Đây là tín hiệu đủ để dừng lại và điều tra trước khi đưa mô hình ra dây chuyền. Nhưng hãy chú ý: Grad-CAM cũng sáng quanh vết xước. Nhìn bản đồ, bạn có thể kết luận "mô hình nhìn cả lỗi lẫn dấu, chắc vẫn ổn". Mục sau cho thấy kết luận đó sai.

3. Phép che: kiểm chứng nhân quả

Grad-CAM cho biết vùng nào góp phần vào điểm số, không cho biết phần góp đó có đủ để quyết định hay không. Cách kiểm chứng trực tiếp: xóa thứ nghi ngờ khỏi ảnh và xem quyết định có đổi không.

def xac_suat_ng(mh, X):
    with torch.no_grad():
        return torch.softmax(mh(X), 1)[:, 1]


che = X_va2[ng].clone()
che[:, :, 54:61, 48:61] = 0.55                            # che góc bằng màu nền: xóa dấu ngày giờ
p_truoc, p_sau = xac_suat_ng(mo_hinh, X_va2[ng]), xac_suat_ng(mo_hinh, che)
print(f"ảnh NG validation: P(NG) trung vị {p_truoc.median():.3f} → sau khi che góc {p_sau.median():.3f}; "
      f"vẫn được báo NG {100 * (p_sau > 0.5).float().mean():.0f}%")
ảnh NG validation: P(NG) trung vị 0.999 → sau khi che góc 0.216; vẫn được báo NG 1%

Che dấu góc, xác suất NG trung vị giảm từ gần 1 xuống khoảng 0,2, và gần như không ảnh NG nào còn được báo NG, dù vết xước vẫn còn nguyên. Vết xước có góp phần (Grad-CAM thấy nó), nhưng một mình nó không đủ đẩy mô hình qua ngưỡng: quyết định thực sự do dấu góc. Grad-CAM giúp đặt giả thuyết; phép che (hoặc tạo ảnh đối chứng) kiểm chứng giả thuyết.

4. Sửa dữ liệu, không sửa mô hình

Đường tắt là lỗi của dữ liệu, nên cách sửa nằm ở dữ liệu: làm cho dấu hiệu tình cờ không còn đi kèm nhãn. Có nhiều cách: thu ảnh OK từ chính trạm sửa chữa, cắt bỏ vùng dấu khi tiền xử lý, hoặc khi augment thì chèn dấu ngẫu nhiên vào cả ảnh OK lẫn NG. Ở đây ta mô phỏng cách thứ ba: dấu xuất hiện ở 50% ảnh của cả hai lớp.

# sửa dữ liệu: dấu ngày giờ xuất hiện ngẫu nhiên ở cả hai lớp (thu ảnh OK từ cùng trạm, hoặc tự chèn dấu khi augment)
X_tr2, y_tr2, _ = tao_anh(1200, 1, dau_goc_ng=0.5, dau_goc_ok=0.5)
mo_hinh2 = huan_luyen(X_tr2, y_tr2)
X_va3, y_va3, vt_va3 = tao_anh(400, 2, dau_goc_ng=0.5, dau_goc_ok=0.5)
for ten, X, y in (("validation mới", X_va3, y_va3), ("sản xuất", X_sx, y_sx)):
    acc, recall = danh_gia(mo_hinh2, X, y)
    print(f"mô hình sau khi sửa dữ liệu, {ten:14s}: accuracy {100 * acc:5.1f}%, recall NG {100 * recall:5.1f}%")
ng3 = y_va3 == 1
g, q = phan_tram_vung(grad_cam(mo_hinh2, X_va3[ng3]), vt_va3[ng3.numpy()])
print(f"Grad-CAM sau khi sửa: CAM ở góc {g:.0f}%, quanh vết xước {q:.0f}%")
mô hình sau khi sửa dữ liệu, validation mới: accuracy 100.0%, recall NG 100.0%
mô hình sau khi sửa dữ liệu, sản xuất      : accuracy 100.0%, recall NG 100.0%
Grad-CAM sau khi sửa: CAM ở góc 0%, quanh vết xước 94%

Mô hình huấn luyện lại đạt 100% cả trên validation mới lẫn dữ liệu sản xuất, và Grad-CAM giờ gần như chỉ sáng quanh vết xước (khoảng 94% năng lượng), góc không còn đáng kể. Đây là bằng chứng có thể đưa cho QC: số liệu trên dữ liệu đúng nguồn, cộng với bản đồ cho thấy mô hình nhìn đúng chỗ.

Mẹo nhỏ để huấn luyện ổn địnhMô hình trong bài có BatchNorm sau mỗi lớp tích chập. Khi thử bản không có BatchNorm, mô hình sau khi sửa dữ liệu (không còn đường tắt dễ học) bị kẹt ở lời giải "báo NG mọi ảnh" và không thoát ra được dù huấn luyện lâu hơn: đúng hiện tượng ở bài dữ liệu mất cân bằng và cách BatchNorm giúp ở bài BatchNorm, Dropout. Đường tắt nguy hiểm một phần vì nó dễ học: nó che mất khó khăn thật của bài toán.

5. Grad-CAM trong thực tế

from pytorch_grad_cam import GradCAM
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget

x = X_va2[ng][:20]
with GradCAM(model=mo_hinh, target_layers=[mo_hinh.dac_trung[-2]]) as gc:           # ReLU cuối (trước MaxPool)
    cam_tv = gc(input_tensor=x, targets=[ClassifierOutputTarget(1)] * len(x))       # (20, 64, 64), đã phóng to
cam_ta = F.interpolate(grad_cam(mo_hinh, x)[:, None], size=(S, S), mode="bilinear")[:, 0].numpy()
r = [np.corrcoef(a.ravel(), b.ravel())[0, 1] for a, b in zip(cam_tv, cam_ta)]
print(f"tương quan giữa CAM của thư viện (ReLU cuối, 16×16) và CAM tự viết (sau pooling, 8×8): trung vị {np.median(r):.2f}")
tương quan giữa CAM của thư viện (ReLU cuối, 16×16) và CAM tự viết (sau pooling, 8×8): trung vị 0.82

Thư viện pytorch-grad-cam (pip install grad-cam) cho kết quả tương tự bản tự viết (tương quan cao; chênh lệch do bản thư viện lấy lớp ReLU cuối trước MaxPool, độ phân giải 16 × 16). Nó có sẵn nhiều biến thể (Grad-CAM++, Score-CAM, Eigen-CAM…) và hàm chồng bản đồ lên ảnh. Chọn target_layers là lớp tích chập cuối còn đủ thông tin vị trí: với ResNet của torchvision thường là model.layer4[-1].

  • Khi nào chạy: trên một mẫu ảnh của golden set (bài chọn ngưỡng và golden set) trước mỗi lần đưa mô hình mới vào sản xuất; trên mọi ảnh bị phân loại sai; khi dữ liệu đến từ nhiều nguồn (trạm, ca, camera khác nhau).
  • Cách đọc: không chỉ nhìn ảnh NG; xem cả ảnh OK có điểm NG cao, và tính tỉ lệ năng lượng theo vùng như mục 2 để có con số thay vì cảm nhận.
  • Giới hạn: độ phân giải thô (bằng lưới của lớp cuối), có thể bỏ qua chi tiết nhỏ; bị ảnh hưởng khi điểm số đã bão hòa; cho biết tương quan chứ không chứng minh nhân quả. Luôn đi kèm phép che hoặc ảnh đối chứng khi kết luận quan trọng.
  • Anomaly detection (PatchCore, PaDiM) đã có sẵn bản đồ bất thường theo vùng (bài anomaly detection), không cần Grad-CAM; detector như YOLO trả về hộp, bản thân hộp đã là "giải thích" vị trí.

Tóm tắt

  • Đường tắt: dấu hiệu tình cờ đi kèm nhãn trong dữ liệu huấn luyện (dấu thời gian, đèn khác, nguồn ảnh khác). Validation chia từ cùng nguồn không phát hiện được.
  • Grad-CAM: trọng số kênh = trung bình gradient; bản đồ = ReLU(tổng có trọng số của kênh). Đo tỉ lệ năng lượng theo vùng để có con số.
  • Grad-CAM cho giả thuyết; phép che hoặc ảnh đối chứng cho kiểm chứng. Dùng logit thay vì xác suất khi mô hình đã bão hòa.
  • Sửa đường tắt bằng dữ liệu (thu đúng nguồn, cắt vùng, augment phá liên hệ), rồi kiểm tra lại trên dữ liệu đúng nơi triển khai.

Bài tập

Bài 1. Bản đồ che toàn ảnh

Viết hàm che lần lượt từng ô 8 × 8 của ảnh NG mẫu ở mục 2 bằng màu nền và ghi lượng giảm của điểm NG. Dùng hiệu logit NG − OK thay vì xác suất. So bản đồ thu được với Grad-CAM.

Xem đáp án
def le(mh, X):
    """Hiệu logit NG − OK: không bão hòa như xác suất khi mô hình đã rất chắc."""
    with torch.no_grad():
        z = mh(X)
    return z[:, 1] - z[:, 0]


def ban_do_che(mh, x, o=8):
    """Che lần lượt từng ô o×o bằng màu nền, ghi hiệu logit NG − OK giảm bao nhiêu (không cần gradient)."""
    goc = le(mh, x[None])[0]
    ket_qua = torch.zeros(S // o, S // o)
    for r in range(S // o):
        for c in range(S // o):
            xc = x.clone()
            xc[:, r * o:(r + 1) * o, c * o:(c + 1) * o] = 0.55
            ket_qua[r, c] = goc - le(mh, xc[None])[0]
    return ket_qua, goc


bd, goc = ban_do_che(mo_hinh, X_va2[i0])
print(f"hiệu logit ban đầu {goc:.1f}; che ô chứa vết xước (hàng 2, cột 3) giảm {bd[2, 3]:.1f}, "
      f"che ô góc (hàng 7, cột 6) giảm {bd[7, 6]:.1f}")
for hang in (9 * bd.clamp(min=0) / bd.max()).round().int().tolist():
    print("   " + " ".join(str(v) for v in hang))
hiệu logit ban đầu 8.9; che ô chứa vết xước (hàng 2, cột 3) giảm 2.3, che ô góc (hàng 7, cột 6) giảm 1.8
   0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0
   0 0 8 9 0 0 0 0
   0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0
   0 0 0 0 0 0 9 4
   0 0 0 0 0 0 7 4

Bản đồ che có cùng hai điểm nóng như Grad-CAM: ô chứa vết xước và các ô góc. Vì sao dùng logit: xác suất NG của ảnh này là 0,999, che một ô làm logit giảm vài đơn vị nhưng xác suất gần như không nhúc nhích (thử thay bằng xác suất để thấy). Phép che không cần gradient nên dùng được cho mọi mô hình, kể cả mô hình chỉ có file ONNX, nhưng chậm hơn: 64 lần suy luận cho một ảnh với lưới 8 × 8.

Bài 2. Đường tắt ở dây chuyền của bạn

Liệt kê ít nhất năm dấu hiệu tình cờ có thể đi kèm nhãn NG trong dữ liệu của một trạm kiểm tra thật, và với mỗi dấu hiệu, cách kiểm tra nhanh xem mô hình có dùng nó không.

Xem đáp án

(1) Ảnh NG chụp ở trạm khác (đèn, camera, nền khác): so phân phối độ sáng, độ nét giữa hai lớp; Grad-CAM tập trung ở nền. (2) Dấu, chữ, thước, bút đánh dấu lỗi do người QC vẽ lên sản phẩm: che vùng đánh dấu. (3) NG được chụp ở thời điểm khác (ca đêm, nhiệt độ khác): kiểm tra theo thời gian chụp. (4) Ảnh NG được cắt (crop) hoặc nén khác (JPEG chất lượng khác): so kích thước file, mức nén. (5) Vị trí đặt sản phẩm khác (NG đặt tay, OK do robot đặt): so phân phối vị trí, góc xoay. (6) Lô vật liệu: NG chủ yếu từ một lô có màu khác. Cách kiểm tra chung: huấn luyện một mô hình nhỏ chỉ trên đặc trưng "nghi ngờ" (độ sáng trung bình, vị trí, kích thước file); nếu nó phân biệt được OK/NG tốt hơn hẳn mức ngẫu nhiên, dữ liệu có đường tắt.

Bài tiếp theo: Foundation model cho vision: DINOv2, SAM và khi nào nên dùng, khi chỉ có vài chục ảnh để bắt đầu.

Nguồn tham khảo: Selvaraju và cộng sự (2017), Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization (arXiv:1610.02391); Zeiler, Fergus (2014), Visualizing and Understanding Convolutional Networks (phép che); Lapuschkin và cộng sự (2019), Unmasking Clever Hans predictors and assessing what machines really learn, Nature Communications; Geirhos và cộng sự (2020), Shortcut learning in deep neural networks, Nature Machine Intelligence; pytorch-grad-cam trên GitHub.

Bài tập thực hành

  1. C
  2. h
  3. ạ
  4. y
  5. t
  6. h
  7. í
  8. n
  9. g
  10. h
  11. i
  12. ệ
  13. m
  14. l
  15. ố
  16. i
  17. t
  18. ắ
  19. t
  20. ,
  21. v
  22. ẽ
  23. G
  24. r
  25. a
  26. d
  27. -
  28. C
  29. A
  30. M
  31. t
  32. r
  33. ư
  34. ớ
  35. c
  36. v
  37. à
  38. s
  39. a
  40. u
  41. k
  42. h
  43. i
  44. s
  45. ử
  46. a
  47. d
  48. ữ
  49. l
  50. i
  51. ệ
  52. u
  53. ,
  54. r
  55. ồ
  56. i
  57. l
  58. à
  59. m
  60. o
  61. c
  62. c
  63. l
  64. u
  65. s
  66. i
  67. o
  68. n
  69. m
  70. a
  71. p
  72. d
  73. ù
  74. n
  75. g
  76. l
  77. o
  78. g
  79. i
  80. t

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.