Hướng dẫn bạn chi tiết quy trình xây dựng hệ thống OCR trích xuất dữ liệu Căn cước công dân (CCCD) tự động chuẩn Production cho bài toán eKYC, sử dụng kết hợp hai mô hình học sâu DBNet (Text Detection) và VietOCR (Text Recognition).
Đây là một quy trình phổ biến trong nghề AI Engineer, Data Science, hoặc Business Analyst mà mọi người có thể gặp. Đặc biệt là những bạn làm trong lĩnh vực ngân hàng, tài chính, bảo hiểm. Thế nên việc hiểu được hệ thống này hoạt động là một lợi thế lớn.
I. GIỚI THIỆU & NGUYÊN LÝ HỆ THỐNG
1. Đặt vấn đề & Bài toán eKYC thực tế
Trong xu hướng chuyển đổi số của ngành Tài chính - Ngân hàng (BFSI) và các nền tảng thương mại điện tử, quy trình eKYC (Electronic Know Your Customer) đóng vai trò là cửa ngõ xác thực người dùng đầu tiên. Thành phần cốt lõi trong eKYC chính là hệ thống OCR (Optical Character Recognition - Nhận dạng Ký tự Quang học) dành cho giấy tờ định danh, phổ biến nhất tại Việt Nam là thẻ Căn cước công dân (CCCD).
Một hệ thống OCR trong phòng thí nghiệm có thể đạt độ chính xác 99% trên tập dữ liệu đẹp. Tuy nhiên, khi triển khai vào môi trường Production, hệ thống phải đối mặt với hàng loạt thách thức từ ảnh chụp thực tế của người dùng:
Điều kiện ánh sáng bất lợi: Hiện tượng chói lóa (glare) do đèn xẻ bóng trên bề mặt nhựa ép của CCCD, hoặc ảnh chụp thiếu sáng gây nhiễu hạt (noise).
Biến dạng hình học: Ảnh chụp bị xéo góc, độ nghiêng (skew) lớn, méo hình do tiêu cự camera điện thoại.
Chất lượng ảnh thấp: Ảnh mờ nhòe do rung tay (blur), độ phân giải thấp, bị mất góc thẻ.
Nhiễu nền: Nền thẻ CCCD có hoa văn trống đồng, vân tay và tem hoa văn phức tạp đè lên chữ.
2. Kiến trúc hệ thống OCR chuẩn Production
Để giải quyết triệt để các thách thức trên, chúng ta không thể sử dụng các thư viện OCR truyền thống dựa trên thuật toán xử lý ảnh cổ điển (như Tesseract OCR). Thay vào đó, kiến trúc chuẩn Production được thiết kế theo dạng Deep Learning Pipeline 2 giai đoạn riêng biệt (Two-stage Architecture):
Giai đoạn 1 - Text Detection (Phát hiện văn bản): Xác định chính xác vị trí (tọa độ các đỉnh Polygon) của từng vùng chứa chữ trên thẻ CCCD. Ở giai đoạn này, chúng ta sử dụng kiến trúc DBNet (Differentiable Binarization) - thuật toán được công bố bởi Minghui Liao và các cộng sự tại Đại học Khoa học và Công nghệ Huazhong (HUST) năm 2019. DBNet đạt tốc độ xử lý vượt trội và độ chính xác cao trên các văn bản có kích thước, tỉ lệ biến dạng khác nhau.
Giai đoạn 2 - Text Recognition (Nhận dạng văn bản): Cắt từng vùng ảnh chứa chữ thu được từ Giai đoạn 1 và đưa vào mô hình nhận dạng chuỗi ký tự. Chúng ta sử dụng VietOCR - kiến trúc kết hợp Transformer/CRNN được phát triển chuyên biệt cho ngôn ngữ tiếng Việt bởi nhóm nghiên cứu mã nguồn mở tại Việt Nam. VietOCR xử lý triệt để các dấu câu phức tạp (như dấu thanh, dấu mũ) mà các mô hình đa ngôn ngữ thường bỏ sót.
II. CHUẨN BỊ MÔI TRƯỜNG & TẬP DỮ LIỆU
1. Thiết lập môi trường phần mềm
Hệ thống yêu cầu cài đặt môi trường Python 3.9 trở lên kết hợp với các thư viện tính toán hình ảnh và mô hình học sâu. Khuyến nghị sử dụng card đồ họa GPU NVIDIA với CUDA 11.8 trở lên.
Bash
\# Tạo môi trường ảo conda
conda create -n ocr\_cccd python=3.9 -y
conda activate ocr\_cccd
\# Cài đặt PyTorch hỗ trợ CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
\# Cài đặt các thư viện xử lý ảnh và giao diện
pip install opencv-python albumentations Pillow numpy pandas
pip install gradio vietocr
2. Quy trình thu thập & Gán nhãn dữ liệu (Data Annotation)
CẢNH BÁO BẢO MẬT & PHÁP LÝ: Dữ liệu Căn cước công dân chứa thông tin định danh cá nhân (PII) nhạy cảm. Việc thu thập, lưu trữ và xử lý dữ liệu phải tuân thủ nghiêm ngặt Nghị định 13/2023/NĐ-CP của Chính phủ về bảo vệ dữ liệu cá nhân. Trong quá trình huấn luyện mô hình thử nghiệm, kỹ sư nên sử dụng dữ liệu mô phỏng (Synthetic Data) hoặc che mờ (blur) các trường thông tin nhạy cảm của người thật.
Quy trình gán nhãn được chia làm 2 bước độc lập:
A. Gán nhãn cho Text Detection
Sử dụng công cụ Labelme hoặc Roboflow để khoanh vùng từng cụm từ trên thẻ CCCD dưới dạng đa giác 4 điểm (Polygon/Quad).
Định dạng đầu ra được chuyển đổi về dạng ICDAR format: Mỗi dòng tương ứng với một bounding box bao gồm 8 tọa độ [x1, y1, x2, y2, x3, y3, x4, y4] và nhãn nội dung.
B. Gán nhãn cho Text Recognition
Crop tất cả các vùng bounding box thu được ở bước trên thành các bức ảnh dòng chữ đơn lẻ.
Tạo cấu trúc file labels.txt phân cách bằng ký tự Tab (\t):
Plaintext
data/crops/line\_001.png Số / No.:
data/crops/line\_002.png 001095012345
data/crops/line\_003.png Họ và tên / Full name:
data/crops/line\_004.png NGUYỄN VĂN A
III. TIỀN XỬ LÝ & CHUẨN HÓA ẢNH ĐẦU VÀO
Trước khi đưa vào mô hình học sâu, ảnh chụp CCCD cần trải qua bước tiền xử lý để loại bỏ biến dạng hình học và tối ưu hóa độ tương phản.
1. Căn chỉnh khung hình (Perspective Transformation)
Kỹ thuật Perspective Transform giúp biến đổi ảnh CCCD bị chụp nghiêng/chéo về dạng chữ nhật phẳng chuẩn theo tỉ lệ kích thước chuẩn ISO/IEC 7810 ID-1 (85.60 mm x 53.98 mm, tương đương tỉ lệ xấp xỉ 1.586).
Python
import cv2
import numpy as np
def order\_points(pts):
"""
Sắp xếp 4 tọa độ góc theo thứ tự:
Top-Left, Top-Right, Bottom-Right, Bottom-Left
"""
rect = np.zeros((4, 2), dtype="float32")
s = pts.sum(axis=1)
rect\[0\] = pts\[np.argmin(s)\]
rect\[2\] = pts\[np.argmax(s)\]
diff = np.diff(pts, axis=1)
rect\[1\] = pts\[np.argmin(diff)\]
rect\[3\] = pts\[np.argmax(diff)\]
return rect
def align\_cccd(image, pts):
"""
Thực hiện biến đổi Perspective Transformation để làm phẳng ảnh CCCD.
"""
rect = order\_points(pts)
(tl, tr, br, bl) = rect
# Tính toán chiều rộng lớn nhất của ảnh mới
widthA = np.sqrt(((br\[0\] - bl\[0\]) \*\* 2) + ((br\[1\] - bl\[1\]) \*\* 2))
widthB = np.sqrt(((tr\[0\] - tl\[0\]) \*\* 2) + ((tr\[1\] - tl\[1\]) \*\* 2))
maxWidth = max(int(widthA), int(widthB))
# Tính toán chiều cao tương ứng theo tỉ lệ chuẩn ID-1 (~1.586)
maxHeight = int(maxWidth / 1.586)
# Đích đến của 4 góc sau khi nắn phẳng
dst = np.array(\[
\[0, 0\],
\[maxWidth - 1, 0\],
\[maxWidth - 1, maxHeight - 1\],
\[0, maxHeight - 1\]\], dtype="float32")
# Ma trận biến đổi
M = cv2.getPerspectiveTransform(rect, dst)
warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
return warped
2. Tăng cường chất lượng ảnh (Image Enhancement)
Đối với các thẻ CCCD bị bóng nhọt hoặc thiếu sáng, chúng ta áp dụng giải thuật CLAHE (Contrast Limited Adaptive Histogram Equalization) trên kênh màu L của không gian màu LAB để cải thiện độ tương phản cục bộ mà không làm bão hòa màu sắc.
Python
def enhance\_image(image):
# Chuyển từ BGR sang LAB
lab = cv2.cvtColor(image, cv2.COLOR\_BGR2LAB)
l, a, b = cv2.split(lab)
# Áp dụng CLAHE lên kênh L (Luminance)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
cl = clahe.apply(l)
# Gộp lại các kênh màu và chuyển về BGR
limg = cv2.merge((cl, a, b))
enhanced = cv2.cvtColor(limg, cv2.COLOR\_LAB2BGR)
return enhanced
IV. HUẤN LUYỆN MÔ HÌNH TEXT DETECTION VỚI DBNET
1. Tổng quan thuật toán DBNet (Differentiable Binarization)
Trong các kiến trúc Text Detection dựa trên Segmentation truyền thống, quy trình tạo Binarization Map (mặt nạ nhị phân) thường áp dụng một ngưỡng cứng (hard threshold) sau ma trận xác suất (Probability Map). Điều này khiến quá trình này không thể tính đạo hàm (non-differentiable) và không thể tối ưu hóa end-to-end cùng mạng Nơ-ron.
DBNet của Liao và các cộng sự đã giải quyết triệt để vấn đề này bằng cách đưa vào hàm Approximate Binarization, cho phép lan truyền ngược (backpropagation) qua thao tác nhị phân hóa:
HTML
<div style="background-color: #f6f8fa; padding: 12px; border-radius: 6px; text-align: center; font-family: 'Courier New', monospace; margin: 10px 0;">
Hat\_B<sub>i,j</sub> = 1 / (1 + e<sup>-k × (P<sub>i,j</sub> - T<sub>i,j</sub>)</sup>)
</div>
Trong đó:
Pi,j là giá trị tại tọa độ (i, j) trên Probability Map (Ma trận xác suất điểm ảnh thuộc văn bản).
Ti,j là giá trị tại Threshold Map (Ma trận ngưỡng học được).
k là hệ số phóng đại (amplifying factor), thường được thiết lập bằng 50.
Hat_Bi,j là Differentiable Binarization Map.
2. Triển khai cấu trúc mô hình DBNet
Dưới đây là đoạn mã khởi tạo kiến trúc DBNet rút gọn dựa trên Backbone ResNet-18 kết hợp FPN (Feature Pyramid Network):
Python
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import resnet18, ResNet18\_Weights
class DBHead(nn.Module):
def \_\_init\_\_(self, in\_channels, k=50):
super(DBHead, self).\_\_init\_\_()
self.k = k
# Nhánh dự đoán Probability Map
self.p\_module = nn.Sequential(
nn.Conv2d(in\_channels, in\_channels // 4, kernel\_size=3, padding=1),
nn.BatchNorm2d(in\_channels // 4),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(in\_channels // 4, in\_channels // 4, kernel\_size=2, stride=2),
nn.BatchNorm2d(in\_channels // 4),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(in\_channels // 4, 1, kernel\_size=2, stride=2),
nn.Sigmoid()
)
# Nhánh dự đoán Threshold Map
self.t\_module = nn.Sequential(
nn.Conv2d(in\_channels, in\_channels // 4, kernel\_size=3, padding=1),
nn.BatchNorm2d(in\_channels // 4),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(in\_channels // 4, in\_channels // 4, kernel\_size=2, stride=2),
nn.BatchNorm2d(in\_channels // 4),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(in\_channels // 4, 1, kernel\_size=2, stride=2),
nn.Sigmoid()
)
def forward(self, x):
p\_map = self.p\_module(x)
t\_map = self.t\_module(x)
# Tính toán Approximate Binarization Map
hat\_b\_map = 1.0 / (1.0 + torch.exp(-self.k \* (p\_map - t\_map)))
return p\_map, t\_map, hat\_b\_map
class DBNet(nn.Module):
def \_\_init\_\_(self, pretrained=True):
super(DBNet, self).\_\_init\_\_()
weights = ResNet18\_Weights.DEFAULT if pretrained else None
backbone = resnet18(weights=weights)
# Trích xuất các tầng đặc trưng từ ResNet
self.stage1 = nn.Sequential(backbone.conv1, backbone.bn1, backbone.relu, backbone.maxpool, backbone.layer1)
self.stage2 = backbone.layer2
self.stage3 = backbone.layer3
self.stage4 = backbone.layer4
# Kênh ra FPN đơn giản hóa
self.db\_head = DBHead(in\_channels=512)
def forward(self, x):
x1 = self.stage1(x)
x2 = self.stage2(x1)
x3 = self.stage3(x2)
x4 = self.stage4(x3)
# Đi qua DB Head
p\_map, t\_map, hat\_b\_map = self.db\_head(x4)
return p\_map, t\_map, hat\_b\_map
V. HUẤN LUYỆN MÔ HÌNH TEXT RECOGNITION VỚI VIETOCR
1. Kiến trúc VietOCR
VietOCR giải quyết bài toán nhận dạng văn bản tiếng Việt dòng dài thông qua kiến trúc Sequence-to-Sequence biến đổi. Mô hình sử dụng một CNN Backbone (như VGG-16 hoặc ResNet) hoặc Swin Transformer để trích xuất đặc trưng không gian từ ảnh dòng chữ, kết hợp với mạng Transformer Decoder hoặc LSTM + Attention để dự đoán chuỗi tự regressive.
Ưu điểm tuyệt đối của VietOCR so với kiến trúc CRNN + CTC truyền thống là khả năng học ngữ cảnh ngôn ngữ tự nhiên. Nhờ cơ chế Attention, VietOCR dễ dàng phân biệt các ký tự tiếng Việt có dấu dễ gây nhầm lẫn (ví dụ: ơ với ờ, ê với ế) dựa vào ngữ cảnh từ ngữ xung quanh.
2. Fine-tuning VietOCR với dữ liệu CCCD
Chúng ta sẽ tải mô hình huấn luyện sẵn (Pretrained weight vgg_transformer) từ VietOCR và tiến hành Fine-tune trên tập dữ liệu cắt dòng chữ CCCD đã chuẩn bị ở Phần II.
Python
from vietocr.tool.config import Cfg
from vietocr.tool.predictor import Predictor
from vietocr.model.trainer import Trainer
\# 1. Tải cấu hình chuẩn của VietOCR
config = Cfg.load\_config\_from\_name('vgg\_transformer')
\# 2. Bổ sung/Cấu hình đường dẫn dữ liệu huấn luyện
config\['dataset'\]\['train\_part'\] = 'data/crops/train'
config\['dataset'\]\['val\_part'\] = 'data/crops/val'
config\['dataset'\]\['image\_root'\] = 'data/crops/'
\# 3. Điều chỉnh thông số huấn luyện
config\['trainer'\]\['epochs'\] = 20
config\['trainer'\]\['batch\_size'\] = 32
config\['trainer'\]\['lr'\] = 1e-4
config\['device'\] = 'cuda:0'
\# 4. Khởi tạo Trainer và bắt đầu huấn luyện
trainer = Trainer(config)
trainer.train()
VI. GHÉP NỐI PIPELINE & POST-PROCESSING
Sau khi cả hai mô hình DBNet và VietOCR đã được huấn luyện đạt độ chính xác cao, chúng ta kết hợp chúng thành một luồng xử lý End-to-End khép kín.
Python
import torch
import cv2
import numpy as np
from PIL import Image
from vietocr.tool.config import Cfg
from vietocr.tool.predictor import Predictor
class CCCD\_OCR\_Pipeline:
def \_\_init\_\_(self, dbnet\_weight\_path, vietocr\_config\_name='vgg\_transformer'):
self.device = 'cuda' if torch.cuda.is\_available() else 'cpu'
# Initialize VietOCR Predictor
config = Cfg.load\_config\_from\_name(vietocr\_config\_name)
config\['device'\] = self.device
self.vietocr\_predictor = Predictor(config)
# Initialize DBNet (Nên export sang ONNX/TensorRT để chạy tối ưu hơn)
# Ở đây khởi tạo mô hình PyTorch đại diện
self.dbnet = DBNet(pretrained=False).to(self.device)
self.dbnet.load\_state\_dict(torch.load(dbnet\_weight\_path, map\_location=self.device))
self.dbnet.eval()
def detect\_boxes(self, image):
"""
Dự đoán vị trí các bounding boxes bằng DBNet
Trả về danh sách tọa độ bounding boxes \[ymin, xmin, ymax, xmax\]
"""
h, w, \_ = image.shape
# Tiền xử lý ảnh cho DBNet
img\_resized = cv2.resize(image, (512, 512))
img\_tensor = torch.from\_numpy(img\_resized).permute(2, 0, 1).unsqueeze(0).float() / 255.0
img\_tensor = img\_tensor.to(self.device)
with torch.no\_grad():
p\_map, \_, hat\_b\_map = self.dbnet(img\_tensor)
# Đơn giản hóa: Chuyển đổi b\_map sang contours để trích xuất boxes
mask = (hat\_b\_map.squeeze().cpu().numpy() > 0.3).astype(np.uint8)
mask = cv2.resize(mask, (w, h))
contours, \_ = cv2.findContours(mask, cv2.RETR\_LIST, cv2.CHAIN\_APPROX\_SIMPLE)
boxes = \[\]
for cnt in contours:
x, y, bw, bh = cv2.boundingRect(cnt)
if bw > 10 and bh > 10: # Lọc nhiễu nhỏ
boxes.append(\[y, x, y + bh, x + bw\])
# Sắp xếp bounding boxes theo tọa độ Y (từ trên xuống dưới)
boxes = sorted(boxes, key=lambda b: b\[0\])
return boxes
def recognize\_text(self, image, boxes):
"""
Cắt từng vùng ảnh và nhận dạng bằng VietOCR
"""
results = \[\]
for box in boxes:
ymin, xmin, ymax, xmax = box
crop\_img = image\[ymin:ymax, xmin:xmax\]
# Chuyển đổi BGR (OpenCV) sang PIL Image cho VietOCR
crop\_pil = Image.fromarray(cv2.cvtColor(crop\_img, cv2.COLOR\_BGR2RGB))
text = self.vietocr\_predictor.predict(crop\_pil)
results.append({
"box": \[xmin, ymin, xmax, ymax\],
"text": text
})
return results
Kỹ thuật Hậu xử lý (Post-processing Rules)
Kết quả thô từ mô hình OCR cần được chuẩn hóa qua chuỗi quy tắc (Rule-based) và Biểu thức chính quy (Regex) để ánh xạ chính xác vào lược đồ JSON cấu trúc.
Python
import re
def parse\_cccd\_structured\_data(ocr\_results):
"""
Ánh xạ các chuỗi nhận dạng thô vào cấu trúc dữ liệu chuẩn của CCCD
"""
structured\_data = {
"id\_number": None,
"full\_name": None,
"date\_of\_birth": None,
"sex": None,
"nationality": "Việt Nam",
"address": None
}
full\_text = " ".join(\[res\['text'\] for res in ocr\_results\])
# 1. Trích xuất Số CCCD (Bắt buộc đúng 12 chữ số)
id\_pattern = r'\\b\\d{12}\\b'
id\_match = re.search(id\_pattern, full\_text)
if id\_match:
structured\_data\["id\_number"\] = id\_match.group(0)
# 2. Trích xuất Ngày sinh (Định dạng DD/MM/YYYY)
dob\_pattern = r'\\b(0\[1-9\]|\[12\]\[0-9\]|3\[01\])/(0\[1-9\]|1\[012\])/(19\[0-9\]{2}|20\[0-9\]{2})\\b'
dob\_match = re.search(dob\_pattern, full\_text)
if dob\_match:
structured\_data\["date\_of\_birth"\] = dob\_match.group(0)
# 3. Trích xuất Giới tính
if "Nam" in full\_text or "NAM" in full\_text:
structured\_data\["sex"\] = "Nam"
elif "Nữ" in full\_text or "NỮ" in full\_text:
structured\_data\["sex"\] = "Nữ"
return structured\_data
VII. TRỰC QUAN HÓA DEMO VỚI GRADIO & TỐI ƯU PRODUCTION
1. Xây dựng Web Demo với Gradio
Gradio cho phép xây dựng giao diện tương tác web nhẹ nhàng bằng Python để người dùng kiểm thử mô hình một cách trực quan.
Python
import gradio as gr
import json
\# Khởi tạo Pipeline (Giả định weight đã sẵn có)
\# pipeline = CCCD\_OCR\_Pipeline('weights/dbnet\_cccd.pth')
def process\_ocr\_demo(input\_image):
if input\_image is None:
return None, "Vui lòng tải lên ảnh CCCD."
# 1. Căn chỉnh ảnh (Nếu cần)
# 2. Chạy Detection & Recognition
# boxes = pipeline.detect\_boxes(input\_image)
# raw\_ocr = pipeline.recognize\_text(input\_image, boxes)
# Dữ liệu mô phỏng kết quả demo
raw\_ocr = \[
{"box": \[100, 50, 300, 80\], "text": "Số / No.: 001095012345"},
{"box": \[100, 90, 400, 120\], "text": "Họ và tên / Full name: NGUYỄN VĂN A"},
{"box": \[100, 130, 250, 150\], "text": "01/01/1995"}
\]
structured\_data = parse\_cccd\_structured\_data(raw\_ocr)
# Vẽ Bounding Box lên ảnh để hiển thị kết quả
annotated\_image = input\_image.copy()
for item in raw\_ocr:
box = item\['box'\]
cv2.rectangle(annotated\_image, (box\[0\], box\[1\]), (box\[2\], box\[3\]), (0, 255, 0), 2)
return annotated\_image, json.dumps(structured\_data, ensure\_ascii=False, indent=2)
\# Dựng giao diện Gradio
iface = gr.Interface(
fn=process\_ocr\_demo,
inputs=gr.Image(type="numpy", label="Ảnh CCCD Đầu Vào"),
outputs=\[
gr.Image(type="numpy", label="Kết quả Bounding Boxes"),
gr.Code(language="json", label="Dữ liệu Cấu trúc JSON")
\],
title="Hệ Thống Trích Xuất Dữ Liệu CCCD Tự Động (eKYC OCR)",
description="Tải ảnh CCCD để hệ thống tự động phát hiện vị trí văn bản và trích xuất thông tin."
)
if \_\_name\_\_ == "\_\_main\_\_":
iface.launch(server\_name="0.0.0.0", server\_port=7860)
2. Các điểm lưu ý khi đưa hệ thống lên Production
Chuyển đổi Mô hình sang ONNX / TensorRT: Mô hình PyTorch thuần có thời gian phản hồi (latency) cao. Việc chuyển đổi weights sang định dạng ONNX (Open Neural Network Exchange) hoặc tối ưu hóa bằng NVIDIA TensorRT giúp tăng tốc độ xử lý trên GPU gấp 3 đến 5 lần, giảm latency toàn bộ pipeline xuống dưới mức 200 ms trên mỗi ảnh.
Cấu hình Batch Processing: Thay vì đưa từng bức ảnh bị cắt (crop line) vào VietOCR từng cái một, hãy gộp chúng thành từng lô (batch) có cùng chiều cao để xử lý song song trên GPU, giúp tối ưu hiệu năng tính toán.
Tích hợp mô hình chống gian lận (Anti-Spoofing / Liveness Detection): Trong thực tế, hệ thống OCR cần kết hợp với mô hình kiểm tra gian lận (Liveness Check) để phát hiện các trường hợp dùng ảnh chụp lại từ màn hình điện thoại, ảnh in ra giấy, hoặc ảnh CCCD bị chỉnh sửa qua Photoshop.
VIII. TỔNG KẾT & KINH NGHIỆM THỰC TẾ
Xây dựng một hệ thống OCR xử lý giấy tờ định danh tiếng Việt hoàn chỉnh yêu cầu sự kết hợp chặt chẽ giữa kỹ thuật xử lý hình học ảnh thô và kiến trúc học sâu hiện đại:
DBNet đóng vai trò quan trọng trong việc cắt chính xác từng vùng văn bản, bất chấp góc xoay và độ méo của thẻ.
VietOCR giải quyết bài toán nhận dạng ngữ cảnh tiếng Việt có dấu với độ chính xác vượt trội so với các thư viện OCR truyền thống.
Hậu xử lý bằng Regex & Rule-based là thành phần bắt buộc để biến kết quả văn bản thô thành dữ liệu cấu trúc chuẩn xác phục vụ lưu trữ CSDL.
Kinh nghiệm Debug thực tế:
Nếu mô hình nhận dạng bị sai nhiều ở các số 0, 6, 8, 9, hãy kiểm tra lại bước Căn chỉnh góc nghiêng (Perspective Transform); các con số này rất dễ nhầm lẫn nếu ảnh bị méo góc đứng.
Nếu VietOCR bỏ sót ký tự ở mép chữ, hãy mở rộng viền (padding) Bounding Box từ DBNet ra thêm 3 đến 5 pixels trước khi đưa vào bước nhận dạng.
.jpg "Đào tạo Data cho doanh nghiệp: Làm chủ dữ liệu, tối ưu vận hành")
