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.
Nội dung bài viết
Độ 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.
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ượng | Yê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ắt | thiế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ền | chỉ 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
- Phân ngưỡng và contour, morphology (opening để bỏ vệt chói mảnh).
- Fitting đường tròn và loại điểm lệch.
- Kiểm tra màu: Lab, ΔE2000.
- MES và truy xuất nguồn gốc.
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
- Định vị và chuẩn hóa sáng bằng hai lỗ định vị trắng.
- 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).
- 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.
- Độ đầ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ẻ.
- 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ẫy | Hậu quả | Cách tránh |
|---|---|---|
| Kiểm sau khi đã hàn màng nhôm | Viên trắng trên nền nhôm sáng, gần như không có tương phản | Kiể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 PVC | Loạ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 được | Hồ sơ không đáng tin | Chuỗ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ẹt | Hà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.


