Projects

Dự án: kiểm tra vỉ thuốc (blister) và nhật ký chống sửa theo GMP

Kiểm 10 hốc vỉ thuốc: thiếu viên, mẻ, viên lạ màu, đốm bẩn, bền với vệt chói PVC; nhật ký chuỗi băm, phân quyền đổi ngưỡng, HMAC chống sửa log.

Dự án: kiểm tra vỉ thuốc (blister) và nhật ký chống sửa theo GMP
Nội dung bài viết
  1. 1. Bài toán
  2. 2. Yêu cầu
  3. 3. Kiến thức sử dụng
  4. 4. Dữ liệu: vỉ mô phỏng
  5. 5. Lời giải 1: diện tích sáng trong ô cố định
  6. 6. Lời giải 2: định vị, fit đường tròn bền, đo trong đường tròn
  7. 7. Đánh giá
  8. 8. Toàn vẹn dữ liệu: nhật ký chuỗi băm và phân quyền
  9. 9. Bẫy thực tế
  10. 10. Tự đánh giá
  11. Bài tập

Độ khó: ★★★☆ (khó) · Cần học trước: chặng 3: Image Processing, chặng 6: Camera / Lens / Lighting, chặng 10: PLC / Robot / MES · Thời lượng: khoảng 3 giờ

Trong nhà máy dược, trạm vision trên máy đóng vỉ (blister) kiểm từng hốc trước khi hàn màng nhôm: có viên chưa, viên có mẻ vỡ không, có lẫn viên của sản phẩm khác không, có đốm bẩn không. Hai điều làm bài toán này khác các trạm kiểm tra thông thường. Thứ nhất, màng PVC tạo vệt chói cong ngay sát mép viên, đúng chỗ cần đo mẻ. Thứ hai, ngành dược yêu cầu toàn vẹn dữ liệu: mọi kết quả, mọi lần đổi ngưỡng phải được ghi lại, ai làm, lúc nào, vì sao, và không ai sửa được mà không bị phát hiện. Dự án này làm cả hai phần.

Mục tiêu dự án(1) Kiểm 10 hốc mỗi vỉ: thiếu viên, mẻ, sai màu, đốm bẩn, bền với vệt chói và vỉ lệch. (2) Đo được mẻ nhỏ tới mức nào và chọn ngưỡng bằng dữ liệu. (3) Nhật ký chỉ ghi thêm, chuỗi băm phát hiện bản ghi bị sửa. (4) Phân quyền đổi công thức có lý do, và hiểu vì sao chuỗi băm thường chưa đủ, cần khóa bí mật.

1. Bài toán

"Đợt thanh tra vừa rồi ghi nhận: trạm camera máy đóng vỉ số 2 cho phép người vận hành chỉnh ngưỡng mà không lưu lại, và file kết quả là file CSV sửa được. Ngoài ra có khiếu nại một vỉ lẫn viên ngà vàng của sản phẩm khác (cùng kích thước, cùng ca). Yêu cầu nâng cấp trạm: bắt được viên lạ màu, mẻ từ 8% diện tích, đốm bẩn; nhật ký kết quả và thay đổi đáp ứng yêu cầu về hồ sơ điện tử."
Đại lượngYêu cầu
Vỉ2 × 5 hốc, bước 22 mm, viên tròn trắng 10 mm; ảnh 6 pixel/mm
Lỗi phải bắtthiếu viên; mẻ ≥ 8% diện tích; viên lạ màu; đốm bẩn trên viên
Loại nhầm≤ 0,5% số vỉ tốt
Hồ sơmọi kết quả và thay đổi được ghi, có người và thời điểm; sửa hồ sơ phải bị phát hiện
Quyềnchỉ QA được đổi ngưỡng, phải ghi lý do

2. Yêu cầu

  • Vỉ lệch ±10 pixel: định vị bằng hai lỗ định vị (lỗ đục trên màng), không giả định vị trí hốc.
  • Đèn mạnh yếu ±10%: chuẩn hóa độ sáng theo lỗ định vị.
  • Vệt chói trên vòm PVC không được làm viên tốt thành "mẻ" và không được che mẻ thật.
  • Trạm không thấy lỗ định vị thì báo lỗi đo, không phán OK/NG.
  • Nhật ký chỉ ghi thêm, có chuỗi băm; mọi lần đổi công thức (kể cả bị từ chối) đều được ghi.

3. Kiến thức sử dụng

4. Dữ liệu: vỉ mô phỏng

Viên trắng nằm trong hốc PVC trong, bên dưới là tấm đỡ tối (kiểm trước khi hàn màng nhôm, lúc tương phản viên/nền cao nhất). Mỗi hốc có một vệt chói cong ở vòm PVC, vị trí ngẫu nhiên, thường chạm mép viên. Viên lệch trong hốc ±4 pixel, đường kính dao động 1%. Mẻ được tạo bằng cách cắt đúng một tỉ lệ diện tích cho trước (giải phương trình diện tích hình viên phân), để đo được "bắt được mẻ từ bao nhiêu phần trăm".

import cv2
import numpy as np

PX_MM = 6.0
H, W = 330, 720
HANG, COT, BUOC = 2, 5, 132                    # 2 × 5 hốc, bước 22 mm
GOC_HOC = np.array([(96 + c * BUOC, 99 + r * BUOC) for r in range(HANG) for c in range(COT)], float)
LO_DANG_KY = np.array([[30.0, 30.0], [690.0, 30.0]])          # hai lỗ định vị trên màng (pixel, danh định)
R_VIEN, R_HOC = 30, 36                         # viên 10 mm, hốc 12 mm
MAU_VIEN = np.array([0.82, 0.84, 0.85], np.float32)          # viên trắng (B, G, R, tuyến tính)
MAU_LA = np.array([0.55, 0.80, 0.86], np.float32)            # viên của sản phẩm khác lẫn vào: ngà vàng


def tao_vi(rng, ty_le_loi=0.35):
    """Mỗi vỉ có xác suất ty_le_loi chứa một hốc lỗi: thiếu viên, mẻ (mất 4–25% diện tích), sai màu, đốm bẩn."""
    loi = {}
    if rng.random() < ty_le_loi:
        loi[int(rng.integers(0, HANG * COT))] = ["thiếu", "mẻ", "sai màu", "đốm bẩn"][rng.integers(0, 4)]
    return loi


def ve_vien(anh, tam, r, mau, mat_manh=0.0, goc_me=0.0):
    lop = np.zeros(anh.shape[:2], np.uint8)
    cv2.circle(lop, tuple(np.round(tam).astype(int)), int(round(r)), 255, -1, cv2.LINE_AA)
    if mat_manh > 0:                                             # cắt một mảnh hình viên phân: mất đúng mat_manh diện tích
        lo, hi = -r, r                                           # tìm khoảng cách dây cung d bằng chia đôi
        for _ in range(50):
            d = (lo + hi) / 2
            phan = (r * r * np.arccos(d / r) - d * np.sqrt(r * r - d * d)) / (np.pi * r * r)
            lo, hi = (d, hi) if phan > mat_manh else (lo, d)
        huong = np.array([np.cos(goc_me), np.sin(goc_me)])
        yy, xx = np.mgrid[:anh.shape[0], :anh.shape[1]]
        lop[((xx - tam[0]) * huong[0] + (yy - tam[1]) * huong[1]) > d] = 0
    m = lop.astype(np.float32)[..., None] / 255
    yy, xx = np.mgrid[:anh.shape[0], :anh.shape[1]]
    bong = 1 - 0.12 * (((xx - tam[0]) ** 2 + (yy - tam[1]) ** 2) / r ** 2)   # viên lồi: tối dần ra mép
    anh[:] = anh * (1 - m) + (mau * np.clip(bong, 0.8, 1)[..., None]) * m


def chup_vi(loi, rng, danh_dinh=False, ty_le_me=None):
    anh = np.full((H, W, 3), 0.08, np.float32)                   # tấm đỡ tối dưới màng PVC trong
    lech = np.zeros(2) if danh_dinh else rng.uniform(-10, 10, 2)
    for p in LO_DANG_KY + lech:
        cv2.circle(anh, tuple(np.round(p).astype(int)), 8, (0.95, 0.95, 0.95), -1, cv2.LINE_AA)
    for k, g in enumerate(GOC_HOC + lech):
        cv2.circle(anh, tuple(np.round(g).astype(int)), R_HOC, (0.13, 0.13, 0.13), -1, cv2.LINE_AA)   # đáy hốc
        kieu = loi.get(k)
        if kieu != "thiếu":
            tam = g + (0 if danh_dinh else rng.uniform(-4, 4, 2))
            r = R_VIEN * (1 if danh_dinh else rng.normal(1, 0.01))
            mau = MAU_LA if kieu == "sai màu" else MAU_VIEN
            mat = 0.0
            if kieu == "mẻ":
                mat = ty_le_me if ty_le_me is not None else rng.uniform(0.04, 0.25)
            ve_vien(anh, tam, r, mau, mat, rng.uniform(0, 2 * np.pi))
            if kieu == "đốm bẩn":
                d = tam + rng.uniform(-15, 15, 2)
                cv2.circle(anh, tuple(np.round(d).astype(int)), int(rng.integers(2, 4)), (0.25, 0.22, 0.20), -1)
        goc = rng.uniform(0, 2 * np.pi) if not danh_dinh else 0.8
        cv2.ellipse(anh, tuple(np.round(g).astype(int)), (R_HOC - 3, R_HOC - 3), np.degrees(goc), 0, 70,
                    (0.97, 0.97, 0.97), 3, cv2.LINE_AA)        # vệt chói cong trên vòm PVC
    anh *= 1.0 if danh_dinh else rng.uniform(0.9, 1.1)
    return np.clip(anh + rng.normal(0, 0.01, anh.shape), 0, 1).astype(np.float32)


rng = np.random.default_rng(0)
anh = chup_vi({1: "mẻ", 3: "sai màu", 6: "thiếu", 8: "đốm bẩn"}, rng, ty_le_me=0.12)
cv2.imwrite("vi.png", np.uint8(255 * anh ** (1 / 2.2)))
print(anh.shape, "hốc 2: mẻ 12%, hốc 4: sai màu, hốc 7: thiếu, hốc 9: đốm bẩn")
(330, 720, 3) hốc 2: mẻ 12%, hốc 4: sai màu, hốc 7: thiếu, hốc 9: đốm bẩn

5. Lời giải 1: diện tích sáng trong ô cố định

Ô cố định quanh mỗi hốc, đếm pixel sáng hơn 0,5, so với diện tích dạy, cho phép ±10%.

# Lời giải 1: ô hốc cố định, ngưỡng sáng, đếm diện tích, so với diện tích dạy (±10%)
def dien_tich_1(anh, k):
    x, y = GOC_HOC[k].astype(int)
    o = anh[y - R_HOC:y + R_HOC, x - R_HOC:x + R_HOC].mean(axis=2)
    return int((o > 0.5).sum())


rng_day = np.random.default_rng(1)
DT_DAY = np.mean([dien_tich_1(chup_vi({}, rng_day, danh_dinh=True), k) for k in range(HANG * COT)])


def kiem_vi_1(anh):
    return {k: ("OK" if abs(dien_tich_1(anh, k) / DT_DAY - 1) <= 0.10 else "NG") for k in range(HANG * COT)}

6. Lời giải 2: định vị, fit đường tròn bền, đo trong đường tròn

  1. Định vị và chuẩn hóa sáng bằng hai lỗ định vị trắng.
  2. Mặt nạ viên: ngưỡng trên ảnh đã chuẩn hóa, opening 9 × 9 bỏ phần vệt chói mảnh, lấy blob lớn nhất, lấp lỗ (để đốm tối trên viên vẫn thuộc viên).
  3. Fit đường tròn bền trên biên viên: bình phương tối thiểu, lặp lại sau khi bỏ điểm lệch quá 2 pixel. Mép bị mẻ nằm trong đường tròn, vệt chói dính mép nằm ngoài: cả hai đều bị loại khỏi phép fit.
  4. Độ đầy = phần diện tích viên nằm trong đường tròn fit (bán kính trừ 1,5 pixel để bỏ mép răng cưa). Vệt chói nằm ngoài đường tròn nên không làm sai; mẻ làm thiếu một mảnh bên trong nên độ đầy giảm đúng bằng tỉ lệ mẻ.
  5. Màu: Lab của phần lõi viên, ΔE00 so với màu dạy; đốm: số pixel tối hơn trung vị lõi viên 0,2.
def de2000(lab1, lab2):
    """CIEDE2000 (bài kiểm tra màu: Lab, ΔE2000)."""
    L1, a1, b1 = np.moveaxis(np.asarray(lab1, float), -1, 0)
    L2, a2, b2 = np.moveaxis(np.asarray(lab2, float), -1, 0)
    C_tb = (np.hypot(a1, b1) + np.hypot(a2, b2)) / 2
    G = 0.5 * (1 - np.sqrt(C_tb ** 7 / (C_tb ** 7 + 25.0 ** 7)))
    a1p, a2p = (1 + G) * a1, (1 + G) * a2
    C1p, C2p = np.hypot(a1p, b1), np.hypot(a2p, b2)
    h1p, h2p = np.degrees(np.arctan2(b1, a1p)) % 360, np.degrees(np.arctan2(b2, a2p)) % 360
    dh = h2p - h1p
    dh = np.where(dh > 180, dh - 360, np.where(dh < -180, dh + 360, dh))
    dh = np.where(C1p * C2p == 0, 0, dh)
    dL, dC = L2 - L1, C2p - C1p
    dH = 2 * np.sqrt(C1p * C2p) * np.sin(np.radians(dh / 2))
    L_tb, Cp_tb, tong_h = (L1 + L2) / 2, (C1p + C2p) / 2, h1p + h2p
    h_tb = np.where(C1p * C2p == 0, tong_h, np.where(np.abs(h1p - h2p) <= 180, tong_h / 2,
                    np.where(tong_h < 360, (tong_h + 360) / 2, (tong_h - 360) / 2)))
    T = (1 - 0.17 * np.cos(np.radians(h_tb - 30)) + 0.24 * np.cos(np.radians(2 * h_tb))
         + 0.32 * np.cos(np.radians(3 * h_tb + 6)) - 0.20 * np.cos(np.radians(4 * h_tb - 63)))
    SL = 1 + 0.015 * (L_tb - 50) ** 2 / np.sqrt(20 + (L_tb - 50) ** 2)
    SC, SH = 1 + 0.045 * Cp_tb, 1 + 0.015 * Cp_tb * T
    RT = -np.sin(np.radians(60 * np.exp(-((h_tb - 275) / 25) ** 2))) * 2 * np.sqrt(Cp_tb ** 7 / (Cp_tb ** 7 + 25.0 ** 7))
    return np.sqrt((dL / SL) ** 2 + (dC / SC) ** 2 + (dH / SH) ** 2 + RT * (dC / SC) * (dH / SH))


def can_vi(anh):
    """Độ lệch của màng theo hai lỗ định vị, và hệ số độ sáng (lỗ định vị trắng 0,95 khi đèn danh định)."""
    sang = (anh.mean(axis=2) > 0.6).astype(np.uint8)
    n, _, st, tam = cv2.connectedComponentsWithStats(sang)
    lech, do_sang = [], []
    for p in LO_DANG_KY:
        uv = [k for k in range(1, n) if 120 < st[k, cv2.CC_STAT_AREA] < 300 and np.linalg.norm(tam[k] - p) < 25]
        if len(uv) != 1:
            return None, None
        lech.append(tam[uv[0]] - p)
        x, y = np.round(tam[uv[0]]).astype(int)
        do_sang.append(anh[y - 3:y + 4, x - 3:x + 4].mean() / 0.95)
    return np.mean(lech, axis=0), float(np.mean(do_sang))


def fit_duong_tron(diem, lap=4, nguong=2.0):
    """Fit đường tròn bình phương tối thiểu (Kåsa), lặp lại sau khi bỏ điểm lệch > nguong pixel
    (mép bị mẻ nằm trong, vệt chói dính mép nằm ngoài: cả hai đều là điểm lệch)."""
    giu = np.ones(len(diem), bool)
    for _ in range(lap):
        x, y = diem[giu, 0], diem[giu, 1]
        A = np.column_stack([x, y, np.ones_like(x)])
        a, b, c = np.linalg.lstsq(A, x * x + y * y, rcond=None)[0]
        cx, cy = a / 2, b / 2
        r = np.sqrt(c + cx * cx + cy * cy)
        giu = np.abs(np.hypot(diem[:, 0] - cx, diem[:, 1] - cy) - r) < nguong
    return cx, cy, r


def dac_trung_vien(anh, tam_hoc, do_sang):
    """None nếu hốc trống; ngược lại: độ đầy trong đường tròn fit, bán kính, Lab, số pixel đốm."""
    x, y = np.round(tam_hoc).astype(int)
    o = anh[y - R_HOC - 4:y + R_HOC + 4, x - R_HOC - 4:x + R_HOC + 4]
    xam = o.mean(axis=2) / do_sang
    mat_na = (xam > 0.45).astype(np.uint8)
    mat_na = cv2.morphologyEx(mat_na, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9)))
    n, nhan, st, _ = cv2.connectedComponentsWithStats(mat_na)
    if n < 2 or st[1:, cv2.CC_STAT_AREA].max() < 0.3 * np.pi * R_VIEN ** 2:
        return None
    k = 1 + np.argmax(st[1:, cv2.CC_STAT_AREA])
    vien_bien, _ = cv2.findContours((nhan == k).astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
    bien = max(vien_bien, key=len)
    vien = np.zeros_like(mat_na)
    cv2.drawContours(vien, [bien], -1, 1, -1)                          # lấp lỗ: đốm tối trên viên vẫn thuộc viên
    cx, cy, r = fit_duong_tron(bien[:, 0, :].astype(float))
    dia = np.zeros_like(vien)
    cv2.circle(dia, (int(round(cx)), int(round(cy))), int(round(r - 1.5)), 1, -1)
    trong = cv2.erode(vien, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))) > 0
    lab = cv2.cvtColor((np.median(o[trong], axis=0) / do_sang).astype(np.float32)[None, None], cv2.COLOR_LBGR2Lab)[0, 0]
    trung_vi = np.median(xam[trong])
    return {"do_day": float((vien & dia).sum() / dia.sum()), "ban_kinh": float(r / R_VIEN),
            "lab": lab, "dom": int(np.sum(xam[trong] < trung_vi - 0.2))}


rng_d2 = np.random.default_rng(2)
day = []
for _ in range(3):
    a = chup_vi({}, rng_d2, danh_dinh=True)
    day += [dac_trung_vien(a, g, 1.0) for g in GOC_HOC]
LAB_DAY = np.mean([d["lab"] for d in day], axis=0)


def kiem_hoc(f, nguong_day=0.97, nguong_de=4.0):
    if f is None:
        return "thiếu"
    if f["do_day"] < nguong_day:
        return "mẻ"
    if de2000(f["lab"], LAB_DAY) > nguong_de:
        return "sai màu"
    if f["dom"] >= 6:
        return "đốm bẩn"
    return "OK"


def kiem_vi_2(anh):
    lech, do_sang = can_vi(anh)
    if lech is None:
        return None                                                    # không thấy lỗ định vị: lỗi đo
    return {k: kiem_hoc(dac_trung_vien(anh, g + lech, do_sang)) for k, g in enumerate(GOC_HOC)}


print("ΔE00 viên lạ so với viên chuẩn:",
      round(float(de2000(cv2.cvtColor(MAU_LA[None, None], cv2.COLOR_LBGR2Lab)[0, 0], cv2.cvtColor(MAU_VIEN[None, None], cv2.COLOR_LBGR2Lab)[0, 0])), 1))
print("vỉ ví dụ:", kiem_vi_2(anh))
ΔE00 viên lạ so với viên chuẩn: 12.1
vỉ ví dụ: {0: 'OK', 1: 'mẻ', 2: 'OK', 3: 'sai màu', 4: 'OK', 5: 'OK', 6: 'thiếu', 7: 'OK', 8: 'đốm bẩn', 9: 'OK'}

Viên lạ ngà vàng cách viên chuẩn ΔE00 khoảng 12, rõ ràng với máy nhưng dễ lọt mắt người dưới đèn xưởng. Trên vỉ ví dụ, cả bốn lỗi được gọi đúng tên.

Bản đầu của lời giải này có hai lỗi đáng kể lại. Bản thứ nhất tính độ đầy so với đường tròn ngoại tiếp blob: vệt chói dính mép làm đường tròn ngoại tiếp phình ra, viên tốt chỉ đạt 0,93 và bị gọi là mẻ. Bản thứ hai thêm phép kiểm bán kính fit trong khoảng ±6%: khi vệt chói bám một đoạn mép dài, đường tròn fit vẫn bị kéo to tới 8,5%, sinh loại nhầm khoảng 10% số vỉ tốt. Cả hai được phát hiện nhờ in phân bố từng đặc trưng trên vỉ tốt, không phải bằng cách nhìn vài ảnh.

7. Đánh giá

300 vỉ (khoảng một phần ba có một hốc lỗi), rồi quét theo kích thước mẻ, mỗi mức 60 viên. Chạy khoảng 3 phút.

from collections import Counter

rng_dg = np.random.default_rng(3)
ket = {"lời giải 1": Counter(), "lời giải 2": Counter()}
bat = {"lời giải 1": Counter(), "lời giải 2": Counter()}
tong_loai = Counter()
so_vi_tot = 0
for _ in range(300):
    loi = tao_vi(rng_dg)
    anh = chup_vi(loi, rng_dg)
    so_vi_tot += not loi
    for ten, kq in (("lời giải 1", kiem_vi_1(anh)), ("lời giải 2", kiem_vi_2(anh))):
        sai_hoc_tot = sum(1 for k, v in kq.items() if k not in loi and v != "OK")
        ket[ten]["hốc tốt bị loại"] += sai_hoc_tot
        if not loi:
            ket[ten]["vỉ tốt bị loại"] += any(v != "OK" for v in kq.values())
        for k, kieu in loi.items():
            bat[ten][kieu] += kq[k] != "OK"
    for kieu in loi.values():
        tong_loai[kieu] += 1
print(f"300 vỉ, {so_vi_tot} vỉ tốt")
for ten in ket:
    print(f"{ten}: vỉ tốt bị loại {ket[ten]['vỉ tốt bị loại']}, " +
          ", ".join(f"bắt {k} {bat[ten][k]}/{tong_loai[k]}" for k in ("thiếu", "mẻ", "sai màu", "đốm bẩn")))

print("\nkích thước mẻ | lời giải 1 bắt | lời giải 2 bắt (mỗi mức 60 viên)")
for me in (0.02, 0.03, 0.05, 0.08, 0.12, 0.20):
    rng_me = np.random.default_rng(int(me * 1000))
    b1 = b2 = 0
    for _ in range(60):
        k = int(rng_me.integers(0, HANG * COT))
        anh = chup_vi({k: "mẻ"}, rng_me, ty_le_me=me)
        b1 += kiem_vi_1(anh)[k] != "OK"
        b2 += kiem_vi_2(anh)[k] != "OK"
    print(f"{me:12.0%}  | {b1:13d} | {b2:14d}")
300 vỉ, 203 vỉ tốt
lời giải 1: vỉ tốt bị loại 65, bắt thiếu 24/24, bắt mẻ 18/21, bắt sai màu 2/22, bắt đốm bẩn 4/30
lời giải 2: vỉ tốt bị loại 0, bắt thiếu 24/24, bắt mẻ 21/21, bắt sai màu 22/22, bắt đốm bẩn 30/30

kích thước mẻ | lời giải 1 bắt | lời giải 2 bắt (mỗi mức 60 viên)
          2%  |             9 |              0
          3%  |             7 |              2
          5%  |            19 |             51
          8%  |            42 |             60
         12%  |            59 |             60
         20%  |            60 |             60
  • Lời giải 1 loại nhầm gần một phần ba số vỉ tốt (vệt chói cộng thêm diện tích, viên lệch ra ngoài ô), bỏ sót gần hết viên lạ màu và đốm bẩn vì nó chỉ nhìn diện tích sáng.
  • Cột "lời giải 1 bắt" ở mẻ 2 đến 3% không có nghĩa là nó nhạy hơn: đó là những hốc bị loại nhầm vì lý do khác, trùng vào hốc có mẻ. Một trạm loại nhầm nhiều luôn trông như "bắt được" lỗi nhỏ.
  • Lời giải 2: 0 vỉ tốt bị loại, bắt đủ mọi lỗi trong bộ thử; mẻ từ 8% trở lên bắt hết, mẻ 5% bắt khoảng 85%, mẻ 2 đến 3% gần như không. Giới hạn này do độ phân giải và độ đều của viên, không phải do thuật toán (bài tập 1).

8. Toàn vẹn dữ liệu: nhật ký chuỗi băm và phân quyền

Yêu cầu về hồ sơ điện tử trong ngành dược (FDA 21 CFR Part 11, EU GMP Annex 11) xoay quanh vài nguyên tắc dễ hiểu: hồ sơ phải ghi được ai, làm gì, lúc nào; thay đổi phải có lý do và không xóa dấu vết cũ; chỉ người có quyền mới được thay đổi; và mọi sửa đổi trái phép phải phát hiện được. Đoạn code dưới hiện thực các nguyên tắc đó ở mức trạm: mỗi bản ghi chứa mã băm SHA-256 của bản ghi trước, nên sửa một bản ghi bất kỳ làm đứt chuỗi từ chỗ đó.

import hashlib
import json


class NhatKy:
    """Nhật ký chỉ ghi thêm (append-only), mỗi bản ghi chứa mã băm của bản ghi trước: sửa hay xóa một
    bản ghi bất kỳ làm đứt chuỗi từ chỗ đó trở đi."""

    def __init__(self):
        self.ban_ghi = []

    def ghi(self, thoi_gian, nguoi, loai, noi_dung):
        truoc = self.ban_ghi[-1]["bam"] if self.ban_ghi else "0" * 64
        bg = {"stt": len(self.ban_ghi), "thoi_gian": thoi_gian, "nguoi": nguoi, "loai": loai,
              "noi_dung": noi_dung, "bam_truoc": truoc}
        bg["bam"] = hashlib.sha256(json.dumps(bg, ensure_ascii=False, sort_keys=True).encode()).hexdigest()
        self.ban_ghi.append(bg)

    def kiem_tra(self):
        """Trả về chỉ số bản ghi đầu tiên bị sửa, hoặc None nếu chuỗi nguyên vẹn."""
        truoc = "0" * 64
        for bg in self.ban_ghi:
            than = {k: v for k, v in bg.items() if k != "bam"}
            if bg["bam_truoc"] != truoc or hashlib.sha256(
                    json.dumps(than, ensure_ascii=False, sort_keys=True).encode()).hexdigest() != bg["bam"]:
                return bg["stt"]
            truoc = bg["bam"]
        return None


QUYEN_DOI_CONG_THUC = {"qa.lan"}                     # chỉ QA được đổi ngưỡng; người vận hành thì không
cong_thuc = {"ma_sp": "PARA-500", "nguong_day": 0.97, "nguong_de": 4.0}


def doi_cong_thuc(nk, thoi_gian, nguoi, khoa, gia_tri, ly_do):
    if nguoi not in QUYEN_DOI_CONG_THUC:
        nk.ghi(thoi_gian, nguoi, "TỪ CHỐI", {"muon_doi": khoa, "gia_tri": gia_tri})
        return False
    nk.ghi(thoi_gian, nguoi, "ĐỔI CÔNG THỨC", {"khoa": khoa, "cu": cong_thuc[khoa], "moi": gia_tri, "ly_do": ly_do})
    cong_thuc[khoa] = gia_tri
    return True


def kiem_vi_theo_cong_thuc(anh):
    lech, do_sang = can_vi(anh)
    if lech is None:
        return None
    return {k: kiem_hoc(dac_trung_vien(anh, g + lech, do_sang), cong_thuc["nguong_day"], cong_thuc["nguong_de"])
            for k, g in enumerate(GOC_HOC)}


nk = NhatKy()
nk.ghi("2026-10-23 06:00:00", "vh.minh", "BẮT ĐẦU LÔ", {"lo": "L2610-07", "cong_thuc": dict(cong_thuc)})
rng_lo = np.random.default_rng(6)
dem = Counter()
for i in range(40):
    loi = tao_vi(rng_lo)
    kq = kiem_vi_theo_cong_thuc(chup_vi(loi, rng_lo))
    hoc_ng = {k: v for k, v in kq.items() if v != "OK"}
    dem["NG" if hoc_ng else "OK"] += 1
    nk.ghi(f"2026-10-23 06:00:{i + 1:02d}", "tram-03", "KẾT QUẢ", {"vi": i, "kq": "NG" if hoc_ng else "OK", "hoc_ng": hoc_ng})
    if i == 15:
        doi_cong_thuc(nk, "2026-10-23 06:00:16", "vh.minh", "nguong_day", 0.90, "")              # vận hành muốn bớt loại
    if i == 25:
        doi_cong_thuc(nk, "2026-10-23 06:00:26", "qa.lan", "nguong_de", 3.5, "CAPA-112: lẫn viên lô khác")
print(f"lô 40 vỉ: {dict(dem)}; {len(nk.ban_ghi)} bản ghi; chuỗi nguyên vẹn: {nk.kiem_tra() is None}")
for bg in nk.ban_ghi:
    if bg["loai"] in ("TỪ CHỐI", "ĐỔI CÔNG THỨC"):
        print(f"  #{bg['stt']} {bg['thoi_gian']} {bg['nguoi']}: {bg['loai']} {bg['noi_dung']}")

# Ai đó sửa một kết quả NG thành OK trong file log
vi_ng = next(bg for bg in nk.ban_ghi if bg["loai"] == "KẾT QUẢ" and bg["noi_dung"]["kq"] == "NG")
vi_ng["noi_dung"] = {**vi_ng["noi_dung"], "kq": "OK", "hoc_ng": {}}
print(f"sau khi sửa bản ghi #{vi_ng['stt']}: kiểm tra báo bản ghi bị sửa đầu tiên là #{nk.kiem_tra()}")
lô 40 vỉ: {'OK': 29, 'NG': 11}; 43 bản ghi; chuỗi nguyên vẹn: True
  #17 2026-10-23 06:00:16 vh.minh: TỪ CHỐI {'muon_doi': 'nguong_day', 'gia_tri': 0.9}
  #28 2026-10-23 06:00:26 qa.lan: ĐỔI CÔNG THỨC {'khoa': 'nguong_de', 'cu': 4.0, 'moi': 3.5, 'ly_do': 'CAPA-112: lẫn viên lô khác'}
sau khi sửa bản ghi #3: kiểm tra báo bản ghi bị sửa đầu tiên là #3

Người vận hành muốn hạ ngưỡng độ đầy xuống 0,90 cho bớt loại: trạm từ chối, nhưng vẫn ghi lại lần thử đó. QA đổi ngưỡng ΔE kèm mã CAPA làm lý do: được chấp nhận, bản ghi lưu cả giá trị cũ và mới. Khi có người sửa một kết quả NG thành OK trong file, hàm kiểm tra chỉ ra đúng bản ghi bị sửa. Lưu ý: đây là các nguyên tắc kỹ thuật cốt lõi, không phải một hệ thống đã được thẩm định (validation). Hệ thống thật cần quy trình thẩm định theo GAMP 5, đồng bộ thời gian, sao lưu, và lưu trữ hồ sơ theo quy định.

9. Bẫy thực tế

BẫyHậu quảCách tránh
Kiểm sau khi đã hàn màng nhômViên trắng trên nền nhôm sáng, gần như không có tương phảnKiểm trước khi hàn, tấm đỡ tối dưới màng PVC; hoặc dùng camera hồng ngoại, chiếu xuyên
Vệt chói đổi chỗ khi đổi lô màng PVCLoại nhầm tăng đột ngộtĐèn khuếch tán (dome), phép đo không phụ thuộc vùng ngoài đường tròn viên
Viên bao phim bóng, viên có khắc chữChữ khắc bị tính là đốm, mẻ giảDạy mẫu riêng cho từng sản phẩm; vùng loại trừ cho phần khắc
Người vận hành chỉnh ngưỡng cho "bớt loại"Lọt lỗi, vi phạm hồ sơPhân quyền, ghi mọi lần đổi kèm lý do, QA duyệt
Log là file CSV, đồng hồ máy trạm chỉnh đượcHồ sơ không đáng tinChuỗi băm có khóa (bài tập 2), đồng bộ giờ với máy chủ, đẩy log về hệ thống trung tâm
Hốc trống do máy cấp viên kẹtHàng loạt vỉ NG liên tiếpĐếm NG liên tiếp theo vị trí hốc, quá ngưỡng thì báo dừng máy

10. Tự đánh giá

  • 300 vỉ: 0 vỉ tốt bị loại, bắt đủ thiếu viên, mẻ, viên lạ, đốm bẩn.
  • Mẻ 8% diện tích: bắt 60/60 trên bộ thử chính nhưng 59/60 trên bộ của bài tập 1, tức đang sát giới hạn của trạm; biết rõ giới hạn dưới và lý do, cân nhắc ngưỡng 0,975 đến 0,98 sau khi có thêm dữ liệu viên tốt.
  • Nhật ký: mọi kết quả và thay đổi có người, thời điểm; sửa một bản ghi bị phát hiện đúng vị trí.
  • Quyền đổi công thức được kiểm soát; lần thử trái phép cũng được ghi.

Bài tập

Bài 1. Chọn ngưỡng độ đầy và biết giới hạn của trạm

Đo độ đầy trên 1 000 viên tốt và trên viên mẻ 5%, 8%, rồi thử các ngưỡng 0,95 đến 0,98.

Xem đáp án
rng_e1 = np.random.default_rng(7)
day_tot, day_me = [], {0.05: [], 0.08: []}
for _ in range(100):
    a = chup_vi({}, rng_e1)
    lech, ds = can_vi(a)
    day_tot += [dac_trung_vien(a, g + lech, ds)["do_day"] for g in GOC_HOC]
for me in day_me:
    for _ in range(60):
        k = int(rng_e1.integers(0, HANG * COT))
        a = chup_vi({k: "mẻ"}, rng_e1, ty_le_me=me)
        lech, ds = can_vi(a)
        day_me[me].append(dac_trung_vien(a, GOC_HOC[k] + lech, ds)["do_day"])
day_tot = np.array(day_tot)
print(f"độ đầy viên tốt: nhỏ nhất {day_tot.min():.3f}, p0.1 {np.percentile(day_tot, 0.1):.3f} (1 000 viên)")
for me, v in day_me.items():
    print(f"độ đầy viên mẻ {me:.0%}: lớn nhất {max(v):.3f}, trung vị {np.median(v):.3f}")
for ng in (0.95, 0.96, 0.97, 0.98):
    print(f"ngưỡng {ng}: viên tốt bị loại {np.sum(day_tot < ng)}/1000, bắt mẻ 5% {np.sum(np.array(day_me[0.05]) < ng)}/60, "
          f"mẻ 8% {np.sum(np.array(day_me[0.08]) < ng)}/60")
độ đầy viên tốt: nhỏ nhất 0.986, p0.1 0.986 (1 000 viên)
độ đầy viên mẻ 5%: lớn nhất 0.986, trung vị 0.962
độ đầy viên mẻ 8%: lớn nhất 0.972, trung vị 0.934
ngưỡng 0.95: viên tốt bị loại 0/1000, bắt mẻ 5% 2/60, mẻ 8% 51/60
ngưỡng 0.96: viên tốt bị loại 0/1000, bắt mẻ 5% 22/60, mẻ 8% 56/60
ngưỡng 0.97: viên tốt bị loại 0/1000, bắt mẻ 5% 48/60, mẻ 8% 59/60
ngưỡng 0.98: viên tốt bị loại 0/1000, bắt mẻ 5% 55/60, mẻ 8% 60/60

Viên tốt nhỏ nhất 0,986; viên mẻ 5% lớn nhất cũng 0,986: hai phân bố chồng nhau, nên không ngưỡng nào tách được hoàn toàn mẻ 5%. Ngưỡng 0,98 bắt nhiều nhất mà chưa loại nhầm viên nào trong 1 000 viên, nhưng khe hở so với viên tốt nhỏ nhất chỉ 0,006: trên một ca vài trăm nghìn viên, phần đuôi của phân bố viên tốt rất có thể vượt qua. Ngưỡng 0,97 (giá trị trong công thức) có khe hở an toàn hơn và vẫn bắt gần hết mẻ 8%, đúng yêu cầu. Muốn bắt chắc mẻ 5% thì phải tăng độ phân giải (nhiều pixel hơn trên mép viên) hoặc thêm đèn góc thấp làm nổi mép vỡ, không phải chỉnh ngưỡng. Ghi rõ giới hạn này trong hồ sơ thẩm định của trạm.

Bài 2. Kẻ sửa log biết tính lại chuỗi băm

Thay vì chỉ sửa một bản ghi, kẻ sửa log tính lại toàn bộ mã băm phía sau. Chuỗi SHA-256 còn phát hiện được không? Sửa thế nào?

Xem đáp án
import hmac

# Kẻ sửa log tinh hơn: sửa bản ghi rồi TÍNH LẠI toàn bộ chuỗi băm phía sau
def tinh_lai_chuoi(nk):
    truoc = "0" * 64
    for bg in nk.ban_ghi:
        bg["bam_truoc"] = truoc
        than = {k: v for k, v in bg.items() if k != "bam"}
        bg["bam"] = hashlib.sha256(json.dumps(than, ensure_ascii=False, sort_keys=True).encode()).hexdigest()
        truoc = bg["bam"]


tinh_lai_chuoi(nk)
print("chuỗi SHA-256 thường sau khi kẻ sửa tính lại:", "nguyên vẹn" if nk.kiem_tra() is None else "bị sửa")


class NhatKyHMAC(NhatKy):
    """Như NhatKy nhưng băm bằng HMAC với khóa bí mật chỉ trạm có (lưu trong TPM/HSM hoặc kho khóa của hệ thống)."""

    def __init__(self, khoa):
        super().__init__()
        self.khoa = khoa

    def _bam(self, than):
        return hmac.new(self.khoa, json.dumps(than, ensure_ascii=False, sort_keys=True).encode(), "sha256").hexdigest()

    def ghi(self, thoi_gian, nguoi, loai, noi_dung):
        truoc = self.ban_ghi[-1]["bam"] if self.ban_ghi else "0" * 64
        bg = {"stt": len(self.ban_ghi), "thoi_gian": thoi_gian, "nguoi": nguoi, "loai": loai,
              "noi_dung": noi_dung, "bam_truoc": truoc}
        bg["bam"] = self._bam(bg)
        self.ban_ghi.append(bg)

    def kiem_tra(self):
        truoc = "0" * 64
        for bg in self.ban_ghi:
            than = {k: v for k, v in bg.items() if k != "bam"}
            if bg["bam_truoc"] != truoc or not hmac.compare_digest(self._bam(than), bg["bam"]):
                return bg["stt"]
            truoc = bg["bam"]
        return None


nk2 = NhatKyHMAC(khoa=b"khoa-bi-mat-cua-tram-03")
for bg in nk.ban_ghi[:10]:
    nk2.ghi(bg["thoi_gian"], bg["nguoi"], bg["loai"], bg["noi_dung"])
nk2.ban_ghi[5]["noi_dung"] = {"vi": 4, "kq": "OK", "hoc_ng": {}}
tinh_lai_chuoi(nk2)                                                  # kẻ sửa không có khóa, chỉ tính lại được SHA-256
print("chuỗi HMAC sau khi kẻ sửa tính lại:", "nguyên vẹn" if nk2.kiem_tra() is None else f"bị sửa từ bản ghi #{nk2.kiem_tra()}")
chuỗi SHA-256 thường sau khi kẻ sửa tính lại: nguyên vẹn
chuỗi HMAC sau khi kẻ sửa tính lại: bị sửa từ bản ghi #0

Chuỗi SHA-256 thường không có gì bí mật: ai có file đều tính lại được, nên chuỗi mới vẫn "nguyên vẹn". Chuỗi băm chỉ phát hiện sửa đổi khi kẻ sửa không thể tạo lại mã băm hợp lệ. HMAC dùng một khóa bí mật chỉ trạm có (lưu trong TPM, HSM hoặc kho khóa của hệ điều hành, không nằm trong mã nguồn): kẻ sửa không có khóa thì mọi mã băm tính lại đều sai, ngay từ bản ghi đầu tiên. Cách bổ sung rẻ và hiệu quả: định kỳ gửi mã băm của bản ghi mới nhất sang một hệ thống khác (MES, máy chủ QA). Muốn sửa lén thì phải sửa được cả ở hai nơi.

Nguồn tham khảo: FDA 21 CFR Part 11: Electronic Records; Electronic Signatures (eCFR); EudraLex Volume 4: EU GMP, Annex 11 Computerised Systems; ISPE, GAMP 5: A Risk-Based Approach to Compliant GxP Computerized Systems, 2nd ed., 2022; Python: hmac; Python: hashlib; OpenCV: Morphological Transformations.

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í.