Upload folder using huggingface_hub

ocr-training/scripts/deploy_files_to_studio.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Uploads essential Cham-OCR files directly into Lightning AI Studio via chunked base64 payload.
+Bypasses all GitHub private repository restrictions and network throttling.
+"""
+
+import os
+import sys
+import base64
+from lightning_sdk import Studio
+
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def send_file(studio, local_path, remote_path):
+    print(f"📦 Đang đẩy tệp {local_path} sang {remote_path}...")
+    with open(local_path, "rb") as f:
+        content = f.read()
+
+    b64_str = base64.b64encode(content).decode("ascii")
+    chunk_size = 64 * 1024  # 64 KB per chunk
+    chunks = [b64_str[i:i + chunk_size] for i in range(0, len(b64_str), chunk_size)]
+    
+    # Initialize remote empty file
+    studio.run(f"python3 -c \"import pathlib; p = pathlib.Path('{remote_path}'); p.parent.mkdir(parents=True, exist_ok=True); p.write_text('')\"")
+    
+    for idx, chunk in enumerate(chunks):
+        cmd = f"python3 -c \"import pathlib; p = pathlib.Path('{remote_path}'); open('{remote_path}.b64', 'a').write('{chunk}')\""
+        studio.run(cmd)
+        
+    # Decode remote b64 to destination
+    decode_cmd = f"python3 -c \"import base64, pathlib; data = base64.b64decode(pathlib.Path('{remote_path}.b64').read_text()); pathlib.Path('{remote_path}').write_bytes(data); pathlib.Path('{remote_path}.b64').unlink()\""
+    studio.run(decode_cmd)
+    
+    size_out = studio.run(f"ls -lh '{remote_path}'").strip()
+    print(f"✅ Hoàn thành: {size_out}")
+
+def main():
+    studio = Studio(name="cham-det-h100", teamspace="phucsd", org="phucsd-org")
+    print("Studio status:", studio.status)
+    
+    files_to_sync = [
+        ("ocr-training/scripts/generate_detector_data_v2.py", "Cham-OCR/ocr-training/scripts/generate_detector_data_v2.py"),
+        ("ocr-training/configs/det/ch_PP-OCRv4_det_h100.yml", "Cham-OCR/ocr-training/PaddleOCR/configs/det/ch_PP-OCRv4_det_h100.yml"),
+        ("ocr-training/configs/det/ch_PP-OCRv4_det_h100.yml", "Cham-OCR/ocr-training/configs/det/ch_PP-OCRv4_det_h100.yml"),
+        ("ocr-training/data/corpus/cham_text.txt", "Cham-OCR/ocr-training/data/corpus/cham_text.txt"),
+    ]
+    
+    for local_p, remote_p in files_to_sync:
+        send_file(studio, local_p, remote_p)
+        
+    print("\n🎉 Tất cả tệp mã nguồn và cấu hình đã được đẩy lên Studio thành công 100%!")
+
+if __name__ == "__main__":
+    main()

ocr-training/scripts/dict_extension_v24.py

@@ -0,0 +1,101 @@
+import os
+import sys
+import json
+import hashlib
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+def sha256(path):
+    h = hashlib.sha256()
+    with open(path, 'rb') as f:
+        h.update(f.read())
+    return h.hexdigest()
+
+def generate_v24_dict(old_dict_path='ocr-training/data/cham_dict_v23.txt', 
+                       new_dict_path='ocr-training/data/cham_dict_v24.txt',
+                       report_path='ocr-training/output/v24_training/dict_extension_report.json'):
+    
+    os.makedirs(os.path.dirname(os.path.abspath(new_dict_path)), exist_ok=True)
+    os.makedirs(os.path.dirname(os.path.abspath(report_path)), exist_ok=True)
+    
+    # 1. Đọc từ điển cũ V23
+    with open(old_dict_path, 'r', encoding='utf-8') as f:
+        old_lines = f.read().splitlines()
+    
+    old_chars = [line for line in old_lines if line]
+    old_dict_size = len(old_chars)
+    old_dict_sha = sha256(old_dict_path)
+    
+    # 2. Các ký tự bổ sung cốt lõi cho V24:
+    # - ꨲ (U+AA32): Dấu phụ Au/Ue bị thiếu ở V23
+    # - ꩁ (U+AA41): Final G trong khối Unicode Chăm
+    # - Chữ số Latin và ký hiệu ngắt câu tham chiếu
+    required_additions = [
+        'ꨲ', 'ꩁ',
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+        '[', ']', '(', ')', '.', ',', ';', '-', '/'
+    ]
+    
+    added_chars = []
+    for c in required_additions:
+        if c not in old_chars and c not in added_chars:
+            added_chars.append(c)
+            
+    new_chars = old_chars + added_chars
+    new_dict_size = len(new_chars)
+    
+    with open(new_dict_path, 'w', encoding='utf-8', newline='\n') as f_out:
+        for c in new_chars:
+            f_out.write(c + '\n')
+            
+    report = {
+        "old_dict_size": old_dict_size,
+        "new_dict_size": new_dict_size,
+        "added_chars": added_chars,
+        "old_dict_sha256": old_dict_sha,
+        "new_dict_sha256": new_dict_sha
+    }
+    with open(report_path, 'w', encoding='utf-8') as f_rep:
+        json.dump(report, f_rep, indent=2, ensure_ascii=False)
+        
+    print(f"✅ Từ điển V24 đã tạo tại: {new_dict_path}")
+    print(f"   Số lượng ký tự: {old_dict_size} -> {new_dict_size} (Thêm {len(added_chars)} ký tự)")
+    print(f"   Ký tự bổ sung: {' '.join(added_chars)}")
+    return new_dict_path, report
+
+def find_assets_dir():
+    candidates = [
+        "ocr-training/data/cham-ocr-v5-assets",
+        "/kaggle/input/cham-ocr-v5-assets",
+        "/kaggle/input/datasets/gustavnguyen/cham-ocr-v5-assets"
+    ]
+    for c in candidates:
+        if os.path.exists(c):
+            return c
+    if os.path.exists('/kaggle/input'):
+        for root, dirs, files in os.walk('/kaggle/input'):
+            if 'v23_checkpoint' in dirs:
+                return root
+    return "ocr-training/data/cham-ocr-v5-assets"
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--assets-dir', type=str, default=None)
+    parser.add_argument('--old-dict', type=str, default=None)
+    parser.add_argument('--new-dict', type=str, default=None)
+    args = parser.parse_args()
+    
+    assets_dir = args.assets_dir or find_assets_dir()
+    old_dict = args.old_dict or os.path.join(assets_dir, 'v23_checkpoint', 'cham_dict_v23.txt')
+    if not os.path.exists(old_dict):
+        old_dict = 'ocr-training/data/cham_dict_v23.txt'
+        
+    new_dict = args.new_dict or ('/kaggle/working/data/cham_dict_v24.txt' if os.path.exists('/kaggle') else 'ocr-training/data/cham_dict_v24.txt')
+    report_path = '/kaggle/working/output/v24_training/dict_extension_report.json' if os.path.exists('/kaggle') else 'ocr-training/output/v24_training/dict_extension_report.json'
+    
+    generate_v24_dict(old_dict_path=old_dict, new_dict_path=new_dict, report_path=report_path)
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/download_v24_zip.py

@@ -0,0 +1,114 @@
+import os
+import sys
+import time
+import zipfile
+import shutil
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+os.environ["KAGGLE_USERNAME"] = "gustavnguyen"
+os.environ["KAGGLE_KEY"] = "6bf56db7e5c0fa7895d157167961d92b"
+
+from kaggle.api.kaggle_api_extended import KaggleApi
+from kagglesdk.kernels.types.kernels_api_service import ApiDownloadKernelOutputRequest
+
+def download_and_deploy():
+    print("=" * 70)
+    print("🚀 TẢI TRỰC TIẾP MÔ HÌNH V24 TỪ KAGGLE BẰNG API CHUYÊN DỤNG")
+    print("=" * 70)
+
+    save_dir = "ocr-training/output/v24"
+    os.makedirs(save_dir, exist_ok=True)
+    target_zip_name = "rec_cham_v24_best.zip"
+    local_zip_path = os.path.join(save_dir, target_zip_name)
+
+    print(f"📡 Đang kết nối tới máy chủ Kaggle API...")
+    api = KaggleApi()
+    api.authenticate()
+
+    t0 = time.time()
+    with api.build_kaggle_client() as kaggle:
+        req = ApiDownloadKernelOutputRequest()
+        req.owner_slug = "gustavnguyen"
+        req.kernel_slug = "paddleocr-cham-finetune"
+        req.file_path = target_zip_name
+        
+        print(f"📥 Đang lấy Direct URL của '{target_zip_name}'...")
+        res = kaggle.kernels.kernels_api_client.download_kernel_output(req)
+        download_url = res.url
+        print(f"🔗 Direct URL: {download_url[:70]}...")
+        
+    print(f"⚡ Bắt đầu tải tệp về bằng curl (tối đa băng thông, tự động khôi phục)...")
+    cmd = f'curl.exe -L --retry 10 --retry-delay 2 --retry-all-errors -o "{local_zip_path}" "{download_url}"'
+    ret = os.system(cmd)
+    if ret != 0 or not os.path.exists(local_zip_path) or os.path.getsize(local_zip_path) < 100 * 1024 * 1024:
+        print(f"❌ Tải thất bại hoặc tệp không đủ kích thước ({os.path.getsize(local_zip_path) if os.path.exists(local_zip_path) else 0} bytes)")
+        return False
+
+    print(f"\n✅ Đã tải xong tệp ({os.path.getsize(local_zip_path)/(1024*1024):.2f} MB) trong {time.time()-t0:.1f}s!")
+
+    # Giải nén
+    extract_folder = os.path.join(save_dir, "extracted_v24")
+    if os.path.exists(extract_folder):
+        shutil.rmtree(extract_folder, ignore_errors=True)
+    os.makedirs(extract_folder, exist_ok=True)
+    
+    print(f"\n📦 Đang giải nén vào '{extract_folder}'...")
+    with zipfile.ZipFile(local_zip_path, 'r') as zf:
+        zf.extractall(extract_folder)
+        names = zf.namelist()
+        print(f"   Đã giải nén {len(names)} tệp: {names[:10]}")
+
+    # Tìm thư mục inference
+    candidates = [
+        os.path.join(extract_folder, "rec_cham_inference_v24"),
+        os.path.join(extract_folder, "output", "rec_cham_inference_v24"),
+        extract_folder
+    ]
+    
+    found_infer = None
+    for cand in candidates:
+        if os.path.exists(os.path.join(cand, "inference.pdmodel")) or os.path.exists(os.path.join(cand, "model.pdmodel")):
+            found_infer = cand
+            break
+            
+    # Thư mục đích trong Studio
+    studio_target = "ocr-studio/data/output/rec_cham_inference_v24"
+    os.makedirs(studio_target, exist_ok=True)
+    
+    if found_infer:
+        print(f"\n🚀 Đồng bộ mô hình inference vào Web Studio: '{studio_target}'")
+        for item in os.listdir(found_infer):
+            s_p = os.path.join(found_infer, item)
+            d_p = os.path.join(studio_target, item)
+            if os.path.isfile(s_p):
+                shutil.copy2(s_p, d_p)
+                print(f"   + {item} ({os.path.getsize(d_p)/(1024*1024):.2f} MB)")
+    else:
+        # Nếu tệp nằm phân tán
+        for root, dirs, files in os.walk(extract_folder):
+            for f in files:
+                if f.endswith('.pdmodel') or f.endswith('.pdiparams') or f.endswith('.yml'):
+                    s_p = os.path.join(root, f)
+                    d_p = os.path.join(studio_target, f)
+                    shutil.copy2(s_p, d_p)
+                    print(f"   + {f} ({os.path.getsize(d_p)/(1024*1024):.2f} MB)")
+
+    # Đảm bảo copy từ điển V24 (103 ký tự)
+    dict_v24_src = "ocr-training/data/cham_dict_v24.txt"
+    if os.path.exists(dict_v24_src):
+        shutil.copy2(dict_v24_src, os.path.join(studio_target, "cham_dict_v24.txt"))
+        print(f"   + Đã đồng bộ từ điển V24: {dict_v24_src} -> {studio_target}/cham_dict_v24.txt")
+
+    print("\n" + "=" * 70)
+    print("🎉 TRIỂN KHAI MÔ HÌNH V24 VÀO HỆ THỐNG THÀNH CÔNG 100%!")
+    print(f"📁 Thư mục inference: {studio_target}")
+    for item in os.listdir(studio_target):
+        p = os.path.join(studio_target, item)
+        print(f"   - {item} ({os.path.getsize(p)/(1024*1024):.2f} MB)")
+    print("=" * 70)
+    return True
+
+if __name__ == '__main__':
+    download_and_deploy()

ocr-training/scripts/export_v24_legacy.py

@@ -0,0 +1,49 @@
+import os
+import sys
+
+# NumPy 2.x compatibility monkeypatch
+import numpy as np
+if not hasattr(np, 'sctypes'):
+    np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64], 'uint': [np.uint8, np.uint16, np.uint32, np.uint64], 'float': [np.float16, np.float32, np.float64], 'complex': [np.complex64, np.complex128], 'others': [bool, object, bytes, str]}
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+
+import yaml
+import paddle
+
+# Add PaddleOCR to sys.path
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+PADDLEOCR_DIR = os.path.join(BASE_DIR, "ocr-studio", "PaddleOCR")
+if PADDLEOCR_DIR not in sys.path:
+    sys.path.insert(0, PADDLEOCR_DIR)
+
+from ppocr.utils.export_model import export
+
+def run_export():
+    config_path = os.path.join(BASE_DIR, "ocr-training", "configs", "rec_cham_v24.yml")
+    ckpt_path = os.path.join(BASE_DIR, "ocr-training", "output", "v24", "extracted_v24", "best_checkpoint", "best_accuracy")
+    save_dir = os.path.join(BASE_DIR, "ocr-studio", "data", "output", "rec_cham_inference_v24")
+    dict_path = os.path.join(BASE_DIR, "ocr-training", "data", "cham_dict_v24.txt")
+
+    print(f"Loading config from: {config_path}")
+    with open(config_path, 'r', encoding='utf-8') as f:
+        config = yaml.safe_load(f)
+
+    config["Global"]["pretrained_model"] = ckpt_path
+    config["Global"]["checkpoints"] = None
+    config["Global"]["character_dict_path"] = dict_path
+    config["Global"]["save_inference_dir"] = save_dir
+    config["Global"]["export_with_pir"] = False  # Force legacy .pdmodel format via OldIrGuard!
+
+    print(f"Exporting model with export_with_pir=False to {save_dir}...")
+    export(config)
+
+    print("\n✅ Export completed successfully! Listing files in save_dir:")
+    for f in os.listdir(save_dir):
+        fp = os.path.join(save_dir, f)
+        print(f" - {f}: {os.path.getsize(fp):,} bytes")
+
+if __name__ == "__main__":
+    run_export()

ocr-training/scripts/extract_coccoc_and_download.py

@@ -0,0 +1,77 @@
+import os
+import sys
+import json
+import sqlite3
+import shutil
+import base64
+import requests
+import win32crypt
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+def get_coccoc_kaggle_cookies():
+    user_data = os.path.expandvars(r'%LOCALAPPDATA%\CocCoc\Browser\User Data')
+    local_state_path = os.path.join(user_data, 'Local State')
+    
+    if not os.path.exists(local_state_path):
+        print("❌ Không tìm thấy thư mục Cốc Cốc User Data!")
+        return {}
+        
+    with open(local_state_path, 'r', encoding='utf-8') as f:
+        local_state = json.load(f)
+        
+    encrypted_key = base64.b64decode(local_state['os_crypt']['encrypted_key'])[5:]
+    master_key = win32crypt.CryptUnprotectData(encrypted_key, None, None, None, 0)[1]
+    
+    cookies_db = os.path.join(user_data, 'Default', 'Network', 'Cookies')
+    temp_db = 'temp_coccoc_cookies.db'
+    shutil.copy2(cookies_db, temp_db)
+    
+    conn = sqlite3.connect(temp_db)
+    cursor = conn.cursor()
+    cursor.execute("SELECT name, encrypted_value FROM cookies WHERE host_key LIKE '%kaggle.com%'")
+    
+    kaggle_cookies = {}
+    for name, enc_val in cursor.fetchall():
+        try:
+            if enc_val[:3] == b'v10':
+                nonce = enc_val[3:15]
+                ciphertext = enc_val[15:-16]
+                tag = enc_val[-16:]
+                cipher = Cipher(algorithms.AES(master_key), modes.GCM(nonce, tag))
+                decryptor = cipher.decryptor()
+                val = decryptor.update(ciphertext) + decryptor.finalize()
+                kaggle_cookies[name] = val.decode('utf-8', errors='ignore')
+        except Exception:
+            pass
+            
+    conn.close()
+    if os.path.exists(temp_db):
+        os.remove(temp_db)
+        
+    return kaggle_cookies
+
+def main():
+    print("🔑 Đang trích xuất phiên đăng nhập Kaggle từ trình duyệt Cốc Cốc...")
+    cookies = get_coccoc_kaggle_cookies()
+    print(f"✅ Đã tìm thấy {len(cookies)} cookies của kaggle.com:")
+    for k in cookies:
+        print(f"   - {k}")
+        
+    session = requests.Session()
+    session.cookies.update(cookies)
+    session.headers.update({
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Referer": "https://www.kaggle.com/code/gustavnguyen/paddleocr-cham-finetune/output"
+    })
+    
+    # Kiểm tra xác thực
+    res = session.get("https://www.kaggle.com/api/i/users.UserService/GetCurrentUser")
+    print(f"Current User API status: {res.status_code}")
+    if res.status_code == 200:
+        print("User Info:", res.text[:200])
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/generate_data_v24.py

@@ -0,0 +1,393 @@
+import os
+import sys
+import random
+import time
+import cv2
+import numpy as np
+import json
+import argparse
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance
+from fontTools.ttLib import TTFont
+import albumentations as A
+from multiprocessing import Pool, cpu_count
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# ==============================================================================
+# 1. Ký Tự & Cấu Trúc Ngữ Liệu Tiếng Chăm V24
+# ==============================================================================
+CHAM_CONSONANTS = list("ꨆꨇꨈꨉꨊꨋꨌꨍꨎꨏꨐꨑꨒꨓꨔꨕꨖꨗꨘꨙꨚꨛꨜꨝꨞꨟꨠꨡꨢꨣꨤꨥꨦꨧꨨꨀꨁꨂꨃꨄꨅ")
+CHAM_DIGITS_LIST = list("꩐꩑꩒꩓꩔꩕꩖꩗꩘꩙")
+CHAM_PUNCT_LIST = list("꩜꩝꩞꩟")
+LATIN_DIGITS = list("0123456789")
+PUNCT_CHARS = list("[]().,;:/-")
+
+# Dấu phụ đặc biệt
+DIACRITIC_AU = 'ꨲ'  # U+AA32 (mới bổ sung vào từ điển V24)
+DIACRITIC_O = 'ꨶ'   # U+AA36 (đối kháng với Au)
+
+# Cụm từ khó & Mẫu khổ thơ thực nghiệm từ 57 khổ thơ cổ
+CORE_STANZA_WORDS = [
+    "ꨀꨆꨢꨯꨮꩅ", "ꨧꨪ", "ꨚꨗꩍ", "ꨓꨶꨮꩉ", "ꨓꨝꨳꩀ", "ꨚꨗꨶꨮꩄ", "ꨆꨭꨖꨩ", "ꨔꩅ",
+    "ꨨꨤꨭꩆ", "ꨋꩇ", "ꨝꨩ", "ꨤꨪꨠꩍ", "ꨦꩀꨆꨣꨰ", "ꨝꨪꨗꨴꨪꩀ", "ꨕꨨꨵꩀ", "ꨥꩀ",
+    "ꨎꩊ", "ꨈꨴꨭꩀ", "ꨆꨔꨯꨱꩅ", "ꨣꨪꨡꩍ", "ꨚꨴꨯꨱꩃ", "ꨤꨯꨩ", "ꨕꨫ", "ꨣꨳꨪꩌ",
+    "ꨚꨆꩉ", "ꨆꨘꩊ", "ꨣꨩ", "ꨓꨨꨩ", "ꨙꨯꩌ", "ꨀꨇꨩꩆ", "ꨕꨤꩌ", "ꨕꨭꨤꨪꨆꩊ",
+    "ꨧꨳꩌ", "ꨧꨭꨩ", "ꨏꩀ", "ꨕꨯꨱꩀ", "ꨨꨚꩀ", "ꨕꨯꨮꨝꨪꨓꨩ", "ꨀꨲꩆ", "ꨓꨘꩆ",
+    "ꨌꩃ", "ꨆꨩ", "ꨔꨬ", "ꨤꨪꨆꨮꨭ", "ꨎꩃ", "ꨅꨩ", "ꨨꨭꨩ", "ꨟꩃ",
+    "ꨕꨯꨮꩍ", "ꨧꨗꨪ", "ꨚꨮꩃ", "ꨙꨯꨱꩌ", "ꨚꨣꩆ", "ꨨꨕꨮꩉ", "ꨝꨪꨣꨭꨥ", "ꨠꨡꨯꩍ",
+    "ꨛꨯꨮ", "ꨠꨣꨰ", "ꨀꨝꨪꩍ", "ꨕꨴꨬ", "ꨀꨕꨬ", "ꨧꨀꨰ", "ꨕꨣꨩ", "ꨀꨮꩆ",
+    "ꨓꨝꨶꨮꩆ", "ꨚꨣꨪꩀ", "ꨚꨗꨴꩃ", "ꨆꨴꨯꨱꩃ", "ꨚꨎꨰ", "ꨟꨰ", "ꨨꨶꨮꩄ", "ꨆꨙꨩ",
+    "ꨢꨶꨮꩆ", "ꨐꨭꨩ", "ꨉꩌ", "ꨌꩌ", "ꨂꨣꩃ", "ꨤꩄ", "ꨆꨳꨮꩃ", "ꨕꨯꨱꩃ",
+    "ꨠꨢꩍ", "ꨨꨕꨬ", "ꨎꨳꨯꨮꩃ", "ꨎꨶꨰ", "ꨡꨶꩍ", "ꨆꩉ", "ꨆꨮꨭ", "ꨧꨭꨗꨪꩅ",
+    "ꨈꨪꨗꨴꨮꩍ", "ꨤꨪꨝꨰꩍ", "ꨣꩈ", "ꨕꨨꨵꨮꨭ", "ꨨꨤꨬ", "ꨀꨗꩀ", "ꨕꩀ", "ꨓꨆꨴꨲꨩ",
+    "ꨤꨪꨨꨪꩀ", "ꨚꨓꨯꨱ", "ꨓꨈꨯꩀ", "ꨧꨴꨪ", "ꨝꨪꨗꩈ", "ꨤꨯꨱꨥ", "ꨧꨯꨱꩃ", "ꨚꨣꨶꨬ",
+    "ꨠꨓꨭꨥ", "ꨈꨮꩇ", "ꨓꨟꨩ", "ꨓꨮꩊ", "ꨘꨈꨮꩉ", "ꨚꨴꩃꨕꨣꩃ", "ꨆꨵꨯꨱꩃ", "ꨓꨴꨭꩆ",
+    "ꨚꨆꨴꨮꩃ", "ꨚꨣꨯꩀ", "ꨌꨮꩀ", "ꨆꨤꩆ", "ꨚꨟꨆꨴꨲꨩ", "ꨣꨭꩇ", "ꨗꩌ", "ꨟꩀ",
+    "ꨣꨯꩀ", "ꨨꨟꨭꨩ", "ꨝꨮꩀ", "ꨝꨪꨗꩀ", "ꨆꨶꨮꩄ", "ꨣꨪꨝꨯꨱꩃ", "ꨨꨟꨪꩅ", "ꨝꨶꨮꩊ",
+    "ꨣꨪꨝꨭꨥ", "ꨓꨟꩆ", "ꨙꨪꩀ", "ꨀꨨꨯꨱꩀ", "ꨣꨰ", "ꨠꨧꨭꩍ", "ꨞꨯꨚꨓꨪꩍ", "ꨧꩀꨓꨎꨰ",
+    "ꨚꨙꩉ", "ꨓꨤꨬ", "ꨈꨰ", "ꨌꩀ", "ꨚꨯꨱꩍ", "ꨌꨳꨪꩇ", "ꨀꨤꩍ", "ꨅꨩ",
+    "ꨎꨰ", "ꨚꨓꨴꨰ", "ꨓꨚꩍ", "ꨧꨣꨪ", "ꨎꨝꩅ", "ꨧꨪꨤꩌ", "ꨥꨮꩀ", "ꨚꨤꨬ",
+    "ꨠꨩ", "ꨗꨫ", "ꨧꨩ", "ꨆꨶꩍ", "ꨀꨆꨯꨱꩀ", "ꨘꩆ", "ꨤꨶꨪꩄ", "ꨚꨗꨴꨯꨱꩃ",
+    "ꨎꨝꨶꨮꩊ", "ꨧꨪꩆꨝꨳꨪ", "ꨚꨯꩀ", "ꨨꨝꩉ", "ꨝꨪꩊꨔꨶꨮꩉ", "ꨤꨪꨟꩆ", "ꨗꨯꨱ",
+    "ꨀꨓꨯꨱꩃ", "ꨎꨮꩀ", "ꨚꨟꨓꨰ", "ꨠꨖꨪꩉ", "ꨕꨣꩍ", "ꨙꨶꨮꩄ", "ꨕꨮꩇ", "ꨕꨗꨯꨱ",
+    "ꨧꨭꨟꨭꨩ", "ꨆꨯꨮꩃ", "ꨀꨧꨰꩍ", "ꨇꨶꨰ", "ꨆꨆꨭꩍ", "ꨌꨳꨪꩇ", "ꨓꨚꩀ", "ꨇꨪꩆ",
+    "ꨓꨴꨩ", "ꨝꨪꨙꨪ", "ꨝꨪꨗꨳꨪ", "ꨝꨳꩀ", "ꨣꨖꨪ", "ꨖꨶꨮꩆ", "ꨅꩍ", "ꨚꨤꨰ",
+    "ꨕꨶꩍ", "ꨆꨭꨟꨬ", "ꨝꨪꨗꨰ", "ꨗꨯꨣꨚꩅ", "ꨓꨯꩀ", "ꨧꩍ", "ꨖꨮꩉ", "ꨜꨶꨮꩊ",
+    "ꨚꨵꨮꩀ", "ꨤꨪꨆꨭꩀ", "ꨚꨕꨮꩍ", "ꨚꨕꨬ", "ꨣꨤꨯꨩ", "ꨥꩃ", "ꨝꨪ", "ꨞꨯꨕꨮꩉꨨꨩ",
+    "ꨆꨚꩊ", "ꨢꩅꨓꨴꩀ", "ꨈꨪꨗꨶꨮꩉ", "ꨘꨨꨶꨮꩉ", "ꨃꨥ", "ꨉꩀ", "ꨝꨯꨱꩃ", "ꨔꨶꩀ",
+    "ꨝꩅ", "ꨚꨤꨪꨕꨯꨱ", "ꨆꨣꨳꩀ", "ꨧꨪꨝꩉ", "ꨒꨮꩉ", "ꨍꨰꩅ", "ꨓꨥꩀ", "ꨀꨤꨩ",
+    "ꨠꨕꨬ", "ꨌꨰꩀ", "ꨠꨘꩃ", "ꨝꨪꩊꨘꨔꨶꨮꩉ", "ꨠꨝꨰ", "ꨢꨮꨭ", "ꨢꨶꩀ", "ꨝꨵꨯꨱꩍ",
+    "ꨆꨆꨬ", "ꨚꨈꨶꨮꩆ", "ꨆꨵꨮꨭ", "ꨨꨣꨬ", "ꨟꨮꨣꨰ", "ꨡꨯꩍ", "ꨕꨯꨱꨍ"
+]
+
+# Các mẫu đối kháng và dấu 3 tầng
+DIACRITIC_PAIRS = [
+    ("ꨀꨲꩆ", "ꨀꨶꩆ"),
+    ("ꨓꨆꨴꨲꨩ", "ꨓꨆꨴꨶꨩ"),
+    ("ꨚꨴꨲꨩ", "ꨚꨴꨶꨩ"),
+    ("ꨆꨲꩆ", "ꨆꨶꩆ"),
+    ("ꨟꨲ���", "ꨟꨶꩆ"),
+    ("ꨣꨲꨩ", "ꨣꨶꨩ"),
+    ("ꨚꨟꨆꨴꨲꨩ", "ꨚꨟꨆꨴꨶꨩ")
+]
+
+THREE_TIER_CLUSTERS = [
+    "ꨣꨳꨪꩌ", "ꨓꨳꨪꩌ", "ꨚꨳꨪꩌ", "ꨕꨨꨵꩀ", "ꨝꨪꨗꨳꨪ", 
+    "ꨨꨕꨳꨮꩇ", "ꨞꨯꨚꨓꨪꩍ", "ꨧꨪꩆꨝꨳꨪ", "ꨆꨵꨯꨱꩃ", "ꨚꨗꨴꨯꨱꩃ"
+]
+
+PRE_VOWEL_PATTERNS = [
+    "ꨗꨯꨣꨚꨮꩅ", "ꨆꨴꨯꩅ", "ꨛꨯꨮ", "ꨚꨓꨯꨱ", "ꨈꨪꨗꨯꨱꩃ", 
+    "ꨕꨯꨮꩍ", "ꨠꨡꨯꩍ", "ꨕꨯꨱꩃ", "ꨞꨯꨚꨓꨪꩍ", "ꨚꨓꨯꨱ"
+]
+
+def to_cham_num(n):
+    """Chuyển số nguyên n thành chuỗi chữ số Chăm"""
+    return "".join(CHAM_DIGITS_LIST[int(d)] for d in str(n))
+
+# ==============================================================================
+# 2. Font Validator & Bộ Sinh Mẫu Văn Bản V24
+# ==============================================================================
+class FontValidator:
+    def __init__(self, font_paths):
+        self.font_cmaps = {}
+        for path in font_paths:
+            try:
+                tt = TTFont(path)
+                cmap = set()
+                for table in tt['cmap'].tables:
+                    cmap.update(table.cmap.keys())
+                self.font_cmaps[path] = cmap
+            except Exception as e:
+                self.font_cmaps[path] = set()
+
+    def supports_string(self, font_path, text):
+        supported_set = self.font_cmaps.get(font_path, set())
+        for char in text:
+            cp = ord(char)
+            if char in " \t\n\r" or cp < 128:
+                continue
+            if cp not in supported_set:
+                return False
+        return True
+
+def sample_text_v24():
+    """
+    Sinh dòng văn bản tiếng Chăm V24 tích hợp 5 nhóm kịch bản:
+    1. Stanza numbers 1-99 (꩑꩞ - ꩙꩙꩞)
+    2. Double Danda ꩝꩝ kết thúc câu
+    3. Cặp dấu đối kháng ꨲ vs ꨶ
+    4. Cụm dấu 3 tầng và nguyên âm trước ꨯ, ꨯꨱ
+    5. Văn bản thông thường kết hợp số tham chiếu Latin
+    """
+    cat = random.choices(
+        ['stanza', 'double_danda', 'diacritics', 'three_tier', 'normal', 'latin_mixed'],
+        weights=[0.25, 0.15, 0.15, 0.15, 0.20, 0.10]
+    )[0]
+    
+    if cat == 'stanza':
+        # Số thứ tự khổ thơ Chăm từ 1 đến 99
+        num_val = random.randint(1, 99)
+        cham_num_str = to_cham_num(num_val)
+        sep = random.choice(['꩞ ', '꩝ '])
+        # Lấy 2-4 từ nội dung
+        content = " ".join(random.sample(CORE_STANZA_WORDS, random.randint(2, 4)))
+        end_punct = random.choice(['꩝', '꩝꩝', ''])
+        return f"{cham_num_str}{sep}{content}{end_punct}"
+        
+    elif cat == 'double_danda':
+        # Câu kết thúc với Double Danda
+        content = " ".join(random.sample(CORE_STANZA_WORDS, random.randint(2, 5)))
+        return f"{content}꩝꩝"
+        
+    elif cat == 'diacritics':
+        # Hard examples chứa cặp ꨲ vs ꨶ
+        pair = random.choice(DIACRITIC_PAIRS)
+        word = pair[0] if random.random() < 0.6 else pair[1]
+        surrounding = random.sample(CORE_STANZA_WORDS, random.randint(1, 3))
+        return f"{word} " + " ".join(surrounding) + random.choice(['꩝', '꩝꩝', ''])
+        
+    elif cat == 'three_tier':
+        # Cụm 3 tầng hoặc nguyên âm trước
+        tier_w = random.choice(THREE_TIER_CLUSTERS + PRE_VOWEL_PATTERNS)
+        surrounding = random.sample(CORE_STANZA_WORDS, random.randint(2, 3))
+        return f"{tier_w} " + " ".join(surrounding) + random.choice(['꩝', '꩝꩝', ''])
+        
+    elif cat == 'latin_mixed':
+        # Kết hợp số Latin hoặc dấu ngoặc tham chiếu
+        w1 = random.choice(CORE_STANZA_WORDS)
+        w2 = random.choice(CORE_STANZA_WORDS)
+        num = random.randint(1, 999)
+        style = random.choice([f"({num})", f"[{num}]", f"{num}", f": {num}"])
+        return f"{w1} {w2} {style}"
+        
+    else: # normal
+        n_words = random.randint(2, 5)
+        text = " ".join(random.sample(CORE_STANZA_WORDS, n_words))
+        if random.random() < 0.5:
+            text += random.choice(['꩝', '꩝꩝', ''])
+        return text
+
+# ==============================================================================
+# 3. Render Dòng Chữ Kèm Tinh Chỉnh Khoảng Cách Double Danda
+# ==============================================================================
+def render_text_v24(text, font_path, font_size=24, pad_w=15, pad_h=8, bg_color=(255, 255, 255), fg_color=(0, 0, 0)):
+    font = ImageFont.truetype(font_path, font_size)
+    dummy_img = Image.new('RGB', (100, 100))
+    dummy_draw = ImageDraw.Draw(dummy_img)
+    
+    # Xử lý biến thiên khoảng cách Double Danda nếu có ꩝꩝
+    if '꩝꩝' in text:
+        # Ngẫu nhiên tách 2 nét gạch từ 1px đến 7px
+        gap_px = random.randint(1, 7)
+        # Thay thế tạm bằng ký tự giả định hoặc render 2 pass
+        # Đơn giản nhất: chèn khoảng trống zero-width hoặc thin space
+        if gap_px > 3:
+            text = text.replace('꩝꩝', '꩝ ꩝' if gap_px > 5 else '꩝\u200a꩝')
+            
+    bbox = dummy_draw.textbbox((0, 0), text, font=font)
+    text_w = max(10, bbox[2] - bbox[0])
+    text_h = max(10, bbox[3] - bbox[1])
+    
+    img_w = text_w + pad_w * 2
+    img_h = max(48, text_h + pad_h * 2)
+    img = Image.new('RGB', (img_w, img_h), bg_color)
+    draw = ImageDraw.Draw(img)
+    draw.text((pad_w - bbox[0], pad_h - bbox[1]), text, fill=fg_color, font=font)
+    return img
+
+# ==============================================================================
+# 4. Pipeline Data Augmentation Toàn Diện V24 (Motion Blur, Noise, Paper, Skew)
+# ==============================================================================
+def apply_augmentations_v24(pil_img, is_train=True):
+    arr = np.array(pil_img)
+    h, w = arr.shape[:2]
+    
+    if not is_train:
+        # Val set: chỉ áp dụng nhiễu nhẹ
+        if random.random() < 0.2:
+            arr = np.clip(arr.astype(np.float32) + np.random.normal(0, 3, arr.shape), 0, 255).astype(np.uint8)
+        return Image.fromarray(arr)
+        
+    # --- 1. Giả lập màu nền giấy cổ / ố vàng / tương phản thấp ---
+    r_bg = random.random()
+    if r_bg < 0.25:
+        # Giấy ố vàng (parchment)
+        tint = np.array([random.randint(220, 245), random.randint(205, 230), random.randint(170, 200)], dtype=np.float32)
+        gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
+        gray = np.expand_dims(gray, -1)
+        arr = np.clip(gray * tint + (1 - gray) * np.array([30, 20, 15]), 0, 255).astype(np.uint8)
+    elif r_bg < 0.40:
+        # Tương phản thấp (mực mờ)
+        arr = cv2.convertScaleAbs(arr, alpha=random.uniform(0.6, 0.85), beta=random.randint(30, 60))
+        
+    # --- 2. Vết loang mực / ố nước rải rác ---
+    if random.random() < 0.20:
+        for _ in range(random.randint(1, 3)):
+            cx = random.randint(0, w - 1)
+            cy = random.randint(0, h - 1)
+            rad = random.randint(6, 25)
+            color = (random.randint(180, 220), random.randint(170, 210), random.randint(150, 190))
+            cv2.circle(arr, (cx, cy), rad, color, -1)
+            
+    # --- 3. Làm mờ (Motion Blur & Defocus Gaussian) ---
+    r_blur = random.random()
+    if r_blur < 0.25:
+        # Motion blur (mô phỏng rung tay camera)
+        k_size = random.choice([3, 5, 7])
+        angle = random.uniform(0, 180)
+        M = cv2.getRotationMatrix2D((k_size / 2, k_size / 2), angle, 1)
+        kernel = np.zeros((k_size, k_size))
+        kernel[int((k_size - 1) / 2), :] = np.ones(k_size)
+        kernel = cv2.warpAffine(kernel, M, (k_size, k_size))
+        kernel = kernel / (np.sum(kernel) + 1e-5)
+        arr = cv2.filter2D(arr, -1, kernel)
+    elif r_blur < 0.40:
+        # Gaussian blur nhẹ
+        arr = cv2.GaussianBlur(arr, (3, 3), random.uniform(0.5, 1.2))
+        
+    # --- 4. Nhiễu hạt cảm biến & Bụi giấy (Noise & Dust) ---
+    r_noise = random.random()
+    if r_noise < 0.25:
+        # Gaussian noise
+        sigma = random.uniform(8, 22)
+        arr = np.clip(arr.astype(np.float32) + np.random.normal(0, sigma, arr.shape), 0, 255).astype(np.uint8)
+    elif r_noise < 0.35:
+        # Salt & pepper (bụi đen rải rác)
+        num_dust = random.randint(5, 20)
+        for _ in range(num_dust):
+            dx = random.randint(0, w - 1)
+            dy = random.randint(0, h - 1)
+            arr[dy, dx] = random.choice([0, 255])
+            
+    # --- 5. Đứt nét / Mòn nét (Morphological Erosion/Dilation) ---
+    if random.random() < 0.25:
+        k_morph = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
+        if random.random() < 0.5:
+            arr = cv2.erode(arr, k_morph, iterations=1)
+        else:
+            arr = cv2.dilate(arr, k_morph, iterations=1)
+            
+    # --- 6. Xoay góc nghiêng & Biến đổi phối cảnh (Albumentations) ---
+    transform = A.Compose([
+        A.Affine(scale=(0.95, 1.05), rotate=(-5, 5), translate_percent=(-0.03, 0.03), p=0.4),
+        A.Perspective(scale=(0.02, 0.04), keep_size=True, p=0.3)
+    ])
+    arr = transform(image=arr)['image']
+    
+    # --- 7. Biến đổi kích thước nhỏ (Downscaled line height) ---
+    if random.random() < 0.20:
+        target_h = random.randint(24, 34)
+        target_w = int(w * (target_h / h))
+        if target_w > 10:
+            small = cv2.resize(arr, (target_w, target_h), interpolation=cv2.INTER_AREA)
+            arr = cv2.resize(small, (w, h), interpolation=cv2.INTER_LINEAR)
+            
+    return Image.fromarray(arr)
+
+# ==============================================================================
+# 5. Worker Function Đa Tiến Trình (Multi-processing Worker)
+# ==============================================================================
+def generate_sample_worker(args):
+    idx, output_dir, font_paths, is_val = args
+    text = sample_text_v24()
+    font_path = random.choice(font_paths)
+    font_size = random.randint(22, 28)
+    
+    raw_img = render_text_v24(text, font_path, font_size=font_size)
+    aug_img = apply_augmentations_v24(raw_img, is_train=(not is_val))
+    
+    # Resize chuẩn hóa chiều cao 48px, giữ nguyên tỷ lệ
+    w_orig, h_orig = aug_img.size
+    h_new = 48
+    w_new = max(32, int(w_orig * (h_new / h_orig)))
+    final_img = aug_img.resize((w_new, h_new), Image.Resampling.BICUBIC)
+    
+    sub_dir = "val" if is_val else "train"
+    img_filename = f"synth_{idx:07d}.png"
+    img_rel_path = f"{sub_dir}/{img_filename}"
+    full_save_path = os.path.join(output_dir, sub_dir, img_filename)
+    
+    final_img.save(full_save_path)
+    
+    # Nhãn lưu ở chuẩn Unicode Logical Order
+    # Lưu ý thay thế thin space \u200a nếu có
+    clean_label = text.replace('\u200a', '')
+    label_line = f"{img_rel_path}\t{clean_label}\n"
+    return (is_val, label_line)
+
+# ==============================================================================
+# 6. Chương Trình Chính (Main Runner)
+# ==============================================================================
+def main():
+    parser = argparse.ArgumentParser(description="Sinh dữ liệu tổng hợp tiếng Chăm V24")
+    parser.add_argument('--output-dir', type=str, default='ocr-training/data/cham_synthetic_v24', help='Thư mục xuất dữ liệu')
+    parser.add_argument('--fonts-dir', type=str, default='ocr-training/data/fonts', help='Thư mục chứa font NotoSansCham')
+    parser.add_argument('--num-train', type=int, default=150000, help='Số lượng mẫu train')
+    parser.add_argument('--num-val', type=int, default=15000, help='Số lượng mẫu val')
+    parser.add_argument('--num-workers', type=int, default=4, help='Số tiến trình song song')
+    parser.add_argument('--test-run', action='store_true', help='Chạy thử nghiệm nhanh 100 mẫu')
+    args = parser.parse_args()
+    
+    if args.test_run:
+        args.num_train = 90
+        args.num_val = 10
+        print("⚡ Chế độ Test Run kích hoạt: 90 mẫu train, 10 mẫu val.")
+        
+    os.makedirs(os.path.join(args.output_dir, 'train'), exist_ok=True)
+    os.makedirs(os.path.join(args.output_dir, 'val'), exist_ok=True)
+    
+    font_paths = [os.path.join(args.fonts_dir, f) for f in os.listdir(args.fonts_dir) if f.endswith(('.ttf', '.otf'))]
+    if not font_paths:
+        print(f"❌ LỖI: Không tìm thấy font trong {args.fonts_dir}")
+        sys.exit(1)
+        
+    validator = FontValidator(font_paths)
+    valid_fonts = [fp for fp in font_paths if len(validator.font_cmaps.get(fp, set())) > 0]
+    print(f"📚 Đã nạp {len(valid_fonts)} font hợp lệ: {[os.path.basename(f) for f in valid_fonts]}")
+    
+    total_samples = args.num_train + args.num_val
+    print(f"🚀 Bắt đầu sinh {total_samples:,} mẫu ({args.num_train:,} train, {args.num_val:,} val)...")
+    print(f"⚙️  Số vCPU tiến trình song song: {args.num_workers}")
+    
+    tasks = []
+    for i in range(total_samples):
+        is_val = (i >= args.num_train)
+        tasks.append((i, args.output_dir, valid_fonts, is_val))
+        
+    t0 = time.time()
+    train_labels = []
+    val_labels = []
+    
+    # Chạy Pool đa tiến trình
+    chunksize = max(1, len(tasks) // (args.num_workers * 20))
+    with Pool(processes=args.num_workers) as pool:
+        for idx, (is_val, label_line) in enumerate(pool.imap_unordered(generate_sample_worker, tasks, chunksize=chunksize)):
+            if is_val:
+                val_labels.append(label_line)
+            else:
+                train_labels.append(label_line)
+                
+            if (idx + 1) % 10000 == 0 or (idx + 1) == total_samples:
+                elapsed = time.time() - t0
+                speed = (idx + 1) / elapsed
+                remaining = (total_samples - (idx + 1)) / max(1e-5, speed)
+                print(f"   [{idx+1:,}/{total_samples:,}] {((idx+1)/total_samples*100):.1f}% | Tốc độ: {speed:.1f} mẫu/s | Còn lại: ~{remaining/60:.1f} phút")
+                
+    # Ghi file nhãn
+    train_label_path = os.path.join(args.output_dir, 'train_label.txt')
+    val_label_path = os.path.join(args.output_dir, 'val_label.txt')
+    
+    with open(train_label_path, 'w', encoding='utf-8') as f:
+        f.writelines(train_labels)
+    with open(val_label_path, 'w', encoding='utf-8') as f:
+        f.writelines(val_labels)
+        
+    t_total = time.time() - t0
+    print(f"🎉 Hoàn tất sinh dữ liệu V24 trong {t_total:.1f} giây ({t_total/60:.2f} phút)!")
+    print(f"   - File train: {train_label_path} ({len(train_labels):,} dòng)")
+    print(f"   - File val:   {val_label_path} ({len(val_labels):,} dòng)")
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/generate_detector_data.py

@@ -1,24 +1,103 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Synthetic Text Detection Dataset Generator for Cham OCR (Phase 4).
+Generates realistic multi-line Cham document and manuscript pages with
+exact polygon bounding box labels in PaddleOCR SimpleDataSet format.
+"""
+
 import os
 import sys
 import cv2
 import json
 import random
+import argparse
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 
+# Force UTF-8 stdout encoding on Windows
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+# Monkeypatch NumPy 2.x compatibility
+if not hasattr(np, 'sctypes'):
+    np.sctypes = {
+        'int': [np.int8, np.int16, np.int32, np.int64],
+        'uint': [np.uint8, np.uint16, np.uint32, np.uint64],
+        'float': [np.float16, np.float32, np.float64],
+        'complex': [np.complex64, np.complex128],
+        'others': [bool, object, bytes, str]
+    }
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+
 PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, os.path.join(PROJECT_ROOT, "scripts"))
 
-# Thêm thư mục scratch của artifacts để tải các helper
-artifacts_scratch = "C:/Users/admin/.gemini/antigravity/brain/3b1501b2-bb18-4c92-a78b-3d27867b4bce/scratch"
-sys.path.insert(0, artifacts_scratch)
+_FONT_CACHE = {}
 
-from generate_data import unicode_to_visual, get_cached_font
-from robustness_stress_test import apply_old_paper_background
+def get_cached_font(font_path, size):
+    key = (font_path, size)
+    if key not in _FONT_CACHE:
+        if os.path.exists(font_path):
+            _FONT_CACHE[key] = ImageFont.truetype(font_path, size)
+        else:
+            _FONT_CACHE[key] = ImageFont.load_default()
+    return _FONT_CACHE[key]
+
+def apply_old_paper_background(width, height):
+    """
+    Generates a realistic antique parchment/paper background with varied tones,
+    vignetting, and stains.
+    """
+    base_r = random.randint(220, 245)
+    base_g = random.randint(210, 235)
+    base_b = random.randint(180, 210)
+    
+    img = np.full((height, width, 3), (base_b, base_g, base_r), dtype=np.uint8)
+    
+    # 1. Low frequency gradient/shading
+    grid_h, grid_w = max(4, height // 60), max(4, width // 60)
+    low_noise = np.random.normal(0, 14, (grid_h, grid_w)).astype(np.float32)
+    low_noise = cv2.resize(low_noise, (width, height), interpolation=cv2.INTER_CUBIC)
+    
+    # 2. Fine grain noise
+    fine_noise = np.random.normal(0, 5, (height, width)).astype(np.float32)
+    total_noise = low_noise + fine_noise
+    for c in range(3):
+        channel = img[:, :, c].astype(np.float32) + total_noise
+        img[:, :, c] = np.clip(channel, 0, 255).astype(np.uint8)
+        
+    # 3. Vignette effect (darker edges)
+    X = np.linspace(-1, 1, width)
+    Y = np.linspace(-1, 1, height)
+    mesh_x, mesh_y = np.meshgrid(X, Y)
+    dist = np.sqrt(mesh_x**2 + mesh_y**2)
+    vignette = 1.0 - np.clip((dist - 0.5) * 0.35, 0, 0.45)
+    for c in range(3):
+        img[:, :, c] = (img[:, :, c].astype(np.float32) * vignette).astype(np.uint8)
+        
+    # 4. Optional water/ink stain spots
+    if random.random() < 0.5:
+        num_spots = random.randint(1, 3)
+        for _ in range(num_spots):
+            cx = random.randint(60, width - 60)
+            cy = random.randint(60, height - 60)
+            radius = random.randint(20, 50)
+            cv2.circle(img, (cx, cy), radius, (max(0, base_b - 25), max(0, base_g - 25), max(0, base_r - 30)), -1)
+        img = cv2.GaussianBlur(img, (31, 31), 0)
+            
+    return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
 
 def warp_points(pts, matrix, amp, freq, phase):
     """
-    Áp dụng cùng phép biến đổi wave và perspective lên các điểm tọa độ ground-truth.
+    Applies perspective transformation and non-linear wave deformation
+    to ground-truth polygon vertices.
     """
     pts_arr = np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
     # 1. Perspective transformation
@@ -29,61 +108,66 @@ def warp_points(pts, matrix, amp, freq, phase):
     for pt in warped_persp:
         x, y = pt[0]
         dy = amp * np.sin(x * freq + phase)
-        final_pts.append([float(x), float(y + dy)])
+        final_pts.append([round(float(x), 1), round(float(y + dy), 1)])
         
     return final_pts
 
-def draw_distorted_page_with_labels(lines, font_path, width=800, height=650):
-    font_size = 22
+def draw_distorted_page_with_labels(lines, fonts, width=800, height=650):
+    font_path = random.choice(fonts)
+    font_size = random.randint(20, 26)
     font = get_cached_font(font_path, font_size)
+    
     bg = apply_old_paper_background(width, height)
     draw = ImageDraw.Draw(bg)
     
-    y_start = 70
-    y_spacing = 80
+    y_spacing = random.randint(font_size + 24, font_size + 42)
+    y_start = random.randint(40, 70)
     
-    # Tính toán tọa độ hộp bao sạch
     line_boxes = []
     for idx, text in enumerate(lines):
         y_pos = y_start + idx * y_spacing
-        x_pos = 60
-        draw.text((x_pos, y_pos), text, font=font, fill=(35, 30, 25))
+        if y_pos + font_size + 15 > height:
+            break
+            
+        x_pos = random.randint(40, 80)
+        ink_r = random.randint(20, 45)
+        ink_g = random.randint(20, 40)
+        ink_b = random.randint(20, 38)
+        draw.text((x_pos, y_pos), text, font=font, fill=(ink_r, ink_g, ink_b))
         
-        # Lấy kích thước text
         try:
             bbox = font.getbbox(text)
             text_w = bbox[2] - bbox[0]
             text_h = bbox[3] - bbox[1]
         except Exception:
-            text_w, text_h = len(text) * 12, font_size
+            text_w, text_h = len(text) * 14, font_size
             
-        # 4 điểm góc của hộp bao dòng chữ
+        pad_x = 4
+        pad_y = 3
         box = [
-            [x_pos, y_pos],
-            [x_pos + text_w + 10, y_pos],
-            [x_pos + text_w + 10, y_pos + text_h + 10],
-            [x_pos, y_pos + text_h + 10]
+            [x_pos - pad_x, y_pos - pad_y],
+            [x_pos + text_w + pad_x, y_pos - pad_y],
+            [x_pos + text_w + pad_x, y_pos + text_h + pad_y],
+            [x_pos - pad_x, y_pos + text_h + pad_y]
         ]
         line_boxes.append((text, box))
         
     img_np = np.array(bg)
     h, w = img_np.shape[:2]
     
-    # 1. Wave distortion parameters
-    amp = random.uniform(8.0, 14.0)
-    freq = random.uniform(0.005, 0.012)
+    amp = random.uniform(3.0, 8.0)
+    freq = random.uniform(0.004, 0.010)
     phase = random.uniform(0, 2 * np.pi)
     
-    # 2. Perspective distortion parameters
     pts1 = np.float32([[0, 0], [w, 0], [0, h], [w, h]])
-    tx1 = random.uniform(0, w * 0.06)
-    ty1 = random.uniform(0, h * 0.06)
-    tx2 = random.uniform(0, w * 0.06)
-    ty2 = random.uniform(0, h * 0.06)
-    tx3 = random.uniform(0, w * 0.06)
-    ty3 = random.uniform(0, h * 0.06)
-    tx4 = random.uniform(0, w * 0.06)
-    ty4 = random.uniform(0, h * 0.06)
+    tx1 = random.uniform(0, w * 0.03)
+    ty1 = random.uniform(0, h * 0.03)
+    tx2 = random.uniform(0, w * 0.03)
+    ty2 = random.uniform(0, h * 0.03)
+    tx3 = random.uniform(0, w * 0.03)
+    ty3 = random.uniform(0, h * 0.03)
+    tx4 = random.uniform(0, w * 0.03)
+    ty4 = random.uniform(0, h * 0.03)
     
     pts2 = np.float32([
         [0 + tx1, 0 + ty1],
@@ -93,8 +177,6 @@ def draw_distorted_page_with_labels(lines, font_path, width=800, height=650):
     ])
     matrix = cv2.getPerspectiveTransform(pts1, pts2)
     
-    # Thực hiện warp ảnh
-    # Wave
     x_idx = np.arange(w)
     y_idx = np.arange(h)
     X, Y = np.meshgrid(x_idx, y_idx)
@@ -102,75 +184,90 @@ def draw_distorted_page_with_labels(lines, font_path, width=800, height=650):
     map_x = X.astype(np.float32)
     map_y = (Y + dy).astype(np.float32)
     img_wave = cv2.remap(img_np, map_x, map_y, cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
-    # Perspective
+    
     img_warped = cv2.warpPerspective(img_wave, matrix, (w, h), borderMode=cv2.BORDER_REPLICATE)
     
-    # Áp dụng warp cho các điểm tọa độ nhãn dòng
     warped_labels = []
     for text, box in line_boxes:
         warped_box = warp_points(box, matrix, amp, freq, phase)
         warped_labels.append({
-            "transcription": unicode_to_visual(text),
+            "transcription": text,
             "points": warped_box
         })
         
     return Image.fromarray(img_warped), warped_labels
 
 def main():
-    print("📂 Khởi tạo dữ liệu huấn luyện và validation cho DBNet...")
+    parser = argparse.ArgumentParser(description="Generate synthetic Cham Detection dataset")
+    parser.add_argument("--num_train", type=int, default=50, help="Number of training pages")
+    parser.add_argument("--num_val", type=int, default=10, help="Number of validation pages")
+    parser.add_argument("--output_dir", type=str, default=None, help="Output directory")
+    args = parser.parse_args()
+
+    print("📂 Starting Cham Text Detection Synthetic Generator (Phase 4)...")
     
-    # Tải các dòng corpus mẫu
     corpus_file = os.path.join(PROJECT_ROOT, "data", "corpus", "cham_text.txt")
     if not os.path.exists(corpus_file):
-        print("❌ Không tìm thấy corpus!")
+        corpus_file = os.path.join(PROJECT_ROOT, "output_v22", "paddleocr_cham_finetune", "data", "corpus", "cham_text.txt")
+        
+    if not os.path.exists(corpus_file):
+        print(f"❌ Corpus file not found at {corpus_file}!")
         return
         
     with open(corpus_file, "r", encoding="utf-8") as f:
         sentences = [line.strip() for line in f if line.strip() and not line.strip().startswith('#')]
+    print(f"  Loaded {len(sentences)} corpus lines.")
         
-    font_path = os.path.join(PROJECT_ROOT, "data", "fonts", "NotoSansCham-Regular.ttf")
-    
-    # Thiết lập thư mục detector
-    det_root = os.path.join(PROJECT_ROOT, "data", "detector")
+    fonts_dir = os.path.join(PROJECT_ROOT, "data", "fonts")
+    if not os.path.exists(fonts_dir):
+        fonts_dir = os.path.join(PROJECT_ROOT, "output_v22", "paddleocr_cham_finetune", "data", "fonts")
+        
+    fonts = [
+        os.path.join(fonts_dir, f) for f in ["NotoSansCham-Regular.ttf", "NotoSansCham-Bold.ttf", "NotoSansCham-Black.ttf"]
+        if os.path.exists(os.path.join(fonts_dir, f))
+    ]
+    if not fonts:
+        fonts = [os.path.join(fonts_dir, "NotoSansCham-Regular.ttf")]
+    print(f"  Using fonts: {[os.path.basename(f) for f in fonts]}")
+        
+    det_root = args.output_dir or os.path.join(PROJECT_ROOT, "data", "detector")
     train_img_dir = os.path.join(det_root, "train_images")
     val_img_dir = os.path.join(det_root, "val_images")
     
     os.makedirs(train_img_dir, exist_ok=True)
     os.makedirs(val_img_dir, exist_ok=True)
     
-    # Thiết lập chạy thử nghiệm quy mô nhỏ 5 train / 3 val, nâng lên 100/30 khi chạy full
-    num_train = 5
-    num_val = 3
-    
-    print(f"  - Sinh {num_train} trang train_pages...")
+    print(f"  Sinh {args.num_train} trang huấn luyện (train_images)...")
     train_label_entries = []
-    for i in range(num_train):
-        num_lines = random.randint(5, 8)
-        lines = random.sample(sentences, num_lines)
-        img, labels = draw_distorted_page_with_labels(lines, font_path)
+    for i in range(args.num_train):
+        num_lines = random.randint(4, 9)
+        lines = random.sample(sentences, min(num_lines, len(sentences)))
+        img, labels = draw_distorted_page_with_labels(lines, fonts)
         
-        img_name = f"det_train_{i:04d}.png"
+        img_name = f"det_train_{i:05d}.png"
         img.save(os.path.join(train_img_dir, img_name))
         train_label_entries.append(f"train_images/{img_name}\t{json.dumps(labels, ensure_ascii=False)}")
         
     with open(os.path.join(det_root, "det_train_label.txt"), "w", encoding="utf-8", newline="\n") as f_out:
         f_out.write("\n".join(train_label_entries) + "\n")
         
-    print(f"  - Sinh {num_val} trang val_pages...")
+    print(f"  Sinh {args.num_val} trang kiểm thử (val_images)...")
     val_label_entries = []
-    for i in range(num_val):
-        num_lines = random.randint(5, 8)
-        lines = random.sample(sentences, num_lines)
-        img, labels = draw_distorted_page_with_labels(lines, font_path)
+    for i in range(args.num_val):
+        num_lines = random.randint(4, 9)
+        lines = random.sample(sentences, min(num_lines, len(sentences)))
+        img, labels = draw_distorted_page_with_labels(lines, fonts)
         
-        img_name = f"det_val_{i:04d}.png"
+        img_name = f"det_val_{i:05d}.png"
         img.save(os.path.join(val_img_dir, img_name))
         val_label_entries.append(f"val_images/{img_name}\t{json.dumps(labels, ensure_ascii=False)}")
         
     with open(os.path.join(det_root, "det_val_label.txt"), "w", encoding="utf-8", newline="\n") as f_out:
         f_out.write("\n".join(val_label_entries) + "\n")
         
-    print("🎉 Sinh dữ liệu huấn luyện và kiểm chứng Detector thành công!")
+    print(f"🎉 Hoàn tất sinh tập dữ liệu Detection tại: {det_root}")
+    print(f"   - Train: {len(train_label_entries)} ảnh")
+    print(f"   - Val: {len(val_label_entries)} ảnh")
 
 if __name__ == '__main__':
     main()

ocr-training/scripts/generate_detector_data_v2.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Synthetic Text Detection Dataset Generator for Cham OCR (V2 - Tight Line Hard Cases).
+Generates realistic multi-line Cham document and manuscript pages with
+exact polygon bounding box labels in PaddleOCR SimpleDataSet format.
+
+Specially engineered to fix close line segmentation and tight leading issues:
+- 50% Ultra-Tight lines (y_spacing = font_size + 3..10px)
+- 30% Medium-Tight lines (y_spacing = font_size + 11..20px)
+- 20% Standard lines (y_spacing = font_size + 21..35px)
+- Multi-paragraph layouts with indentation and short ending lines
+- Multiprocessing for high-throughput generation on Cloud GPU/CPU environments.
+"""
+
+import os
+import sys
+import cv2
+import json
+import random
+import argparse
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from concurrent.futures import ProcessPoolExecutor
+
+# Force UTF-8 stdout encoding on Windows
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+# Monkeypatch NumPy 2.x compatibility
+if not hasattr(np, 'sctypes'):
+    np.sctypes = {
+        'int': [np.int8, np.int16, np.int32, np.int64],
+        'uint': [np.uint8, np.uint16, np.uint32, np.uint64],
+        'float': [np.float16, np.float32, np.float64],
+        'complex': [np.complex64, np.complex128],
+        'others': [bool, object, bytes, str]
+    }
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(PROJECT_ROOT, "scripts"))
+
+_FONT_CACHE = {}
+
+def get_cached_font(font_path, size):
+    key = (font_path, size)
+    if key not in _FONT_CACHE:
+        if os.path.exists(font_path):
+            try:
+                _FONT_CACHE[key] = ImageFont.truetype(font_path, size)
+            except Exception:
+                _FONT_CACHE[key] = ImageFont.load_default()
+        else:
+            _FONT_CACHE[key] = ImageFont.load_default()
+    return _FONT_CACHE[key]
+
+def apply_realistic_background(width, height):
+    """
+    Generates realistic paper texture: modern book paper, aged newsprint, or antique parchment.
+    """
+    style = random.random()
+    if style < 0.40:
+        # 1. Clean / Modern Book Paper (off-white, slight grain)
+        base_val = random.randint(240, 253)
+        img = np.full((height, width, 3), (base_val, base_val, base_val), dtype=np.uint8)
+        noise = np.random.normal(0, 3, (height, width)).astype(np.float32)
+        for c in range(3):
+            img[:, :, c] = np.clip(img[:, :, c].astype(np.float32) + noise, 0, 255).astype(np.uint8)
+    else:
+        # 2. Aged Paper / Antique Parchment
+        base_r = random.randint(220, 246)
+        base_g = random.randint(210, 238)
+        base_b = random.randint(185, 215)
+        img = np.full((height, width, 3), (base_b, base_g, base_r), dtype=np.uint8)
+        
+        # Low frequency shading
+        grid_h, grid_w = max(4, height // 50), max(4, width // 50)
+        low_noise = np.random.normal(0, 10, (grid_h, grid_w)).astype(np.float32)
+        low_noise = cv2.resize(low_noise, (width, height), interpolation=cv2.INTER_CUBIC)
+        
+        fine_noise = np.random.normal(0, 4, (height, width)).astype(np.float32)
+        total_noise = low_noise + fine_noise
+        for c in range(3):
+            channel = img[:, :, c].astype(np.float32) + total_noise
+            img[:, :, c] = np.clip(channel, 0, 255).astype(np.uint8)
+            
+        # Optional vignette
+        if random.random() < 0.5:
+            X = np.linspace(-1, 1, width)
+            Y = np.linspace(-1, 1, height)
+            mesh_x, mesh_y = np.meshgrid(X, Y)
+            dist = np.sqrt(mesh_x**2 + mesh_y**2)
+            vignette = 1.0 - np.clip((dist - 0.5) * 0.25, 0, 0.35)
+            for c in range(3):
+                img[:, :, c] = (img[:, :, c].astype(np.float32) * vignette).astype(np.uint8)
+                
+    return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+def warp_points(pts, matrix, amp, freq, phase):
+    """
+    Applies perspective transformation and non-linear wave deformation to polygon vertices.
+    """
+    pts_arr = np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
+    warped_persp = cv2.perspectiveTransform(pts_arr, matrix)
+    
+    final_pts = []
+    for pt in warped_persp:
+        x, y = pt[0]
+        dy = amp * np.sin(x * freq + phase) if amp > 0 else 0
+        final_pts.append([round(float(x), 1), round(float(y + dy), 1)])
+        
+    return final_pts
+
+def generate_single_page(args_tuple):
+    """
+    Worker function to generate a single labeled synthetic page.
+    """
+    idx, sentences, fonts, out_dir, prefix = args_tuple
+    
+    width = random.choice([800, 900, 1024])
+    height = random.choice([600, 750, 900])
+    
+    font_path = random.choice(fonts)
+    font_size = random.randint(18, 26)
+    font = get_cached_font(font_path, font_size)
+    
+    bg = apply_realistic_background(width, height)
+    draw = ImageDraw.Draw(bg)
+    
+    # Line spacing distribution:
+    # 50% Ultra-Tight (3..10px), 30% Medium-Tight (11..20px), 20% Standard (21..35px)
+    r_mode = random.random()
+    if r_mode < 0.50:
+        gap = random.randint(3, 10)
+    elif r_mode < 0.80:
+        gap = random.randint(11, 20)
+    else:
+        gap = random.randint(21, 35)
+        
+    y_spacing = font_size + gap
+    y_start = random.randint(30, 60)
+    
+    # Paragraph structure
+    num_paras = random.randint(1, 3)
+    lines_per_para = []
+    for _ in range(num_paras):
+        lines_per_para.append(random.randint(2, 6))
+        
+    line_boxes = []
+    current_y = y_start
+    sent_idx = random.randint(0, max(0, len(sentences) - 20))
+    
+    for para_i, num_l in enumerate(lines_per_para):
+        for line_i in range(num_l):
+            if current_y + font_size + 15 > height:
+                break
+                
+            text = sentences[sent_idx % len(sentences)]
+            sent_idx += 1
+            
+            # Paragraph formatting:
+            # - First line indented
+            # - Last line of paragraph may be shorter
+            is_first_line = (line_i == 0)
+            is_last_line = (line_i == num_l - 1)
+            
+            x_pos = random.randint(60, 90) if is_first_line else random.randint(30, 45)
+            
+            # Trim text if too long for width
+            while len(text) > 5:
+                try:
+                    tb = font.getbbox(text)
+                    tw = tb[2] - tb[0]
+                except Exception:
+                    tw = len(text) * int(font_size * 0.7)
+                if x_pos + tw < width - 40:
+                    break
+                parts = text.rsplit(' ', 1)
+                text = parts[0] if len(parts) > 1 else text[:-2]
+                
+            if is_last_line and random.random() < 0.6:
+                words = text.split()
+                if len(words) > 3:
+                    cut = random.randint(3, len(words) - 1)
+                    text = ' '.join(words[:cut])
+                    if not text.endswith(('꩞', '꩝')):
+                        text += random.choice(['꩞', '꩝'])
+                        
+            if not text.strip():
+                continue
+                
+            ink_r = random.randint(15, 50)
+            ink_g = random.randint(15, 45)
+            ink_b = random.randint(15, 45)
+            draw.text((x_pos, current_y), text, font=font, fill=(ink_r, ink_g, ink_b))
+            
+            try:
+                bbox = font.getbbox(text)
+                text_w = bbox[2] - bbox[0]
+                text_h = bbox[3] - bbox[1]
+            except Exception:
+                text_w = len(text) * int(font_size * 0.7)
+                text_h = font_size
+                
+            pad_x = random.randint(2, 4)
+            # When lines are ultra tight, pad_y must be tight to avoid overlapping labels
+            pad_y = 1 if gap <= 6 else random.randint(2, 3)
+            
+            box = [
+                [x_pos - pad_x, current_y - pad_y],
+                [x_pos + text_w + pad_x, current_y - pad_y],
+                [x_pos + text_w + pad_x, current_y + text_h + pad_y],
+                [x_pos - pad_x, current_y + text_h + pad_y]
+            ]
+            line_boxes.append((text, box))
+            current_y += y_spacing
+            
+        # Paragraph gap
+        current_y += random.randint(12, 24)
+        if current_y + font_size + 15 > height:
+            break
+            
+    if not line_boxes:
+        return None
+        
+    img_np = np.array(bg)
+    h, w = img_np.shape[:2]
+    
+    # Geometric transformations: mild perspective & wave
+    has_distortion = random.random() < 0.65
+    if has_distortion:
+        amp = random.uniform(1.5, 4.0)
+        freq = random.uniform(0.005, 0.010)
+        phase = random.uniform(0, 2 * np.pi)
+        
+        pts1 = np.float32([[0, 0], [w, 0], [0, h], [w, h]])
+        skew_amt = 0.02
+        pts2 = np.float32([
+            [random.uniform(0, w * skew_amt), random.uniform(0, h * skew_amt)],
+            [w - random.uniform(0, w * skew_amt), random.uniform(0, h * skew_amt)],
+            [random.uniform(0, w * skew_amt), h - random.uniform(0, h * skew_amt)],
+            [w - random.uniform(0, w * skew_amt), h - random.uniform(0, h * skew_amt)]
+        ])
+        matrix = cv2.getPerspectiveTransform(pts1, pts2)
+        
+        x_idx = np.arange(w)
+        y_idx = np.arange(h)
+        X, Y = np.meshgrid(x_idx, y_idx)
+        dy = amp * np.sin(X * freq + phase)
+        map_x = X.astype(np.float32)
+        map_y = (Y + dy).astype(np.float32)
+        img_wave = cv2.remap(img_np, map_x, map_y, cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
+        img_warped = cv2.warpPerspective(img_wave, matrix, (w, h), borderMode=cv2.BORDER_REPLICATE)
+        
+        warped_labels = []
+        for text, box in line_boxes:
+            w_box = warp_points(box, matrix, amp, freq, phase)
+            warped_labels.append({
+                "transcription": text,
+                "points": w_box
+            })
+    else:
+        img_warped = img_np
+        warped_labels = [{
+            "transcription": text,
+            "points": box
+        } for text, box in line_boxes]
+        
+    img_name = f"{prefix}_{idx:05d}.png"
+    img_path = os.path.join(out_dir, img_name)
+    Image.fromarray(img_warped).save(img_path)
+    
+    return f"{prefix}/{img_name}\t{json.dumps(warped_labels, ensure_ascii=False)}"
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate synthetic Cham Detection dataset V2")
+    parser.add_argument("--num_train", type=int, default=1000, help="Number of training pages")
+    parser.add_argument("--num_val", type=int, default=100, help="Number of validation pages")
+    parser.add_argument("--output_dir", type=str, default=None, help="Output directory")
+    parser.add_argument("--workers", type=int, default=4, help="Number of parallel worker processes")
+    args = parser.parse_args()
+
+    print(f"🚀 Cham Detection Generator V2 (Tight Line Hard-Cases)")
+    print(f"   - Target Train: {args.num_train} pages")
+    print(f"   - Target Val:   {args.num_val} pages")
+    print(f"   - Workers:      {args.workers}")
+    
+    corpus_candidates = [
+        os.path.join(PROJECT_ROOT, "data", "corpus", "cham_text.txt"),
+        os.path.join(PROJECT_ROOT, "ocr-training", "data", "corpus", "cham_text.txt"),
+        os.path.join(os.getcwd(), "data", "corpus", "cham_text.txt"),
+        os.path.join(os.getcwd(), "ocr-training", "data", "corpus", "cham_text.txt"),
+        os.path.join(PROJECT_ROOT, "output_v22", "paddleocr_cham_finetune", "data", "corpus", "cham_text.txt"),
+        os.path.join(PROJECT_ROOT, "data", "cham-ocr-v5-assets", "corpus", "corpus", "cham_text.txt")
+    ]
+    corpus_file = None
+    for cand in corpus_candidates:
+        if os.path.exists(cand):
+            corpus_file = cand
+            break
+
+    if not corpus_file:
+        print(f"📥 Chưa tìm thấy corpus cục bộ, đang tải cham_text.txt từ GitHub...")
+        corpus_file = os.path.join(PROJECT_ROOT, "data", "corpus", "cham_text.txt")
+        os.makedirs(os.path.dirname(corpus_file), exist_ok=True)
+        try:
+            import urllib.request
+            raw_url = "https://raw.githubusercontent.com/phucsd1/Cham-OCR/main/ocr-training/data/corpus/cham_text.txt"
+            urllib.request.urlretrieve(raw_url, corpus_file)
+            print(f"✅ Đã tải corpus thành công về: {corpus_file}")
+        except Exception as e:
+            print(f"⚠️ Không thể tải từ GitHub ({e}), tự động sinh corpus dự phòng...")
+            # Fallback Cham sentence generator
+            cham_consonants = list("ꨆꨇꨈꨉꨊꨋꨌꨍꨎꨏꨐꨑꨒꨓꨔꨕꨖꨗꨘꨙꨚꨛꨜꨝꨞꨟꨠꨡꨢꨣꨤꨥꨦꨧꨨꨀ")
+            cham_vowels = list("ꨩꨪꨫꨬꨭꨮꨯꨰꨱꨲꨴꨵ")
+            cham_finals = list("ꩀꩃꩌꩍꩆꩉꩊꩂꩅ")
+            synthetic_corpus = []
+            for _ in range(5000):
+                words = []
+                for _ in range(random.randint(4, 10)):
+                    syl = random.choice(cham_consonants)
+                    if random.random() < 0.3: syl += "ꨳ"
+                    if random.random() < 0.7: syl += random.choice(cham_vowels)
+                    if random.random() < 0.5: syl += random.choice(cham_finals)
+                    words.append(syl)
+                synthetic_corpus.append(" ".join(words) + random.choice([" ꩞", " ꩝"]))
+            with open(corpus_file, "w", encoding="utf-8") as f:
+                f.write("\n".join(synthetic_corpus) + "\n")
+            print(f"✅ Đã tạo {len(synthetic_corpus)} câu corpus dự phòng.")
+
+    with open(corpus_file, "r", encoding="utf-8") as f:
+        sentences = [line.strip() for line in f if line.strip() and not line.strip().startswith('#')]
+    print(f"   - Đã nạp {len(sentences)} dòng ngữ liệu Chăm ({corpus_file}).")
+    
+    fonts_dir = os.path.join(PROJECT_ROOT, "data", "fonts")
+    if not os.path.exists(fonts_dir):
+        fonts_dir = os.path.join(PROJECT_ROOT, "output_v22", "paddleocr_cham_finetune", "data", "fonts")
+        
+    font_names = ["NotoSansCham-Regular.ttf", "NotoSansCham-Bold.ttf", "NotoSansCham-Black.ttf"]
+    fonts = [os.path.join(fonts_dir, f) for f in font_names if os.path.exists(os.path.join(fonts_dir, f))]
+    if not fonts:
+        fonts = [os.path.join(fonts_dir, "NotoSansCham-Regular.ttf")]
+    print(f"   - Using fonts: {[os.path.basename(f) for f in fonts]}")
+    
+    det_root = args.output_dir or os.path.join(PROJECT_ROOT, "data", "detector_v2")
+    train_dir = os.path.join(det_root, "train_images")
+    val_dir = os.path.join(det_root, "val_images")
+    os.makedirs(train_dir, exist_ok=True)
+    os.makedirs(val_dir, exist_ok=True)
+    
+    # 1. Generate Training Data
+    print(f"\n⏳ Generating {args.num_train} training pages...")
+    train_tasks = [(i, sentences, fonts, train_dir, "train_images") for i in range(args.num_train)]
+    train_labels = []
+    
+    with ProcessPoolExecutor(max_workers=args.workers) as executor:
+        for res in executor.map(generate_single_page, train_tasks):
+            if res:
+                train_labels.append(res)
+                if len(train_labels) % 200 == 0:
+                    print(f"   ... Generated {len(train_labels)}/{args.num_train} training pages")
+                    
+    with open(os.path.join(det_root, "det_train_label.txt"), "w", encoding="utf-8", newline="\n") as f:
+        f.write("\n".join(train_labels) + "\n")
+    print(f"✅ Finished training data: {len(train_labels)} pages saved.")
+    
+    # 2. Generate Validation Data
+    print(f"\n⏳ Generating {args.num_val} validation pages...")
+    val_tasks = [(i, sentences, fonts, val_dir, "val_images") for i in range(args.num_val)]
+    val_labels = []
+    
+    with ProcessPoolExecutor(max_workers=args.workers) as executor:
+        for res in executor.map(generate_single_page, val_tasks):
+            if res:
+                val_labels.append(res)
+                if len(val_labels) % 50 == 0:
+                    print(f"   ... Generated {len(val_labels)}/{args.num_val} validation pages")
+                    
+    with open(os.path.join(det_root, "det_val_label.txt"), "w", encoding="utf-8", newline="\n") as f:
+        f.write("\n".join(val_labels) + "\n")
+    print(f"✅ Finished validation data: {len(val_labels)} pages saved.")
+    
+    print(f"\n🎉 Dataset successfully generated at: {det_root}")
+    print(f"   - Label format: PaddleOCR SimpleDataSet (points + transcription)")
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/get_live_log.py

@@ -0,0 +1,67 @@
+import os
+import sys
+import time
+import threading
+import queue
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+os.environ['KAGGLE_USERNAME'] = 'gustavnguyen'
+os.environ['KAGGLE_KEY'] = '6bf56db7e5c0fa7895d157167961d92b'
+
+from kaggle.api.kaggle_api_extended import KaggleApi
+
+def main():
+    api = KaggleApi()
+    api.authenticate()
+    
+    q = queue.Queue()
+    stop_event = threading.Event()
+    
+    def worker():
+        try:
+            for event in api.kernels_logs_stream('gustavnguyen/paddleocr-cham-finetune'):
+                if stop_event.is_set():
+                    break
+                data = event.get('data', '')
+                if data:
+                    q.put(data)
+        except Exception:
+            pass
+
+    t = threading.Thread(target=worker, daemon=True)
+    t.start()
+    
+    raw_text = []
+    # Thu thập tất cả log đã có (cho đến khi không còn event mới trong 3 giây)
+    t_start = time.time()
+    last_recv = time.time()
+    
+    while time.time() - t_start < 20:
+        try:
+            chunk = q.get(timeout=2.0)
+            raw_text.append(chunk)
+            last_recv = time.time()
+        except queue.Empty:
+            if raw_text and (time.time() - last_recv > 3.0):
+                # Đã đọc hết log hiện có
+                break
+                
+    stop_event.set()
+    
+    full_str = "".join(raw_text)
+    clean_lines = []
+    for line in full_str.splitlines():
+        l = line.strip()
+        if l and 'MB/s' not in l and 'â”' not in l and not l.startswith('\x1b['):
+            clean_lines.append(l)
+            
+    print(f"📊 Thu thập được {len(clean_lines)} dòng log từ Kaggle:")
+    print("="*70)
+    for l in clean_lines[-40:]:
+        print(l)
+    print("="*70)
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/kaggle_train_det.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Kaggle Training Automation for Cham Text Detection (Phase 4).
+Prepares and submits a multi-GPU (T4x2) PaddleOCR DBNet training job to Kaggle,
+strictly following the Cham-OCR project rules:
+- Kaggle user: "gustavnguyen"
+- Key: "6bf56db7e5c0fa7895d157167961d92b"
+- Accelerator: NvidiaTeslaT4
+- Distributed multi-GPU execution: paddle.distributed.launch --gpus '0,1'
+"""
+
+import os
+import sys
+import json
+import subprocess
+import shutil
+import tempfile
+
+# Force UTF-8 standard output for Windows console
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+# Force Kaggle credentials
+os.environ["KAGGLE_USERNAME"] = "gustavnguyen"
+os.environ["KAGGLE_KEY"] = "6bf56db7e5c0fa7895d157167961d92b"
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(PROJECT_ROOT, "scripts"))
+
+from kaggle_ops import get_authenticated_api, monitor_kernel, download_kernel_outputs
+
+def build_det_notebook():
+    """Generates the Jupyter Notebook for running Cham Detection training on Kaggle."""
+    nb = {
+        "cells": [
+            {
+                "cell_type": "markdown",
+                "metadata": {},
+                "source": [
+                    "# Cham OCR Text Detection Fine-Tuning (Phase 4 - DBNet PP-OCRv4)\n",
+                    "Automated training pipeline for Cham scene text & manuscript detection on Kaggle T4x2."
+                ]
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "metadata": {},
+                "outputs": [],
+                "source": [
+                    "# 1. Environment & Dependencies Setup\n",
+                    "!pip install --upgrade pip\n",
+                    "!pip install \"paddlepaddle-gpu>=2.6.0\" -i https://www.paddlepaddle.org.cn/packages/stable/cu118/\n",
+                    "!pip install imgaug pyclipper shapely lmdb attrdict\n",
+                    "\n",
+                    "import paddle\n",
+                    "print(f\"PaddlePaddle version: {paddle.__version__}\")\n",
+                    "print(f\"CUDA available: {paddle.is_compiled_with_cuda()}\")\n",
+                    "num_gpus = paddle.device.cuda.device_count()\n",
+                    "print(f\"GPU count: {num_gpus}\")\n"
+                ]
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "metadata": {},
+                "outputs": [],
+                "source": [
+                    "# 2. Clone PaddleOCR repository\n",
+                    "import os\n",
+                    "if not os.path.exists('PaddleOCR'):\n",
+                    "    !git clone -b release/2.7 https://github.com/PaddlePaddle/PaddleOCR.git\n",
+                    "\n",
+                    "%cd PaddleOCR\n",
+                    "!pip install -r requirements.txt\n"
+                ]
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "metadata": {},
+                "outputs": [],
+                "source": [
+                    "# 3. Prepare Cham Detection Dataset\n",
+                    "%cd /kaggle/working/PaddleOCR\n",
+                    "os.makedirs('data/detector', exist_ok=True)\n",
+                    "os.makedirs('data/fonts', exist_ok=True)\n",
+                    "os.makedirs('data/corpus', exist_ok=True)\n",
+                    "\n",
+                    "# Download Cham fonts\n",
+                    "!wget -q -O data/fonts/NotoSansCham-Regular.ttf https://raw.githubusercontent.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSansCham/NotoSansCham-Regular.ttf\n",
+                    "!wget -q -O data/fonts/NotoSansCham-Bold.ttf https://raw.githubusercontent.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSansCham/NotoSansCham-Bold.ttf\n",
+                    "\n",
+                    "print(\"Fonts downloaded successfully.\")\n"
+                ]
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "metadata": {},
+                "outputs": [],
+                "source": [
+                    "# 4. Adaptive Multi-GPU Training\n",
+                    "import paddle\n",
+                    "num_gpus = paddle.device.cuda.device_count()\n",
+                    "print(f\"Detected {num_gpus} GPUs for training.\")\n",
+                    "\n",
+                    "config_path = 'configs/det/ch_PP-OCRv4_det_cham.yml'\n",
+                    "\n",
+                    "# Download pre-trained DBNet weights\n",
+                    "!wget -q https://paddleocr.bj.bcebos.com/pretrained/PPLCNetV3_x0_75_ocr_det.pdparams -O ./pretrained_det.pdparams\n",
+                    "\n",
+                    "if num_gpus > 1:\n",
+                    "    gpus = ','.join(str(i) for i in range(num_gpus))\n",
+                    "    print(f\"Launching distributed training on GPUs {gpus}...\")\n",
+                    "    !python3 -m paddle.distributed.launch --gpus '{gpus}' tools/train.py -c {config_path} -o Global.pretrained_model=./pretrained_det.pdparams\n",
+                    "else:\n",
+                    "    print(\"Launching single GPU training...\")\n",
+                    "    !python3 tools/train.py -c {config_path} -o Global.pretrained_model=./pretrained_det.pdparams\n"
+                ]
+            },
+            {
+                "cell_type": "code",
+                "execution_count": None,
+                "metadata": {},
+                "outputs": [],
+                "source": [
+                    "# 5. Export Inference Model\n",
+                    "print(\"Exporting detection model to inference format...\")\n",
+                    "!python3 tools/export_model.py -c configs/det/ch_PP-OCRv4_det_cham.yml -o Global.checkpoints=./output/ch_PP-OCRv4_det_cham/latest Global.save_inference_dir=./output/det_cham_inference\n",
+                    "\n",
+                    "# Archive outputs\n",
+                    "!zip -r /kaggle/working/det_cham_inference.zip ./output/det_cham_inference\n",
+                    "print(\"Done! Checkpoint ready for download.\")\n"
+                ]
+            }
+        ],
+        "metadata": {
+            "kernelspec": {
+                "display_name": "Python 3",
+                "language": "python",
+                "name": "python3"
+            },
+            "language_info": {
+                "codemirror_mode": {"name": "ipython", "version": 3},
+                "file_extension": ".py",
+                "mimetype": "text/x-python",
+                "name": "python",
+                "nbformat": 4,
+                "nbformat_minor": 4
+            }
+        },
+        "nbformat": 4,
+        "nbformat_minor": 4
+    }
+    return nb
+
+def main():
+    print("🚀 Cham Text Detection - Kaggle Dispatcher (Phase 4)")
+    api = get_authenticated_api()
+    if not api:
+        print("❌ Cannot authenticate with Kaggle API.")
+        return
+
+    work_dir = os.path.join(PROJECT_ROOT, "output", "kaggle_det_submission")
+    os.makedirs(work_dir, exist_ok=True)
+
+    # 1. Write notebook
+    nb_path = os.path.join(work_dir, "kaggle_det_notebook.ipynb")
+    nb_data = build_det_notebook()
+    with open(nb_path, "w", encoding="utf-8") as f:
+        json.dump(nb_data, f, indent=2, ensure_ascii=False)
+    print(f"📝 Generated Kaggle notebook at: {nb_path}")
+
+    # 2. Write metadata
+    kernel_slug = "cham-ocr-v4-det-train"
+    meta = {
+        "id": f"gustavnguyen/{kernel_slug}",
+        "title": kernel_slug,
+        "code_file": "kaggle_det_notebook.ipynb",
+        "language": "python",
+        "kernel_type": "notebook",
+        "is_private": "true",
+        "enable_gpu": "true",
+        "enable_internet": "true",
+        "dataset_sources": [],
+        "competition_sources": [],
+        "kernel_sources": []
+    }
+    meta_path = os.path.join(work_dir, "kernel-metadata.json")
+    with open(meta_path, "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2)
+    print(f"📋 Generated kernel-metadata.json at: {meta_path}")
+
+    print("\n📦 To launch training on Kaggle:")
+    print(f"   kaggle kernels push -p \"{work_dir}\"")
+    print("\n⚙️  Configured GPU: NvidiaTeslaT4 (T4x2) with adaptive paddle.distributed.launch")
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/kaggle_watchdog_v24.py

@@ -0,0 +1,170 @@
+import os
+import sys
+import time
+import json
+import zipfile
+import socket
+import threading
+import queue
+from kaggle.api.kaggle_api_extended import KaggleApi
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+socket.setdefaulttimeout(60)
+
+def get_api():
+    os.environ["KAGGLE_USERNAME"] = "gustavnguyen"
+    os.environ["KAGGLE_KEY"] = "6bf56db7e5c0fa7895d157167961d92b"
+    api = KaggleApi()
+    api.authenticate()
+    return api
+
+def stream_logs_worker(api, kernel_id, log_file_path, stop_event):
+    """Lắng nghe luồng SSE log trực tiếp từ Kaggle và lưu file đồng thời phân tích sự kiện (tự động kết nối lại)"""
+    while not stop_event.is_set():
+        try:
+            with open(log_file_path, 'a', encoding='utf-8') as f_log:
+                for event in api.kernels_logs_stream(kernel_id):
+                    if stop_event.is_set():
+                        break
+                    data = event.get('data', '')
+                    if data:
+                        f_log.write(data)
+                        f_log.flush()
+                        # In các dòng quan trọng
+                        for line in data.splitlines():
+                            line_str = line.strip()
+                            if any(k in line_str for k in [
+                                'epoch: [', 'best metric', 'cur metric',
+                                'save best model', 'save model in',
+                                'Detected GPU Count', 'Place(gpu', 'train dataloader has',
+                                'Hoàn thành', 'HOÀN TẤT', 'Error', 'Exception'
+                            ]) and not 'MB/s' in line_str and not 'â”' in line_str:
+                                print(f"🔥 [KAGGLE LIVE] {line_str}")
+        except Exception:
+            pass
+        if not stop_event.is_set():
+            time.sleep(4)
+
+def run_watchdog(user="gustavnguyen", slug="paddleocr-cham-finetune", output_dir="ocr-training/output/v24", poll_interval=30):
+    kernel_id = f"{user}/{slug}"
+    print("="*80)
+    print(f"🛡️  ACTIVE WATCHDOG V24 - LIVE STREAM LOG TỪ KAGGLE DUAL T4x2")
+    print(f"🎯 Kernel: {kernel_id}")
+    print(f"⏱️  Cơ chế: SSE Live Stream + Heartbeat {poll_interval}s")
+    print("="*80)
+    
+    api = get_api()
+    os.makedirs(output_dir, exist_ok=True)
+    live_log_path = os.path.join(output_dir, "live_training.log")
+    
+    # Khởi chạy luồng SSE Live Stream
+    stop_stream_event = threading.Event()
+    stream_thread = threading.Thread(
+        target=stream_logs_worker,
+        args=(api, kernel_id, live_log_path, stop_stream_event),
+        daemon=True
+    )
+    stream_thread.start()
+    print(f"📡 Đã kết nối kênh Live Log SSE. Ghi nhật ký thời gian thực tại: {live_log_path}\n")
+    
+    start_time = time.time()
+    last_status = None
+    fail_count = 0
+    
+    while True:
+        try:
+            res = api.kernels_status(kernel_id)
+            if hasattr(res, 'status') and hasattr(res.status, 'name'):
+                status = res.status.name.lower()
+            elif hasattr(res, 'status'):
+                status = str(res.status).split('.')[-1].lower()
+            else:
+                status = 'unknown'
+                
+            elapsed_sec = int(time.time() - start_time)
+            elapsed_min = elapsed_sec // 60
+            
+            if status != last_status or elapsed_sec % 180 < poll_interval:
+                print(f"⏱️  [Heartbeat {elapsed_min:02d}m{elapsed_sec%60:02d}s] Trạng thái: {status.upper()}")
+                last_status = status
+                
+            # 1. THÀNH CÔNG
+            if 'complete' in status:
+                stop_stream_event.set()
+                print("\n" + "="*80)
+                print(f"🎉 KERNEL ĐÃ HOÀN TẤT THÀNH CÔNG TRONG {elapsed_min} PHÚT!")
+                print("📥 Bắt đầu tải và đồng bộ mô hình (rec_cham_v24_best.zip)...")
+                print("="*80)
+                
+                download_success = download_outputs(api, kernel_id, output_dir)
+                if download_success:
+                    print("✅ Tải và giải nén mô hình V24 hoàn tất!")
+                    return True
+                else:
+                    print("❌ Lỗi khi tải hoặc giải nén kết quả từ Kaggle.")
+                    return False
+                    
+            # 2. LỖI SỚM
+            elif any(k in status for k in ['error', 'cancel', 'abort', 'fail']):
+                stop_stream_event.set()
+                print("\n" + "!"*80)
+                print(f"🚨 BÁO ĐỘNG ĐỎ: KERNEL DỪNG VỚI TRẠNG THÁI LỖI: {status.upper()}!")
+                print(f"⏱️  Thời gian chạy: {elapsed_min} phút {elapsed_sec%60} giây.")
+                print("!"*80)
+                return False
+                
+            fail_count = 0
+            
+        except Exception as e:
+            fail_count += 1
+            if fail_count >= 5:
+                print(f"⚠️  Mất kết nối kiểm tra Kaggle API ({fail_count}/5): {e}")
+                
+        time.sleep(poll_interval)
+
+def download_outputs(api, kernel_id, output_dir):
+    try:
+        socket.setdefaulttimeout(600)
+        api.kernels_output(kernel_id, path=output_dir)
+        print("✅ Đã tải file output từ Kaggle.")
+        
+        zip_files = [f for f in os.listdir(output_dir) if f.endswith('.zip')]
+        if not zip_files:
+            print("❌ Không tìm thấy file .zip trong output!")
+            return False
+            
+        for zf in zip_files:
+            zp = os.path.join(output_dir, zf)
+            extract_folder = os.path.join(output_dir, zf.replace('.zip', ''))
+            os.makedirs(extract_folder, exist_ok=True)
+            print(f"📦 Đang giải nén {zf} ({os.path.getsize(zp) / (1024*1024):.2f} MB)...")
+            with zipfile.ZipFile(zp, 'r') as zref:
+                zref.extractall(extract_folder)
+            print(f"✅ Giải nén xong vào: {extract_folder}")
+            
+            infer_candidates = [
+                os.path.join(extract_folder, 'output', 'rec_cham_inference_v24'),
+                os.path.join(extract_folder, 'rec_cham_inference_v24'),
+                extract_folder
+            ]
+            for cand in infer_candidates:
+                if os.path.exists(os.path.join(cand, 'inference.pdmodel')) or os.path.exists(os.path.join(cand, 'model.pdmodel')):
+                    target_studio_dir = 'ocr-studio/data/output/rec_cham_inference_v24'
+                    os.makedirs(target_studio_dir, exist_ok=True)
+                    import shutil
+                    for item in os.listdir(cand):
+                        s_item = os.path.join(cand, item)
+                        d_item = os.path.join(target_studio_dir, item)
+                        if os.path.isfile(s_item):
+                            shutil.copy2(s_item, d_item)
+                    print(f"🚀 Đã đồng bộ mô hình inference V24 vào Studio: {target_studio_dir}")
+                    break
+        return True
+    except Exception as e:
+        print(f"❌ Lỗi giải nén: {e}")
+        return False
+
+if __name__ == '__main__':
+    run_watchdog()

ocr-training/scripts/launch_h100_full_pipeline.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+End-to-End Automated Pipeline for Cham-DBNet on Lightning AI (H100).
+1. Data Gen (2,000 pages ~40,000 lines on CPU)
+2. Switch to H100 GPU
+3. Install paddlepaddle-gpu & launch distributed training
+4. Stream and monitor training progress
+5. Export & package inference model
+6. Download locally and stop Studio
+"""
+
+import os
+import sys
+import time
+from lightning_sdk import Studio, Machine
+
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def log(msg):
+    timestamp = time.strftime("%H:%M:%S")
+    print(f"[{timestamp}] {msg}", flush=True)
+
+def main():
+    log("=================================================================")
+    log("🚀 KHỞI CHẠY PIPELINE HUẤN LUYỆN CHAM-DBNET TRÊN LIGHTNING AI H100")
+    log("=================================================================")
+
+    studio = Studio(name="cham-det-h100", teamspace="phucsd", org="phucsd-org")
+    log(f"Studio Status: {studio.status} | Machine: {studio.machine}")
+
+    # Step 1: Check existing dataset
+    dataset_exists = studio.run("test -f Cham-OCR/ocr-training/PaddleOCR/data/detector_v2/det_train_label.txt && echo EXISTS || echo NO").strip()
+    if "EXISTS" in dataset_exists:
+        log("✅ [BƯỚC 1/5] Bộ dữ liệu 2,000 trang (det_train_label.txt) đã có sẵn trên đĩa, bỏ qua bước sinh!")
+    else:
+        log("\n⚙️ [BƯỚC 1/5] Sinh 2,000 trang dữ liệu đặc trị dòng hẹp (50% gap 3-10px)...")
+        studio.run(
+            "pkill -9 -f generate_detector_data_v2.py || true",
+            "rm -rf Cham-OCR/ocr-training/PaddleOCR/data/detector_v2"
+        )
+        gen_cmd = "cd Cham-OCR/ocr-training && python3 scripts/generate_detector_data_v2.py --num_train 2000 --num_val 200 --output_dir PaddleOCR/data/detector_v2 --workers 4"
+        gen_out = studio.run(gen_cmd)
+        for line in gen_out.strip().splitlines()[-4:]:
+            log(f"   {line}")
+        log("✅ Bộ dữ liệu 2,000 trang đã sinh và tạo nhãn SimpleDataSet thành công!")
+
+    # Step 2: Switch to NVIDIA H100
+    log("\n🔥 [BƯỚC 2/5] Nâng cấp phần cứng sang NVIDIA H100 (80GB VRAM SXM5 - lit-h100-80gb-1)...")
+    studio.switch_machine("lit-h100-80gb-1")
+    log(f"✅ Đã chuyển sang H100! Machine: {studio.machine}")
+
+    # Step 3: Install PaddlePaddle GPU & Verify
+    log("\n📦 [BƯỚC 3/5] Cài đặt PaddlePaddle GPU bản CUDA 11.8/12.x tối ưu cho Hopper H100...")
+    studio.run("pip install -q paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/stable/cu118/")
+    gpu_check = studio.run("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader")
+    log(f"🔥 GPU H100 đã sẵn sàng: {gpu_check.strip()}")
+
+    # Step 4: Launch Training & Monitor
+    log("\n🚀 [BƯỚC 4/5] Khởi chạy huấn luyện Cham-DBNet (batch 64, 150 epochs)...")
+    train_cmd = "cd Cham-OCR/ocr-training/PaddleOCR && nohup python3 -m paddle.distributed.launch --gpus '0' tools/train.py -c configs/det/ch_PP-OCRv4_det_h100.yml > train.log 2>&1 &"
+    studio.run(train_cmd)
+    log("✅ Huấn luyện đã kích hoạt chạy ngầm (background) an toàn trên H100!")
+
+    log("\n📊 Bắt đầu theo dõi chỉ số loss và epoch liên tục...")
+    prev_log = ""
+    start_train_time = time.time()
+    
+    while True:
+        time.sleep(15)
+        # Check running process
+        ps_out = studio.run("ps aux | grep tools/train.py | grep -v grep | wc -l").strip()
+        is_running = int(ps_out or "0") > 0
+        
+        try:
+            log_tail = studio.run("cd Cham-OCR/ocr-training/PaddleOCR && tail -n 6 train.log").strip()
+            if log_tail and log_tail != prev_log:
+                prev_log = log_tail
+                log("--- TIẾN ĐỘ HUẤN LUYỆN MỚI NHẤT ---")
+                for l in log_tail.splitlines()[-4:]:
+                    log(f"   {l}")
+        except Exception as e:
+            log(f"Lưu ý: {e}")
+            
+        if not is_running:
+            elapsed = (time.time() - start_train_time) / 60
+            log(f"\n🎉 Tiến trình huấn luyện hoàn tất sau {elapsed:.1f} phút!")
+            break
+
+    # Step 5: Export, Zip, Download, and Stop
+    log("\n📦 [BƯỚC 5/5] Xuất mô hình Inference nhẹ ~4.5MB & đóng gói ZIP...")
+    export_cmd = """cd Cham-OCR/ocr-training/PaddleOCR && \
+BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/best_accuracy" && \
+if [ ! -f "${BEST_MODEL}.pdparams" ]; then BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/latest"; fi && \
+python3 tools/export_model.py -c configs/det/ch_PP-OCRv4_det_h100.yml -o Global.pretrained_model=${BEST_MODEL} Global.save_inference_dir=../output/ch_PP-OCRv4_det_cham_infer && \
+cd ../output && zip -r ../cham_dbnet_v1_infer.zip ch_PP-OCRv4_det_cham_infer/"""
+    studio.run(export_cmd)
+    log("✅ Đã xuất mô hình và đóng gói cham_dbnet_v1_infer.zip th��nh công!")
+
+    # Download to local
+    local_zip = os.path.join(os.getcwd(), "ocr-training", "cham_dbnet_v1_infer.zip")
+    log(f"⬇️ Đang tải tệp mô hình về máy local: {local_zip}...")
+    # Read remote zip in base64 and write locally to ensure 100% reliability
+    b64_zip = studio.run("cd Cham-OCR/ocr-training && python3 -c \"import base64, pathlib; print(base64.b64encode(pathlib.Path('cham_dbnet_v1_infer.zip').read_bytes()).decode('ascii'))\"").strip()
+    import base64
+    with open(local_zip, "wb") as f:
+        f.write(base64.b64decode(b64_zip))
+    log(f"🎉 ĐÃ TẢI VỀ THÀNH CÔNG: {local_zip} ({os.path.getsize(local_zip)/(1024*1024):.2f} MB)")
+
+    # STOP STUDIO IMMEDIATELY
+    log("\n🛑 Tự động dừng Studio để bảo vệ số dư credit...")
+    studio.stop()
+    log(f"✅ Studio đã DỪNG (Status: {studio.status})! 0 credit bị tiêu tốn thêm.")
+    log("=================================================================")
+    log("🎊 HOÀN THÀNH TOÀN DIỆN!")
+    log("=================================================================")
+
+if __name__ == "__main__":
+    main()

ocr-training/scripts/launch_l40s_pipeline.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+End-to-End Automated Pipeline for Cham-DBNet on Lightning AI (NVIDIA L40S 48GB).
+- Machine: g6e.4xlarge (NVIDIA L40S 48GB Ada Lovelace - 3.54 cr/h)
+- 2,000 training pages (det_train_label.txt) + 200 validation pages already prepared on disk.
+- 150 epochs, DBNet PP-OCRv4 Mobile, batch size 64.
+- Automatic monitoring, live loss streaming, model export, zip download, and guaranteed auto-stop.
+"""
+
+import os
+import sys
+import time
+import base64
+from lightning_sdk import Studio, Machine
+
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def log(msg):
+    timestamp = time.strftime("%H:%M:%S")
+    print(f"[{timestamp}] {msg}", flush=True)
+
+def main():
+    log("=================================================================")
+    log("🚀 KHỞI CHẠY PIPELINE HUẤN LUYỆN CHAM-DBNET TRÊN NVIDIA L40S 48GB")
+    log("=================================================================")
+
+    studio = Studio(name="cham-det-h100", teamspace="phucsd", org="phucsd-org")
+    log(f"Studio hiện tại: Status={studio.status} | Machine={studio.machine}")
+
+    try:
+        target_machine = Machine.L40S
+        log(f"\n🔥 [BƯỚC 1/5] Khởi động Studio với GPU NVIDIA L40S 48GB (Machine.L40S - 3.54 cr/h)...")
+        if str(studio.status).lower() != "running":
+            studio.start(machine=target_machine)
+        else:
+            if str(studio.machine) != str(target_machine):
+                log(f"Đang chuyển phần cứng từ {studio.machine} sang {target_machine}...")
+                studio.switch_machine(target_machine)
+        
+        log(f"✅ Studio đang chạy! Machine: {studio.machine} | Status: {studio.status}")
+
+        log("\n🔍 [BƯỚC 2/5] Kiểm tra GPU và môi trường CUDA...")
+        gpu_info = studio.run("nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader").strip()
+        log(f"🔥 GPU phát hiện: {gpu_info}")
+
+        log("📦 Cài đặt/Kiểm tra PaddlePaddle GPU tương thích CUDA & VisualDL & NumPy...")
+        paddle_check = studio.run("python3 -c \"import paddle; print('PADDLE_READY', paddle.__version__, paddle.device.cuda.device_count())\" || true").strip()
+        if "PADDLE_READY" not in paddle_check or " 0" in paddle_check:
+            log("Đang cài đặt paddlepaddle-gpu cu118...")
+            studio.run("pip install -q paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/stable/cu118/")
+            paddle_check = studio.run("python3 -c \"import paddle; print('PADDLE_READY', paddle.__version__, paddle.device.cuda.device_count())\"").strip()
+        log(f"✅ PaddlePaddle Status: {paddle_check}")
+
+        log("📦 Cập nhật OpenCV, SciPy, RapidFuzz, VisualDL tương thích hoàn toàn NumPy 2.x...")
+        studio.run("python3 -m pip install -q --upgrade 'opencv-python>=4.10' 'opencv-python-headless>=4.10' 'scipy>=1.13' rapidfuzz visualdl pyclipper shapely lmdb attrdict")
+
+        log("🔧 Áp dụng Monkeypatch NumPy 2.x toàn diện qua sitecustomize và tools/...")
+        sitecust_cmd = """python3 -c "
+import site, pathlib
+patch = '''import numpy as np
+if not hasattr(np, 'sctypes'): np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64], 'uint': [np.uint8, np.uint16, np.uint32, np.uint64], 'float': [np.float16, np.float32, np.float64], 'complex': [np.complex64, np.complex128], 'others': [bool, object, bytes, str]}
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+if not hasattr(np, 'long'): np.long = int
+if not hasattr(np, 'ulong'): np.ulong = int
+if not hasattr(np, 'unicode_'): np.unicode_ = str
+if not hasattr(np, 'string_'): np.string_ = bytes
+if not hasattr(np, 'object_'): np.object_ = object
+if not hasattr(np, 'complex_'): np.complex_ = complex
+'''
+sp_list = site.getsitepackages()
+for sp in sp_list:
+    try:
+        (pathlib.Path(sp) / 'sitecustomize.py').write_text(patch, encoding='utf-8')
+        print(f'Wrote sitecustomize.py to {sp}')
+    except Exception as e:
+        pass
+" """
+        sitecust_out = studio.run(sitecust_cmd).strip()
+        if sitecust_out:
+            log(f"   {sitecust_out}")
+
+        studio.run("cd Cham-OCR/ocr-training/PaddleOCR && git checkout tools/train.py tools/export_model.py 2>/dev/null || true")
+        patch_cmd = """python3 -c "
+import pathlib
+for fn in ['Cham-OCR/ocr-training/PaddleOCR/tools/train.py', 'Cham-OCR/ocr-training/PaddleOCR/tools/export_model.py']:
+    p = pathlib.Path(fn)
+    if p.exists():
+        txt = p.read_text(encoding='utf-8')
+        patch = '''import numpy as np
+if not hasattr(np, 'sctypes'): np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64], 'uint': [np.uint8, np.uint16, np.uint32, np.uint64], 'float': [np.float16, np.float32, np.float64], 'complex': [np.complex64, np.complex128], 'others': [bool, object, bytes, str]}
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+if not hasattr(np, 'long'): np.long = int
+if not hasattr(np, 'ulong'): np.ulong = int
+if not hasattr(np, 'unicode_'): np.unicode_ = str
+if not hasattr(np, 'string_'): np.string_ = bytes
+if not hasattr(np, 'object_'): np.object_ = object
+if not hasattr(np, 'complex_'): np.complex_ = complex
+'''
+        if 'np.sctypes' not in txt:
+            lines = txt.splitlines(keepends=True)
+            insert_idx = 0
+            for idx, line in enumerate(lines):
+                if line.strip().startswith('from __future__'):
+                    insert_idx = idx + 1
+            lines.insert(insert_idx, patch + '\\n')
+            p.write_text(''.join(lines), encoding='utf-8')
+            print(f'Đã patch toàn diện sau __future__: {fn}')
+" """
+        patch_out = studio.run(patch_cmd).strip()
+        if patch_out:
+            log(f"   {patch_out}")
+
+        # Patch random_crop_data.py để tương thích hoàn toàn NumPy 2.x
+        crop_patch_cmd = """python3 -c "
+import pathlib
+p = pathlib.Path('Cham-OCR/ocr-training/PaddleOCR/ppocr/data/imaug/random_crop_data.py')
+if p.exists():
+    txt = p.read_text(encoding='utf-8')
+    if 'size=1' in txt:
+        txt = txt.replace('xx = int(np.random.choice(axis, size=1))', 'xx = int(np.random.choice(axis))')
+        p.write_text(txt, encoding='utf-8')
+        print('Đã vá thành công random_crop_data.py (loại bỏ size=1 cho NumPy 2.x)')
+    else:
+        print('random_crop_data.py đã được vá')
+" """
+        crop_patch_out = studio.run(crop_patch_cmd).strip()
+        if crop_patch_out:
+            log(f"   {crop_patch_out}")
+
+        log("🔍 Kiểm tra tính tương thích của toàn bộ thư viện...")
+        verify_cmd = """python3 -c "
+import numpy as np
+if not hasattr(np, 'sctypes'): np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64], 'uint': [np.uint8, np.uint16, np.uint32, np.uint64], 'float': [np.float16, np.float32, np.float64], 'complex': [np.complex64, np.complex128], 'others': [bool, object, bytes, str]}
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+if not hasattr(np, 'long'): np.long = int
+if not hasattr(np, 'ulong'): np.ulong = int
+import cv2, imgaug, paddle
+print('VERIFY_SUCCESS: numpy', np.__version__, 'cv2', cv2.__version__, 'paddle', paddle.__version__)
+" """
+        verify_check = studio.run(verify_cmd).strip()
+        log(f"   {verify_check}")
+
+        log("\n📂 [BƯỚC 3/5] Xác minh dữ liệu huấn luyện detector_v2...")
+        data_stat = studio.run("wc -l Cham-OCR/ocr-training/PaddleOCR/data/detector_v2/det_train_label.txt Cham-OCR/ocr-training/PaddleOCR/data/detector_v2/det_val_label.txt 2>/dev/null || echo NOT_FOUND").strip()
+        log(f"Số dòng dữ liệu:\n{data_stat}")
+        if "NOT_FOUND" in data_stat:
+            raise RuntimeError("Không tìm thấy bộ dữ liệu det_train_label.txt trên đĩa Studio!")
+
+        sample_img_check = studio.run("python3 -c \"import pathlib, json; p = pathlib.Path('Cham-OCR/ocr-training/PaddleOCR/data/detector_v2/det_train_label.txt'); line = p.read_text(encoding='utf-8').splitlines()[0]; img_rel = line.split('\\t')[0]; img_path = pathlib.Path('Cham-OCR/ocr-training/PaddleOCR/data/detector_v2') / img_rel; print('IMG_SAMPLE_CHECK:', img_rel, img_path.exists())\"").strip()
+        log(f"   {sample_img_check}")
+
+        # Tạo thư mục output nếu chưa có
+        studio.run("mkdir -p Cham-OCR/ocr-training/output")
+
+        log("Đồng bộ tệp cấu hình ch_PP-OCRv4_det_h100.yml từ local vào PaddleOCR/configs/det/...")
+        local_cfg_path = os.path.join(os.getcwd(), "ocr-training", "configs", "det", "ch_PP-OCRv4_det_h100.yml")
+        with open(local_cfg_path, "r", encoding="utf-8") as f:
+            cfg_content = f.read()
+
+        sync_cmd = f"""python3 -c "
+import pathlib
+content = {repr(cfg_content)}
+pathlib.Path('Cham-OCR/ocr-training/PaddleOCR/configs/det/ch_PP-OCRv4_det_h100.yml').write_text(content, encoding='utf-8')
+pathlib.Path('Cham-OCR/ocr-training/configs/det/ch_PP-OCRv4_det_h100.yml').write_text(content, encoding='utf-8')
+print('CONFIG_SYNCED_SUCCESSFULLY')
+" """
+        sync_res = studio.run(sync_cmd).strip()
+        log(f"   {sync_res}")
+
+        log("\n🚀 [BƯỚC 4/5] Khởi chạy huấn luyện Cham-DBNet (150 epochs, batch 64)...")
+        studio.run("pkill -9 -f tools/train.py || true")
+        studio.run("cd Cham-OCR/ocr-training/PaddleOCR && rm -f train.log && rm -rf output/ch_PP-OCRv4_det_cham_h100")
+        time.sleep(2)
+
+        launch_cmd = (
+            "cd Cham-OCR/ocr-training/PaddleOCR && "
+            "nohup python3 -m paddle.distributed.launch --gpus '0' tools/train.py -c configs/det/ch_PP-OCRv4_det_h100.yml > train.log 2>&1 &"
+        )
+        studio.run(launch_cmd)
+        log("✅ Tiến trình huấn luyện đã kích hoạt chạy nền! Đang bắt đầu theo dõi tiến độ...")
+
+        start_time = time.time()
+        prev_log = ""
+
+        while True:
+            time.sleep(15)
+            ps_cnt = studio.run("ps aux | grep tools/train.py | grep -v grep | wc -l").strip()
+            is_alive = int(ps_cnt or "0") > 0
+
+            try:
+                latest_lines = studio.run("cd Cham-OCR/ocr-training/PaddleOCR && tail -n 8 train.log 2>/dev/null").strip()
+                if latest_lines and latest_lines != prev_log:
+                    prev_log = latest_lines
+                    elapsed_min = (time.time() - start_time) / 60
+                    log(f"⏱️ [{elapsed_min:.1f}m] Tiến độ log:")
+                    matched = False
+                    for l in latest_lines.splitlines():
+                        if any(k in l for k in ["epoch:", "loss:", "hmean:", "save checkpoint", "Error", "Traceback", "MainIndicator", "epoch: [", "step:"]):
+                            log(f"   {l}")
+                            matched = True
+                    if not matched and latest_lines.strip():
+                        log(f"   {latest_lines.splitlines()[-1]}")
+            except Exception as e:
+                log(f"Log fetch notice: {e}")
+
+            if not is_alive:
+                final_log = studio.run("cd Cham-OCR/ocr-training/PaddleOCR && tail -n 40 train.log 2>/dev/null").strip()
+                log(f"--- 40 DÒNG LOG CUỐI CÙNG ---\n{final_log}\n-----------------------------")
+                
+                # Kiểm tra xem có lỗi ngoại lệ khiến tiến trình dừng đột ngột không
+                if "Traceback (most recent call last)" in final_log or "Exit code 1" in final_log or "SystemError:" in final_log:
+                    raise RuntimeError("Tiến trình huấn luyện gặp lỗi ngoại lệ dừng đột ngột!")
+
+                chk_check = studio.run("test -f Cham-OCR/ocr-training/PaddleOCR/output/ch_PP-OCRv4_det_cham_h100/latest.pdparams && echo CHK_FOUND || echo NO_CHK").strip()
+                if "CHK_FOUND" not in chk_check:
+                    raise RuntimeError("Huấn luyện dừng bất thường trước khi lưu được checkpoint!")
+                
+                log("\n🎉 Tiến trình huấn luyện đã kết thúc thành công!")
+                break
+
+        log("\n📦 [BƯỚC 5/5] Xuất mô hình Inference & Tải về máy local...")
+        export_script = """
+cd Cham-OCR/ocr-training/PaddleOCR
+BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/best_accuracy"
+if [ ! -f "${BEST_MODEL}.pdparams" ]; then
+    BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/latest"
+fi
+echo "Using checkpoint: $BEST_MODEL"
+mkdir -p ../output
+python3 tools/export_model.py \
+    -c configs/det/ch_PP-OCRv4_det_h100.yml \
+    -o Global.pretrained_model=${BEST_MODEL} \
+       Global.save_inference_dir=../output/ch_PP-OCRv4_det_cham_infer
+
+cd ../output
+python3 -c "import shutil; shutil.make_archive('../cham_dbnet_v1_infer', 'zip', '.', 'ch_PP-OCRv4_det_cham_infer')"
+ls -lh ../cham_dbnet_v1_infer.zip
+"""
+        export_out = studio.run(export_script).strip()
+        log(f"Export log:\n{export_out}")
+
+        log("⬇️ Đang tải tệp cham_dbnet_v1_infer.zip về thư mục ocr-training/ ...")
+        local_dest = os.path.join(os.getcwd(), "ocr-training", "cham_dbnet_v1_infer.zip")
+        downloaded = False
+        try:
+            studio.download_file("Cham-OCR/ocr-training/cham_dbnet_v1_infer.zip", local_dest)
+            if os.path.exists(local_dest) and os.path.getsize(local_dest) > 1000:
+                downloaded = True
+                log("   Đã tải thành công qua native studio.download_file!")
+        except Exception as dl_err:
+            log(f"   Native download gặp lỗi ({dl_err}), chuyển sang Base64 fallback...")
+
+        if not downloaded:
+            remote_b64 = studio.run(
+                "python3 -c \"import base64, pathlib; p = pathlib.Path('Cham-OCR/ocr-training/cham_dbnet_v1_infer.zip'); print(base64.b64encode(p.read_bytes()).decode('ascii'))\""
+            ).strip()
+            with open(local_dest, "wb") as f:
+                f.write(base64.b64decode(remote_b64))
+
+        local_size_mb = os.path.getsize(local_dest) / (1024 * 1024)
+        log(f"🎉 ĐÃ TẢI THÀNH CÔNG: {local_dest} ({local_size_mb:.2f} MB)")
+
+        # Tự động giải nén model vào ocr-training/cham_dbnet_v1_infer
+        import zipfile
+        infer_extract_dir = os.path.join(os.getcwd(), "ocr-training", "cham_dbnet_v1_infer")
+        os.makedirs(infer_extract_dir, exist_ok=True)
+        with zipfile.ZipFile(local_dest, "r") as zf:
+            zf.extractall(infer_extract_dir)
+        log(f"📂 Đã giải nén mô hình suy luận vào: {infer_extract_dir}")
+
+    except Exception as exc:
+        log(f"❌ XẢY RA LỖI: {exc}")
+        raise exc
+
+    finally:
+        log("\n🛑 [AN TOÀN] Đang dừng Studio để bảo vệ số dư tài khoản...")
+        try:
+            if str(studio.status).lower() == "running":
+                studio.stop()
+                log(f"✅ Studio đã DỪNG (Status: {studio.status})! 0 credit bị tiêu tốn thêm.")
+            else:
+                log(f"✅ Studio hiện tại đã ở trạng thái {studio.status}, an toàn.")
+        except Exception as stop_err:
+            log(f"Cảnh báo khi dừng Studio: {stop_err}")
+
+    log("\n🎊 TOÀN BỘ QUY TRÌNH ĐÃ HOÀN TẤT THÀNH CÔNG RỰC RỠ!")
+
+if __name__ == "__main__":
+    main()

ocr-training/scripts/prepare_v24_notebook.py

@@ -0,0 +1,276 @@
+import os
+import sys
+import json
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+def read_file(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+def main():
+    print("📦 Bắt đầu đóng gói Kaggle Notebook huấn luyện V24...")
+    
+    # 1. Đọc mã nguồn các script cục bộ
+    dict_extension_code = read_file('ocr-training/scripts/dict_extension_v24.py')
+    weight_surgery_code = read_file('ocr-training/scripts/weight_surgery_v24.py')
+    generate_data_v24_code = read_file('ocr-training/scripts/generate_data_v24.py')
+    config_v24_code = read_file('ocr-training/configs/rec_cham_v24.yml')
+    
+    kaggle_dict_extension = dict_extension_code
+    kaggle_weight_surgery = weight_surgery_code
+    
+    cells = []
+    
+    def add_md(text):
+        cells.append({
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [line + '\n' for line in text.splitlines()]
+        })
+        
+    def add_code(code_str):
+        cells.append({
+            "cell_type": "code",
+            "execution_count": None,
+            "metadata": {},
+            "outputs": [],
+            "source": [line + '\n' for line in code_str.splitlines()]
+        })
+
+    # Tiêu đề
+    add_md("""# Huấn Luyện Mô Hình Nhận Diện Chữ Chăm PP-OCRv4 V24 (Dual GPU T4x2)
+Mô hình giải quyết triệt để:
+- Số thứ tự khổ thơ Chăm 1-99 (`꩑꩞` - `꩙꩙꩞`)
+- Dấu kết thúc câu kép Double Danda (`꩝꩝`)
+- Dấu phụ đối kháng `ꨲ` (Au, U+AA32) vs `ꨶ` (O, U+AA36)
+- Tổ hợp 3 tầng dấu phụ và bảo toàn nguyên âm trước `ꨯ`, `ꨯꨱ`
+- Khả năng chống chịu Mờ rung (Motion Blur) và Nhiễu giấy cổ""")
+
+    # Phase 1: Environment & GPU Check
+    add_md("## Phase 1: Cài đặt thư viện & Kiểm tra GPU T4x2")
+    add_code("""# 1. Cài đặt PaddlePaddle GPU và các thư viện phụ trợ
+!pip install --quiet "paddlepaddle-gpu>=2.6.0" "albumentations>=1.4.0" fonttools pyyaml opencv-python Pillow
+
+# 2. Kiểm tra môi trường GPU
+import os
+import sys
+import paddle
+
+print("="*60)
+print("PADDLE ENVIRONMENT STATUS:")
+print("Paddle Version:", paddle.__version__)
+print("Compiled with CUDA:", paddle.is_compiled_with_cuda())
+gpu_count = paddle.device.cuda.device_count()
+print(f"Detected GPU Count: {gpu_count}")
+print("="*60)
+
+if gpu_count < 1:
+    print("⚠️ CẢNH BÁO: Không tìm thấy GPU! Vui lòng chọn Accelerator = GPU T4 x2 trong Settings.")
+else:
+    for i in range(gpu_count):
+        print(f" - GPU {i}: {paddle.device.cuda.get_device_name(i)}")
+""")
+
+    # Phase 2: Setup Workspace & PaddleOCR
+    add_md("## Phase 2: Khởi tạo thư mục làm việc & Clone PaddleOCR")
+    add_code("""import os
+import shutil
+
+os.makedirs('/kaggle/working/data/fonts', exist_ok=True)
+os.makedirs('/kaggle/working/data/output_v24_temp', exist_ok=True)
+os.makedirs('/kaggle/working/configs', exist_ok=True)
+os.makedirs('/kaggle/working/scripts', exist_ok=True)
+os.makedirs('/kaggle/working/output/rec_cham_v24', exist_ok=True)
+os.makedirs('/kaggle/working/output/v24_training', exist_ok=True)
+
+# Tự động phát hiện đường dẫn Assets Input trên Kaggle
+candidate_asset_dirs = [
+    "/kaggle/input/cham-ocr-v5-assets",
+    "/kaggle/input/datasets/gustavnguyen/cham-ocr-v5-assets"
+]
+ASSETS_DIR = None
+for d in candidate_asset_dirs:
+    if os.path.exists(d):
+        ASSETS_DIR = d
+        break
+
+if not ASSETS_DIR and os.path.exists('/kaggle/input'):
+    for root, dirs, files in os.walk('/kaggle/input'):
+        if 'v23_checkpoint' in dirs:
+            ASSETS_DIR = root
+            break
+
+if not ASSETS_DIR:
+    raise FileNotFoundError(f"❌ LỖI: Không tìm thấy thư mục Assets trong /kaggle/input")
+
+print(f"✅ Đã tìm thấy Assets Input tại: {ASSETS_DIR}")
+
+# Copy fonts
+fonts_src = os.path.join(ASSETS_DIR, "fonts", "fonts")
+if not os.path.exists(fonts_src):
+    fonts_src = os.path.join(ASSETS_DIR, "fonts")
+
+for f in os.listdir(fonts_src):
+    if f.endswith(('.ttf', '.otf')):
+        shutil.copy2(os.path.join(fonts_src, f), os.path.join('/kaggle/working/data/fonts', f))
+
+print("✅ Đã sao chép fonts:", os.listdir('/kaggle/working/data/fonts'))
+
+# Clone PaddleOCR nếu chưa có
+if not os.path.exists('/kaggle/working/PaddleOCR'):
+    print("⏳ Đang clone PaddleOCR...")
+    !git clone --depth 1 https://github.com/PaddlePaddle/PaddleOCR.git /kaggle/working/PaddleOCR
+    !pip install --quiet -r /kaggle/working/PaddleOCR/requirements.txt
+else:
+    print("✅ PaddleOCR đã tồn tại sẵn.")
+""")
+
+    # Phase 3: Ghi mã nguồn các script
+    add_md("## Phase 3: Nạp kịch bản Sinh dữ liệu, Mở rộng từ điển & Phẫu thuật trọng số")
+    add_code(f"%%writefile /kaggle/working/scripts/dict_extension_v24.py\n{kaggle_dict_extension}")
+    add_code(f"%%writefile /kaggle/working/scripts/weight_surgery_v24.py\n{kaggle_weight_surgery}")
+    add_code(f"%%writefile /kaggle/working/scripts/generate_data_v24.py\n{generate_data_v24_code}")
+    add_code(f"%%writefile /kaggle/working/configs/rec_cham_v24.yml\n{config_v24_code}")
+
+    # Phase 4: Chạy chuẩn bị dữ liệu và phẫu thuật trọng số
+    add_md("## Phase 4: Mở rộng từ điển, Phẫu thuật trọng số & Sinh 50K dữ liệu V24 đặc trị")
+    add_code("""import os, sys, time
+%cd /kaggle/working
+
+print("=== BƯỚC 1: MỞ RỘNG TỪ ĐIỂN V24 ===")
+!python3 scripts/dict_extension_v24.py
+
+print("\\n=== BƯỚC 2: PHẪU THUẬT TRỌNG SỐ V24 ===")
+!python3 scripts/weight_surgery_v24.py
+
+print("\\n=== BƯỚC 3: SINH DỮ LIỆU TỔNG HỢP V24 ĐẶC TRỊ (45K TRAIN, 4.5K VAL) ===")
+t_start = time.time()
+# Chạy với 4 vCPU
+!python3 scripts/generate_data_v24.py --output-dir /kaggle/working/data/cham_synthetic_v24 --fonts-dir /kaggle/working/data/fonts --num-train 45000 --num-val 4500 --num-workers 4
+print(f"🎉 Hoàn thành toàn bộ dữ liệu trong {(time.time()-t_start)/60:.2f} phút!")
+""")
+
+    # Phase 5: Khởi chạy huấn luyện song song phân tán trên GPU T4x2
+    add_md("## Phase 5: Huấn luyện phân tán song song trên Dual GPU Tesla T4x2 (20 Epochs)")
+    add_code("""import os
+import paddle
+
+gpu_count = paddle.device.cuda.device_count()
+print(f"🔥 Khởi chạy huấn luyện với {gpu_count} GPU...")
+
+os.environ["PYTHONUNBUFFERED"] = "1"
+os.environ["FLAGS_fraction_of_gpu_memory_to_use"] = "0.90"
+
+%cd /kaggle/working/PaddleOCR
+
+if gpu_count > 1:
+    print("🚀 Sử dụng lệnh phân tán song song đa GPU (paddle.distributed.launch --gpus '0,1'):")
+    !python3 -m paddle.distributed.launch --gpus '0,1' tools/train.py -c /kaggle/working/configs/rec_cham_v24.yml
+else:
+    print("⚡ Huấn luyện trên Single GPU:")
+    !python3 tools/train.py -c /kaggle/working/configs/rec_cham_v24.yml
+""")
+
+    # Phase 6: Xuất mô hình Inference & Đóng gói ZIP
+    add_md("## Phase 6: Xuất mô hình Inference & Đóng gói rec_cham_v24_best.zip")
+    add_code("""import os
+import shutil
+import zipfile
+
+%cd /kaggle/working/PaddleOCR
+
+best_ckpt = "/kaggle/working/output/rec_cham_v24/best_accuracy"
+latest_ckpt = "/kaggle/working/output/rec_cham_v24/latest"
+
+target_ckpt = best_ckpt if os.path.exists(best_ckpt + ".pdparams") else latest_ckpt
+print(f"🎯 Sử dụng checkpoint: {target_ckpt}")
+
+infer_dir = "/kaggle/working/output/rec_cham_inference_v24"
+os.makedirs(infer_dir, exist_ok=True)
+
+# Xuất mô hình inference
+!python3 tools/export_model.py -c /kaggle/working/configs/rec_cham_v24.yml -o Global.pretrained_model={target_ckpt} Global.save_inference_dir={infer_dir} Global.export_with_pir=False
+
+# Copy từ điển vào thư mục inference
+shutil.copy2('/kaggle/working/data/cham_dict_v24.txt', os.path.join(infer_dir, 'cham_dict_v24.txt'))
+
+print("✅ Thư mục Inference:", os.listdir(infer_dir))
+
+# Đóng gói toàn bộ kết quả thành file zip trong /kaggle/working
+zip_path = "/kaggle/working/rec_cham_v24_best.zip"
+print(f"📦 Đang nén kết quả vào {zip_path}...")
+
+with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+    # Nén inference model
+    for root, dirs, files in os.walk(infer_dir):
+        for f in files:
+            full_p = os.path.join(root, f)
+            rel_p = os.path.relpath(full_p, "/kaggle/working")
+            zipf.write(full_p, rel_p)
+            
+    # Nén best accuracy pdparams
+    for ext in [".pdparams", ".pdopt", ".states"]:
+        p = target_ckpt + ext
+        if os.path.exists(p):
+            zipf.write(p, os.path.join("best_checkpoint", os.path.basename(p)))
+            
+    # Nén từ điển
+    zipf.write('/kaggle/working/data/cham_dict_v24.txt', 'cham_dict_v24.txt')
+
+print(f"🎉 HOÀN TẤT TRỌN GÓI! File zip sẵn sàng ({os.path.getsize(zip_path) / (1024*1024):.2f} MB): {zip_path}")
+""")
+
+    # 5. Lưu Notebook JSON
+    notebook_dict = {
+        "cells": cells,
+        "metadata": {
+            "kernelspec": {
+                "display_name": "Python 3",
+                "language": "python",
+                "name": "python3"
+            },
+            "language_info": {
+                "name": "python",
+                "version": "3.10.12"
+            }
+        },
+        "nbformat": 4,
+        "nbformat_minor": 4
+    }
+    
+    submission_dir = 'ocr-training/output/kaggle_v24_submission'
+    os.makedirs(submission_dir, exist_ok=True)
+    
+    nb_path = os.path.join(submission_dir, 'paddleocr_cham_v24_train.ipynb')
+    with open(nb_path, 'w', encoding='utf-8') as f:
+        json.dump(notebook_dict, f, indent=1, ensure_ascii=False)
+        
+    meta_path = os.path.join(submission_dir, 'kernel-metadata.json')
+    metadata = {
+        "id": "gustavnguyen/paddleocr-cham-finetune",
+        "title": "paddleocr-cham-finetune",
+        "code_file": "paddleocr_cham_v24_train.ipynb",
+        "language": "python",
+        "kernel_type": "notebook",
+        "is_private": "true",
+        "enable_gpu": "true",
+        "enable_tpu": "false",
+        "enable_internet": "true",
+        "dataset_sources": [
+            "gustavnguyen/cham-ocr-v5-assets"
+        ],
+        "competition_sources": [],
+        "kernel_sources": [],
+        "model_sources": []
+    }
+    with open(meta_path, 'w', encoding='utf-8') as f:
+        json.dump(metadata, f, indent=2)
+        
+    print(f"✅ Đã tạo thành công Notebook tại: {nb_path}")
+    print(f"✅ Đã tạo kernel-metadata tại: {meta_path}")
+    return nb_path, meta_path
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/run_l4_interactive.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+End-to-End Optimized Pipeline on NVIDIA L4 (1.68 cr/h - g6.4xlarge).
+- Cost: 1.68 cr/h (53% cheaper than AWS L40S, cheaper than Nebius 2.14 cr/h)
+- In-Place Interactive Pre-Flight Verification:
+    1. Train DataLoader (2 batches)
+    2. Eval DataLoader (5 batches, batch_size=1)
+    3. Forward pass + DBPostProcess + DetMetric
+- Only launches 150 epochs training after 100% Pre-flight test passed.
+- Model export + local download + guaranteed auto-stop when complete.
+"""
+
+import os
+import sys
+import time
+import base64
+import zipfile
+from lightning_sdk import Studio, Machine
+
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def log(msg):
+    timestamp = time.strftime("%H:%M:%S")
+    print(f"[{timestamp}] {msg}", flush=True)
+
+def main():
+    log("=================================================================")
+    log("🚀 OPTION A: KHỞI CHẠY PIPELINE TRÊN NVIDIA L4 (1.68 cr/h - 24GB)")
+    log("=================================================================")
+
+    studio = Studio(name="cham-det-h100", teamspace="phucsd", org="phucsd-org")
+    log(f"Studio hiện tại: Status={studio.status} | Machine={studio.machine}")
+
+    target_machine = Machine.L4
+    log(f"\n🔥 [BƯỚC 1/6] Khởi động Studio với NVIDIA L4 (Machine.L4 - 1.68 cr/h)...")
+    if str(studio.status).lower() != "running":
+        studio.start(machine=target_machine)
+    else:
+        if str(studio.machine) != str(target_machine):
+            log(f"Chuyển máy từ {studio.machine} sang {target_machine}...")
+            studio.switch_machine(target_machine)
+
+    log(f"✅ Studio đang chạy! Machine: {studio.machine} | Status: {studio.status}")
+
+    # Giai đoạn Pre-flight: GIỮ MÁY MỞ nếu có lỗi để sửa ngay tại chỗ
+    log("\n🔍 [BƯỚC 2/6] Kiểm tra phần cứng GPU L4...")
+    gpu_info = studio.run("nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader").strip()
+    log(f"🔥 GPU: {gpu_info}")
+
+    log("📦 Kiểm tra PaddlePaddle GPU 3.3.1...")
+    paddle_check = studio.run("python3 -c \"import paddle; print('PADDLE_READY', paddle.__version__, paddle.device.cuda.device_count())\" || true").strip()
+    if "PADDLE_READY" not in paddle_check or " 0" in paddle_check:
+        log("Cài đặt paddlepaddle-gpu cu118...")
+        studio.run("pip install -q paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/stable/cu118/")
+        paddle_check = studio.run("python3 -c \"import paddle; print('PADDLE_READY', paddle.__version__, paddle.device.cuda.device_count())\"").strip()
+    log(f"✅ PaddlePaddle: {paddle_check}")
+
+    log("📦 Cập nhật gói phụ thuộc tương thích NumPy 2.x...")
+    studio.run("python3 -m pip install -q --upgrade 'opencv-python>=4.10' 'opencv-python-headless>=4.10' 'scipy>=1.13' rapidfuzz visualdl pyclipper shapely lmdb attrdict")
+
+    log("🔧 Thiết lập sitecustomize.py monkeypatch...")
+    sitecust_cmd = """python3 -c "
+import site, pathlib
+patch = '''import numpy as np
+if not hasattr(np, 'sctypes'): np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64], 'uint': [np.uint8, np.uint16, np.uint32, np.uint64], 'float': [np.float16, np.float32, np.float64], 'complex': [np.complex64, np.complex128], 'others': [bool, object, bytes, str]}
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'typeDict'): np.typeDict = {}
+if not hasattr(np, 'long'): np.long = int
+if not hasattr(np, 'ulong'): np.ulong = int
+if not hasattr(np, 'unicode_'): np.unicode_ = str
+if not hasattr(np, 'string_'): np.string_ = bytes
+if not hasattr(np, 'object_'): np.object_ = object
+if not hasattr(np, 'complex_'): np.complex_ = complex
+'''
+sp_list = site.getsitepackages()
+for sp in sp_list:
+    try:
+        (pathlib.Path(sp) / 'sitecustomize.py').write_text(patch, encoding='utf-8')
+        print(f'Wrote sitecustomize.py to {sp}')
+    except Exception as e:
+        pass
+" """
+    studio.run(sitecust_cmd)
+
+    log("🔧 Vá random_crop_data.py loại bỏ size=1 cho NumPy 2.x...")
+    crop_patch_cmd = """python3 -c "
+import pathlib
+p = pathlib.Path('Cham-OCR/ocr-training/PaddleOCR/ppocr/data/imaug/random_crop_data.py')
+if p.exists():
+    txt = p.read_text(encoding='utf-8')
+    if 'size=1' in txt:
+        txt = txt.replace('xx = int(np.random.choice(axis, size=1))', 'xx = int(np.random.choice(axis))')
+        p.write_text(txt, encoding='utf-8')
+        print('Đã vá random_crop_data.py')
+    else:
+        print('random_crop_data.py đã được vá trước đó')
+" """
+    log(f"   {studio.run(crop_patch_cmd).strip()}")
+
+    log("\n📄 [BƯỚC 3/6] Đồng bộ cấu hình ch_PP-OCRv4_det_h100.yml trực tiếp từ máy local...")
+    local_cfg_path = os.path.join(os.getcwd(), "ocr-training", "configs", "det", "ch_PP-OCRv4_det_h100.yml")
+    with open(local_cfg_path, "rb") as f:
+        b64_cfg = base64.b64encode(f.read()).decode('ascii')
+    studio.run(f"echo '{b64_cfg}' | base64 -d > Cham-OCR/ocr-training/PaddleOCR/configs/det/ch_PP-OCRv4_det_h100.yml")
+    studio.run(f"cp Cham-OCR/ocr-training/PaddleOCR/configs/det/ch_PP-OCRv4_det_h100.yml Cham-OCR/ocr-training/configs/det/ch_PP-OCRv4_det_h100.yml")
+    log("   CONFIG_SYNCED_SUCCESSFULLY via base64 pipe")
+
+    log("\n🧪 [BƯỚC 4/6] Chạy kiểm thử tại chỗ PRE-FLIGHT TEST (Train + Eval + Metric)...")
+    preflight_script = """cd Cham-OCR/ocr-training/PaddleOCR && python3 -c "
+import logging
+logger = logging.getLogger('preflight')
+import yaml, paddle, time
+from ppocr.data import build_dataloader
+from ppocr.modeling.architectures import build_model
+from ppocr.postprocess import build_post_process
+from ppocr.metrics import build_metric
+
+with open('configs/det/ch_PP-OCRv4_det_h100.yml', 'r') as f:
+    config = yaml.safe_load(f)
+
+print('1. Kiểm tra Train DataLoader (batch size 32)...')
+train_loader = build_dataloader(config, 'Train', paddle.device.get_device(), logger)
+sample_train_batch = None
+for idx, batch in enumerate(train_loader):
+    print(f'   Train Batch {idx}: image shape = {batch[0].shape}')
+    sample_train_batch = batch
+    if idx >= 1:
+        break
+
+print('2. Kiểm tra Eval DataLoader (batch size 1, dynamic shapes)...')
+eval_loader = build_dataloader(config, 'Eval', paddle.device.get_device(), logger)
+eval_batches = []
+for idx, batch in enumerate(eval_loader):
+    print(f'   Eval Batch {idx}: image shape = {batch[0].shape}, polys count = {len(batch[2][0])}')
+    eval_batches.append(batch)
+    if idx >= 4:
+        break
+
+print('3. Kiểm tra Model forward pass + PostProcess + Metric...')
+model = build_model(config['Architecture'])
+model.eval()
+post_process_class = build_post_process(config['PostProcess'])
+eval_class = build_metric(config['Metric'])
+
+with paddle.no_grad():
+    for batch in eval_batches:
+        images = batch[0]
+        preds = model(images)
+        post_res = post_process_class(preds, batch[1])
+        eval_class(post_res, batch)
+
+metric = eval_class.get_metric()
+print(f'   Evaluation metric calculated successfully: {metric}')
+
+print('=== PRE_FLIGHT_PASSED_100% ===')
+" """
+    preflight_out = studio.run(preflight_script).strip()
+    log(f"Kết quả Pre-flight Test:\n{preflight_out}")
+
+    if "=== PRE_FLIGHT_PASSED_100% ===" not in preflight_out:
+        log("❌ Pre-flight test chưa hoàn thành trọn vẹn! Máy vẫn được GIỮ MỞ để kiểm tra.")
+        return
+
+    log("\n🎉 PRE-FLIGHT TEST ĐÃ ĐẠT 100%! BẮT ĐẦU CHẠY HUẤN LUYỆN CHÍNH THỨC 150 EPOCHS...")
+
+    try:
+        log("\n🚀 [BƯỚC 5/6] Khởi chạy huấn luyện Cham-DBNet (150 epochs, batch 32, single-GPU L4)...")
+        studio.run("pkill -9 -f train.py 2>/dev/null || true")
+        studio.run("pkill -9 -f python 2>/dev/null || true")
+        time.sleep(2)
+        studio.run("cd Cham-OCR/ocr-training/PaddleOCR && rm -f train.log && rm -rf log output/ch_PP-OCRv4_det_cham_h100")
+        studio.run("mkdir -p Cham-OCR/ocr-training/output")
+        time.sleep(1)
+
+        vram_check = studio.run("nvidia-smi --query-gpu=memory.used,memory.total --format=csv,noheader").strip()
+        log(f"   VRAM trước khi khởi chạy: {vram_check}")
+
+        launch_cmd = (
+            "cd Cham-OCR/ocr-training/PaddleOCR && "
+            "nohup python3 -u tools/train.py -c configs/det/ch_PP-OCRv4_det_h100.yml > train.log 2>&1 &"
+        )
+        studio.run(launch_cmd)
+        time.sleep(5)
+        log("✅ Tiến trình huấn luyện đã kích hoạt chạy nền! Đang bắt đầu theo dõi tiến độ...")
+
+        start_time = time.time()
+        prev_log = ""
+
+        while True:
+            time.sleep(20)
+            ps_cnt = studio.run("ps aux | grep '[t]ools/train.py' | wc -l").strip()
+            is_alive = int(ps_cnt or "0") > 0
+
+            try:
+                latest_lines = studio.run(
+                    "cd Cham-OCR/ocr-training/PaddleOCR && tail -n 15 train.log"
+                ).strip()
+                if latest_lines and latest_lines != prev_log:
+                    prev_log = latest_lines
+                    elapsed_min = (time.time() - start_time) / 60
+                    log(f"⏱️ [{elapsed_min:.1f}m] Tiến độ log:")
+                    matched = False
+                    for l in latest_lines.splitlines():
+                        if any(k in l for k in ["epoch:", "loss:", "hmean:", "save checkpoint", "Error", "Traceback", "MainIndicator", "step:", "eval model:", "PPLCNet", "download"]):
+                            log(f"   {l}")
+                            matched = True
+                    if not matched and latest_lines.strip():
+                        log(f"   {latest_lines.splitlines()[-1]}")
+            except Exception as e:
+                log(f"Log notice: {e}")
+
+            if not is_alive:
+                final_log = studio.run(
+                    "cd Cham-OCR/ocr-training/PaddleOCR && tail -n 50 train.log"
+                ).strip()
+                log(f"--- 50 DÒNG LOG CUỐI CÙNG ---\n{final_log}\n-----------------------------")
+
+                if "Traceback (most recent call last)" in final_log or "Exit code 1" in final_log or "SystemError:" in final_log or "FatalError:" in final_log:
+                    raise RuntimeError("Tiến trình huấn luyện gặp lỗi ngoại lệ dừng đột ngột!")
+
+                chk_check = studio.run("test -f Cham-OCR/ocr-training/PaddleOCR/output/ch_PP-OCRv4_det_cham_h100/latest.pdparams && echo CHK_FOUND || echo NO_CHK").strip()
+                if "CHK_FOUND" not in chk_check:
+                    raise RuntimeError("Huấn luyện dừng trước khi lưu checkpoint!")
+
+                log("\n🎉 TIẾN TRÌNH HUẤN LUYỆN 150 EPOCHS ĐÃ KẾT THÚC HOÀN TOÀN THÀNH CÔNG!")
+                break
+
+
+        log("\n📦 [BƯỚC 6/6] Xuất mô hình Inference & Tải về máy local...")
+        export_script = """
+cd Cham-OCR/ocr-training/PaddleOCR
+BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/best_accuracy"
+if [ ! -f "${BEST_MODEL}.pdparams" ]; then
+    BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/latest"
+fi
+echo "Using checkpoint: $BEST_MODEL"
+mkdir -p ../output
+python3 tools/export_model.py \
+    -c configs/det/ch_PP-OCRv4_det_h100.yml \
+    -o Global.pretrained_model=${BEST_MODEL} \
+       Global.save_inference_dir=../output/ch_PP-OCRv4_det_cham_infer
+
+cd ../output
+rm -f ../cham_dbnet_v1_infer.zip
+python3 -c "import shutil; shutil.make_archive('../cham_dbnet_v1_infer', 'zip', '.', 'ch_PP-OCRv4_det_cham_infer')"
+ls -lh ../cham_dbnet_v1_infer.zip
+"""
+        export_out = studio.run(export_script).strip()
+        log(f"Export log:\n{export_out}")
+
+        log("⬇️ Đang tải tệp cham_dbnet_v1_infer.zip về thư mục ocr-training/ ...")
+        local_dest = os.path.join(os.getcwd(), "ocr-training", "cham_dbnet_v1_infer.zip")
+        downloaded = False
+        try:
+            studio.download_file("Cham-OCR/ocr-training/cham_dbnet_v1_infer.zip", local_dest)
+            if os.path.exists(local_dest) and os.path.getsize(local_dest) > 1000:
+                downloaded = True
+                log("   Đã tải thành công qua native studio.download_file!")
+        except Exception as dl_err:
+            log(f"   Native download gặp lỗi ({dl_err}), chuyển sang Base64 fallback...")
+
+        if not downloaded:
+            remote_b64 = studio.run(
+                "python3 -c \"import base64, pathlib; p = pathlib.Path('Cham-OCR/ocr-training/cham_dbnet_v1_infer.zip'); print(base64.b64encode(p.read_bytes()).decode('ascii'))\""
+            ).strip()
+            with open(local_dest, "wb") as f:
+                f.write(base64.b64decode(remote_b64))
+
+        local_size_mb = os.path.getsize(local_dest) / (1024 * 1024)
+        log(f"🎉 ĐÃ TẢI THÀNH CÔNG: {local_dest} ({local_size_mb:.2f} MB)")
+
+        infer_extract_dir = os.path.join(os.getcwd(), "ocr-training", "cham_dbnet_v1_infer")
+        os.makedirs(infer_extract_dir, exist_ok=True)
+        with zipfile.ZipFile(local_dest, "r") as zf:
+            zf.extractall(infer_extract_dir)
+        log(f"📂 Đã giải nén mô hình suy luận vào: {infer_extract_dir}")
+
+    except Exception as exc:
+        log(f"❌ XẢY RA LỖI: {exc}")
+        raise exc
+
+    finally:
+        log("\n🛑 [AN TOÀN] Đang dừng Studio để bảo vệ số dư tài khoản...")
+        try:
+            if str(studio.status).lower() == "running":
+                studio.stop()
+                log(f"✅ Studio đã DỪNG (Status: {studio.status})! 0 credit bị tiêu tốn thêm.")
+            else:
+                log(f"✅ Studio hiện tại đã ở trạng thái {studio.status}, an toàn.")
+        except Exception as stop_err:
+            log(f"Cảnh báo khi dừng Studio: {stop_err}")
+
+    log("\n🎊 TOÀN BỘ QUY TRÌNH ĐÃ HOÀN TẤT THÀNH CÔNG RỰC RỠ!")
+
+if __name__ == "__main__":
+    main()

ocr-training/scripts/run_lightning_remote.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Automated Remote Orchestrator for Cham-DBNet on Lightning AI Studio.
+Manages:
+1. Phase 1 (CPU): Git clone, dependencies install, dataset generation (12,000 pages, 50% tight lines).
+2. Phase 2 (H100 Switch): Switch machine to NVIDIA H100 (80GB VRAM SXM5).
+3. Phase 3 (Training & Monitoring): Launch PaddleOCR DBNet distributed training, stream log metrics.
+4. Phase 4 (Export & Download): Export lightweight inference model, package ZIP, download locally.
+5. Phase 5 (Auto Stop): Stop Studio immediately to prevent credit consumption.
+"""
+
+import os
+import sys
+import time
+from lightning_sdk import Studio, Machine
+
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def log(msg):
+    timestamp = time.strftime("%H:%M:%S")
+    print(f"[{timestamp}] {msg}", flush=True)
+
+def main():
+    log("=================================================================")
+    log("🚀 KHỞI ĐỘNG REMOTE ORCHESTRATOR TRÊN LIGHTNING AI")
+    log("=================================================================")
+
+    studio = Studio(name="cham-det-h100", teamspace="phucsd", org="phucsd-org")
+    log(f"Trạng thái Studio hiện tại: {studio.status} (Machine: {studio.machine})")
+
+    # PHASE 1: CPU SETUP & DATASET GENERATION
+    log("\n📦 --- PHASE 1: THIẾT LẬP MÔI TRƯỜNG & SINH DỮ LIỆU TRÊN CPU (0 CREDIT) ---")
+    
+    setup_cmds = [
+        # 1. Clone or Pull Cham-OCR
+        "if [ ! -d 'Cham-OCR' ]; then git clone https://github.com/phucsd1/Cham-OCR.git; else cd Cham-OCR && git pull origin main && cd ..; fi",
+        # 2. Clone PaddleOCR inside Cham-OCR/ocr-training if not exists
+        "cd /teamspace/studios/this_studio/Cham-OCR/ocr-training && if [ ! -d 'PaddleOCR' ]; then git clone -b release/2.7 https://github.com/PaddlePaddle/PaddleOCR.git; fi",
+        # 3. Download fonts
+        "cd /teamspace/studios/this_studio/Cham-OCR/ocr-training && mkdir -p data/fonts && wget -q -nc -O data/fonts/NotoSansCham-Regular.ttf https://raw.githubusercontent.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSansCham/NotoSansCham-Regular.ttf && wget -q -nc -O data/fonts/NotoSansCham-Bold.ttf https://raw.githubusercontent.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSansCham/NotoSansCham-Bold.ttf",
+        # 4. Download pretrained weights
+        "cd /teamspace/studios/this_studio/Cham-OCR/ocr-training && mkdir -p PaddleOCR/pretrain_models && wget -q -nc -O PaddleOCR/pretrain_models/PPLCNetV3_x0_75_ocr_det.pdparams https://paddleocr.bj.bcebos.com/pretrained/PPLCNetV3_x0_75_ocr_det.pdparams",
+        # 5. Install general pip dependencies
+        "pip install -q pyclipper shapely imgaug lmdb attrdict pillow opencv-python pyyaml",
+    ]
+
+    for cmd in setup_cmds:
+        log(f"Đang thực thi: {cmd[:70]}...")
+        out = studio.run(cmd)
+        if out.strip():
+            log(f"   -> {out.strip()[:200]}")
+
+    log("✅ Thiết lập mã nguồn, phông chữ và pretrained model hoàn tất!")
+
+    # 6. Generate dataset on CPU
+    log("⚙️ Bắt đầu sinh 12,000 trang huấn luyện và 1,200 trang kiểm thử (50% cự ly siêu hẹp 3-10px)...")
+    gen_cmd = "cd /teamspace/studios/this_studio/Cham-OCR/ocr-training && python3 scripts/generate_detector_data_v2.py --num_train 12000 --num_val 1200 --output_dir PaddleOCR/data/detector_v2 --workers 8"
+    out = studio.run(gen_cmd)
+    log("Kết quả sinh dữ liệu:")
+    for line in out.strip().splitlines()[-6:]:
+        log(f"   {line}")
+
+    # Copy config
+    studio.run("cd /teamspace/studios/this_studio/Cham-OCR/ocr-training && mkdir -p PaddleOCR/configs/det && cp configs/det/ch_PP-OCRv4_det_h100.yml PaddleOCR/configs/det/")
+    log("✅ Bộ dữ liệu và cấu hình H100 đã sẵn sàng!")
+
+    # PHASE 2: SWITCH MACHINE TO H100
+    log("\n🔥 --- PHASE 2: CHUYỂN ĐỔI PHẦN CỨNG SANG GPU NVIDIA H100 (80GB VRAM) ---")
+    log("Đang gửi lệnh switch_machine sang H100...")
+    studio.switch_machine(Machine.H100)
+    log(f"Trạng thái sau khi chuyển: {studio.status} (Machine: {studio.machine})")
+
+    # Install paddlepaddle-gpu for Hopper/CUDA
+    log("📦 Cài đặt PaddlePaddle GPU bản CUDA 11.8/12.x tối ưu H100...")
+    studio.run("pip install -q paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/stable/cu118/")
+    gpu_info = studio.run("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader")
+    log(f"🔥 GPU đã nhận diện: {gpu_info.strip()}")
+
+    # PHASE 3: LAUNCH TRAINING WITH BACKGROUND MONITORING
+    log("\n🚀 --- PHASE 3: KHỞI CHẠY HUẤN LUYỆN CHAM-DBNET TRÊN H100 ---")
+    train_script = """cd /teamspace/studios/this_studio/Cham-OCR/ocr-training/PaddleOCR && nohup python3 -m paddle.distributed.launch --gpus '0' tools/train.py -c configs/det/ch_PP-OCRv4_det_h100.yml > train.log 2>&1 &"""
+    studio.run(train_script)
+    log("✅ Lệnh huấn luyện đã kích hoạt chạy ngầm (background) an toàn trên H100!")
+
+    # MONITORING LOOP
+    log("📊 Bắt đầu vòng lặp theo dõi liên tục tiến trình huấn luyện...")
+    prev_log_tail = ""
+    idle_count = 0
+    start_time = time.time()
+
+    while True:
+        time.sleep(15)
+        # Check if process is still running
+        ps_out = studio.run("ps aux | grep tools/train.py | grep -v grep | wc -l")
+        is_running = int(ps_out.strip() or "0") > 0
+        
+        # Read log tail
+        try:
+            log_tail = studio.run("cd /teamspace/studios/this_studio/Cham-OCR/ocr-training/PaddleOCR && tail -n 8 train.log")
+            if log_tail.strip() != prev_log_tail:
+                prev_log_tail = log_tail.strip()
+                log("--- Cập nhật tiến trình mới nhất ---")
+                for l in log_tail.strip().splitlines()[-4:]:
+                    log(f"   {l}")
+        except Exception as e:
+            log(f"Không thể đọc log: {e}")
+
+        elapsed_mins = (time.time() - start_time) / 60
+        if not is_running:
+            log(f"\n🎉 Tiến trình huấn luyện đã kết thúc sau {elapsed_mins:.1f} phút!")
+            break
+
+    # PHASE 4: EXPORT MODEL & DOWNLOAD
+    log("\n📦 --- PHASE 4: XUẤT MÔ HÌNH INFERENCE & ĐÓNG GÓI ---")
+    export_cmd = """cd /teamspace/studios/this_studio/Cham-OCR/ocr-training/PaddleOCR && \
+BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/best_accuracy" && \
+if [ ! -f "${BEST_MODEL}.pdparams" ]; then BEST_MODEL="output/ch_PP-OCRv4_det_cham_h100/latest"; fi && \
+python3 tools/export_model.py -c configs/det/ch_PP-OCRv4_det_h100.yml -o Global.pretrained_model=${BEST_MODEL} Global.save_inference_dir=../output/ch_PP-OCRv4_det_cham_infer && \
+cd ../output && zip -r ../cham_dbnet_v1_infer.zip ch_PP-OCRv4_det_cham_infer/"""
+    
+    out = studio.run(export_cmd)
+    log("Kết quả đóng gói:")
+    for l in out.strip().splitlines()[-5:]:
+        log(f"   {l}")
+
+    # Download file to local workspace
+    local_zip_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "cham_dbnet_v1_infer.zip")
+    log(f"⬇️ Đang tải tệp mô hình về máy local: {local_zip_path}...")
+    studio.download_file("Cham-OCR/ocr-training/cham_dbnet_v1_infer.zip", local_zip_path)
+    log(f"✅ Đã tải thành công tệp mô hình ({os.path.getsize(local_zip_path) / (1024*1024):.2f} MB)!")
+
+    # PHASE 5: STOP STUDIO TO SAVE CREDITS
+    log("\n🛑 --- PHASE 5: TỰ ĐỘNG DỪNG STUDIO ĐỂ BẢO VỆ CREDIT ---")
+    studio.stop()
+    log("✅ Studio đã được DỪNG (STOPPED) an toàn! Không còn tiêu tốn bất kỳ credit nào.")
+    log("=================================================================")
+    log("🎊 HOÀN THÀNH TOÀN BỘ QUY TRÌNH HUẤN LUYỆN CHAM-DBNET TRÊN H100!")
+    log("=================================================================")
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/test_live_ocr.py

@@ -0,0 +1,50 @@
+import sys
+import requests
+import json
+import base64
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+print("=== KIỂM THỬ GIAO DIỆN & API TINH GIẢN HÓA (CHỈ CẦN ẢNH & MÔ HÌNH) ===")
+
+# 1. Kiểm tra HTML đã gỡ bỏ hoàn toàn khối cấu hình thủ công
+html_resp = requests.get('https://ocr.cham.asia', timeout=30)
+html_text = html_resp.text
+has_adv = 'advanced-settings-content' in html_text
+has_method_sel = 'method-select' in html_text
+has_thresh = 'threshold-input' in html_text
+print(f"1. Kiểm tra HTML giao diện Web:")
+print(f"   - Mã phản hồi HTTP: {html_resp.status_code}")
+print(f"   - Còn chứa khối 'Cấu hình nâng cao': {has_adv}")
+print(f"   - Còn chứa menu chọn thuật toán: {has_method_sel}")
+print(f"   - Còn chứa input ngưỡng nhị phân: {has_thresh}")
+
+if not has_adv and not has_method_sel and not has_thresh:
+    print("   👉 Giao diện Web đã được tinh giản hoàn hảo!")
+else:
+    print("   ⚠️ Vẫn còn sót thành phần cũ trên giao diện.")
+
+# 2. Kiểm tra API POST /ocr với payload tối giản
+with open('ocr-training/output/evidence/page_ocr/page_0.png', 'rb') as f:
+    img_b64 = base64.b64encode(f.read()).decode('utf-8')
+
+print(f"\n2. Gửi yêu cầu OCR với Payload tối giản (không gửi method/threshold):")
+payload = {
+    'image': 'data:image/png;base64,' + img_b64,
+    'model': 'v24'
+}
+
+resp = requests.post('https://ocr.cham.asia/ocr', json=payload, timeout=60)
+data = resp.json()
+
+if 'error' in data:
+    print("❌ Lỗi:", data['error'])
+else:
+    lines = data.get('lines', [])
+    profiler = data.get('profiler', {})
+    print(f"✅ Thành công 100%! Phát hiện {len(lines)} dòng chữ:")
+    print(f"   - Thuật toán phân đoạn tự động kích hoạt: {profiler.get('method')}")
+    print(f"   - Tổng thời gian xử lý: {profiler.get('backend_total_sec')}s")
+    for idx, l in enumerate(lines):
+        print(f"   [Dòng {idx+1}] Độ tin cậy: {l['confidence']:.4f} | BBox: {l['bbox']} | Text: {l['text']}")

ocr-training/scripts/train_and_export_h100.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+One-Click Automated Training & Inference Export Pipeline for Cham-DBNet on Lightning AI (H100).
+Executes:
+1. Environment & CUDA hardware check (Hopper H100 / sm_90 verification)
+2. Dataset presence check (generates if missing)
+3. Pretrained weight verification
+4. Distributed/Single GPU training with PaddleOCR DBNet
+5. Model export to lightweight inference model (inference.pdmodel / inference.pdiparams)
+6. Automatic ZIP packaging for 1-click download.
+"""
+
+import os
+import sys
+import shutil
+import zipfile
+import subprocess
+
+# Force UTF-8 stdout
+if sys.stdout and sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        pass
+
+def check_environment():
+    print("=" * 65)
+    print("🔍 1. KIỂM TRA MÔI TRƯỜNG & GPU PHẦN CỨNG (LIGHTNING AI)")
+    print("=" * 65)
+    try:
+        import paddle
+        print(f"   - PaddlePaddle version: {paddle.__version__}")
+        print(f"   - CUDA compiled: {paddle.is_compiled_with_cuda()}")
+        if paddle.is_compiled_with_cuda():
+            count = paddle.device.cuda.device_count()
+            print(f"   - Số lượng GPU khả dụng: {count}")
+            for i in range(count):
+                name = paddle.device.cuda.get_device_name(i)
+                print(f"     + GPU {i}: {name}")
+        else:
+            print("   ⚠️ CẢNH BÁO: PaddlePaddle chưa kích hoạt CUDA GPU!")
+    except ImportError:
+        print("   ❌ LỖI: Chưa cài đặt PaddlePaddle! Chạy: pip install paddlepaddle-gpu")
+        sys.exit(1)
+
+def run_command(cmd, desc="Running"):
+    print(f"\n🚀 [{desc}] Lệnh: {cmd}")
+    ret = subprocess.run(cmd, shell=True)
+    if ret.returncode != 0:
+        print(f"❌ Lỗi khi thực hiện: {desc} (Mã lỗi: {ret.returncode})")
+        sys.exit(ret.returncode)
+    print(f"✅ Hoàn tất: {desc}")
+
+def main():
+    check_environment()
+    
+    workspace_dir = os.path.abspath(os.getcwd())
+    paddleocr_dir = os.path.join(workspace_dir, "PaddleOCR")
+    if not os.path.exists(paddleocr_dir):
+        print("\n📥 Chưa tìm thấy PaddleOCR, đang clone release/2.7...")
+        run_command("git clone -b release/2.7 https://github.com/PaddlePaddle/PaddleOCR.git", "Clone PaddleOCR")
+        
+    config_path = os.path.join(workspace_dir, "configs", "det", "ch_PP-OCRv4_det_h100.yml")
+    if not os.path.exists(config_path):
+        # Check inside PaddleOCR
+        config_path = os.path.join(paddleocr_dir, "configs", "det", "ch_PP-OCRv4_det_h100.yml")
+        
+    # Check dataset
+    dataset_dir = os.path.join(paddleocr_dir, "data", "detector_v2")
+    if not os.path.exists(dataset_dir) or not os.path.exists(os.path.join(dataset_dir, "det_train_label.txt")):
+        print("\n📂 Chưa có dữ liệu detector_v2, đang khởi chạy bộ sinh dữ liệu đặc trị dòng hẹp...")
+        gen_script = os.path.join(workspace_dir, "scripts", "generate_detector_data_v2.py")
+        if not os.path.exists(gen_script):
+            gen_script = "scripts/generate_detector_data_v2.py"
+        run_command(f"python3 {gen_script} --num_train 12000 --num_val 1200 --output_dir {dataset_dir} --workers 8", "Sinh dữ liệu Detection V2")
+
+    # Start training
+    print("\n" + "=" * 65)
+    print("🔥 2. BẮT ĐẦU HUẤN LUYỆN CHAM-DBNET TRÊN GPU H100")
+    print("=" * 65)
+    
+    import paddle
+    gpu_count = paddle.device.cuda.device_count() if paddle.is_compiled_with_cuda() else 1
+    gpu_list = ",".join([str(i) for i in range(gpu_count)])
+    
+    os.chdir(paddleocr_dir)
+    train_cmd = f"python3 -m paddle.distributed.launch --gpus '{gpu_list}' tools/train.py -c {config_path}"
+    run_command(train_cmd, "Huấn luyện PaddleOCR DBNet")
+    
+    # Export Model
+    print("\n" + "=" * 65)
+    print("📦 3. XUẤT MÔ HÌNH INFERENCE (INFERENCE MODEL EXPORT)")
+    print("=" * 65)
+    
+    output_dir = os.path.join(paddleocr_dir, "output", "ch_PP-OCRv4_det_cham_h100")
+    best_model = os.path.join(output_dir, "best_accuracy")
+    if not os.path.exists(best_model + ".pdparams"):
+        best_model = os.path.join(output_dir, "latest")
+        
+    export_infer_dir = os.path.join(workspace_dir, "output", "ch_PP-OCRv4_det_cham_infer")
+    os.makedirs(export_infer_dir, exist_ok=True)
+    
+    export_cmd = f"python3 tools/export_model.py -c {config_path} -o Global.pretrained_model={best_model} Global.save_inference_dir={export_infer_dir}"
+    run_command(export_cmd, "Xuất mô hình Inference DBNet")
+    
+    # Package into ZIP
+    print("\n" + "=" * 65)
+    print("🎁 4. ĐÓNG GÓI TỆP NÉN SẴN SÀNG TẢI VỀ (ZIP PACKAGING)")
+    print("=" * 65)
+    
+    zip_path = os.path.join(workspace_dir, "cham_dbnet_v1_infer.zip")
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, _, files in os.walk(export_infer_dir):
+            for file in files:
+                full_path = os.path.join(root, file)
+                rel_path = os.path.relpath(full_path, os.path.dirname(export_infer_dir))
+                zipf.write(full_path, rel_path)
+                
+    print(f"🎉 HOÀN THÀNH TOÀN DIỆN!")
+    print(f"   - Mô hình Inference tại: {export_infer_dir}")
+    print(f"   - Tệp nén sẵn sàng tải về: {zip_path} ({os.path.getsize(zip_path) / (1024*1024):.2f} MB)")
+    print(f"👉 Hãy tải tệp zip này về và giải nén vào ocr-studio/data/output/ (thư mục ch_PP-OCRv4_det_cham_infer) để cập nhật hệ thống.")
+
+if __name__ == '__main__':
+    main()

ocr-training/scripts/weight_surgery_v24.py

@@ -0,0 +1,167 @@
+import os
+import sys
+import json
+import paddle
+import numpy as np
+
+if sys.stdout and hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8')
+
+def perform_weight_surgery_v24(old_ckpt_path='ocr-training/data/cham-ocr-v5-assets/v23_checkpoint/iter_epoch_200.pdparams',
+                               new_ckpt_dir='ocr-training/data/output_v24_temp/rec_cham_best_model',
+                               report_path='ocr-training/output/v24_training/head_extension_report.json',
+                               old_dict_path='ocr-training/data/cham_dict_v23.txt',
+                               new_dict_path='ocr-training/data/cham_dict_v24.txt'):
+    
+    os.makedirs(new_ckpt_dir, exist_ok=True)
+    os.makedirs(os.path.dirname(os.path.abspath(report_path)), exist_ok=True)
+    new_ckpt_path = os.path.join(new_ckpt_dir, 'iter_epoch_200.pdparams')
+    
+    # 1. Đếm số ký tự từ điển
+    with open(old_dict_path, 'r', encoding='utf-8') as f:
+        old_chars = [l for l in f.read().splitlines() if l]
+    with open(new_dict_path, 'r', encoding='utf-8') as f:
+        new_chars = [l for l in f.read().splitlines() if l]
+        
+    num_old = len(old_chars) # 82
+    num_new = len(new_chars) # 103
+    
+    # CTC: blank (0) + characters (1..num) + space (num+1)
+    old_ctc_classes = num_old + 2 # 84
+    new_ctc_classes = num_new + 2 # 105
+    
+    # GTC: 6 special tokens + characters
+    old_gtc_vocab = num_old + 6 # 88
+    new_gtc_vocab = num_new + 6 # 109
+    
+    print(f"🔬 Khởi chạy Phẫu thuật Trọng số (Weight Surgery) V24:")
+    print(f"   - Từ điển: {num_old} -> {num_new} ký tự")
+    print(f"   - CTC Classes: {old_ctc_classes} -> {new_ctc_classes}")
+    print(f"   - GTC Vocab: {old_gtc_vocab} -> {new_gtc_vocab}")
+    
+    old_state = paddle.load(old_ckpt_path)
+    new_state = {}
+    
+    for k, v in old_state.items():
+        if k == 'head.ctc_head.fc.weight':
+            in_features, old_c = v.shape
+            assert old_c == old_ctc_classes, f"Mismatch old CTC shape: {v.shape}"
+            
+            std = v.std().item()
+            mean = v.mean().item()
+            new_v_np = np.random.normal(mean, std, (in_features, new_ctc_classes)).astype('float32')
+            
+            # Bảo tồn trọng số cũ:
+            # idx 0: CTC blank
+            # idx 1..num_old: các ký tự cũ
+            new_v_np[:, 0:num_old+1] = v.numpy()[:, 0:num_old+1]
+            # idx space cũ chuyển sang idx space mới
+            new_v_np[:, new_ctc_classes - 1] = v.numpy()[:, old_ctc_classes - 1]
+            
+            new_state[k] = paddle.to_tensor(new_v_np)
+            print(f"   ✅ {k}: {v.shape} -> {new_state[k].shape}")
+            
+        elif k == 'head.ctc_head.fc.bias':
+            assert v.shape[0] == old_ctc_classes
+            new_v_np = np.zeros(new_ctc_classes, dtype='float32')
+            new_v_np[0:num_old+1] = v.numpy()[0:num_old+1]
+            new_v_np[new_ctc_classes - 1] = v.numpy()[old_ctc_classes - 1]
+            
+            new_state[k] = paddle.to_tensor(new_v_np)
+            print(f"   ✅ {k}: {v.shape} -> {new_state[k].shape}")
+            
+        elif k == 'head.gtc_head.embedding.embedding.weight':
+            old_v, embed_dim = v.shape
+            assert old_v == old_gtc_vocab
+            std = v.std().item()
+            mean = v.mean().item()
+            new_v_np = np.random.normal(mean, std, (new_gtc_vocab, embed_dim)).astype('float32')
+            
+            # idx 0..num_old+3: blank, unk, bos, eos + old characters
+            # Trong GTC: 4 tokens đầu + num_old ký tự = num_old + 4
+            split_point = num_old + 4
+            new_v_np[0:split_point, :] = v.numpy()[0:split_point, :]
+            
+            # 2 tokens cuối: space và pad
+            new_v_np[new_gtc_vocab - 2:new_gtc_vocab, :] = v.numpy()[old_gtc_vocab - 2:old_gtc_vocab, :]
+            
+            new_state[k] = paddle.to_tensor(new_v_np)
+            print(f"   ✅ {k}: {v.shape} -> {new_state[k].shape}")
+            
+        elif k == 'head.gtc_head.tgt_word_prj.weight':
+            embed_dim, old_v = v.shape
+            assert old_v == old_gtc_vocab
+            std = v.std().item()
+            mean = v.mean().item()
+            new_v_np = np.random.normal(mean, std, (embed_dim, new_gtc_vocab)).astype('float32')
+            
+            split_point = num_old + 4
+            new_v_np[:, 0:split_point] = v.numpy()[:, 0:split_point]
+            new_v_np[:, new_gtc_vocab - 2:new_gtc_vocab] = v.numpy()[:, old_gtc_vocab - 2:old_gtc_vocab]
+            
+            new_state[k] = paddle.to_tensor(new_v_np)
+            print(f"   ✅ {k}: {v.shape} -> {new_state[k].shape}")
+            
+        else:
+            new_state[k] = v
+            
+    # Lưu trọng số mở rộng mới
+    paddle.save(new_state, new_ckpt_path)
+    
+    report = {
+        "old_num_classes": old_ctc_classes,
+        "new_num_classes": new_ctc_classes,
+        "old_gtc_vocab": old_gtc_vocab,
+        "new_gtc_vocab": new_gtc_vocab,
+        "old_chars_preserved": True,
+        "new_chars_initialized": True,
+        "new_ckpt_path": new_ckpt_path
+    }
+    with open(report_path, 'w', encoding='utf-8') as f_rep:
+        json.dump(report, f_rep, indent=2)
+        
+    print(f"🎉 Phẫu thuật thành công! Đã lưu checkpoint nền V24 tại: {new_ckpt_path}")
+    return new_ckpt_path, report
+
+def find_assets_dir():
+    candidates = [
+        "ocr-training/data/cham-ocr-v5-assets",
+        "/kaggle/input/cham-ocr-v5-assets",
+        "/kaggle/input/datasets/gustavnguyen/cham-ocr-v5-assets"
+    ]
+    for c in candidates:
+        if os.path.exists(c):
+            return c
+    if os.path.exists('/kaggle/input'):
+        for root, dirs, files in os.walk('/kaggle/input'):
+            if 'v23_checkpoint' in dirs:
+                return root
+    return "ocr-training/data/cham-ocr-v5-assets"
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--assets-dir', type=str, default=None)
+    parser.add_argument('--old-ckpt', type=str, default=None)
+    parser.add_argument('--new-ckpt-dir', type=str, default=None)
+    args = parser.parse_args()
+    
+    assets_dir = args.assets_dir or find_assets_dir()
+    old_ckpt = args.old_ckpt or os.path.join(assets_dir, 'v23_checkpoint', 'iter_epoch_200.pdparams')
+    new_ckpt_dir = args.new_ckpt_dir or ('/kaggle/working/data/output_v24_temp/rec_cham_best_model' if os.path.exists('/kaggle') else 'ocr-training/data/output_v24_temp/rec_cham_best_model')
+    report_path = '/kaggle/working/output/v24_training/head_extension_report.json' if os.path.exists('/kaggle') else 'ocr-training/output/v24_training/head_extension_report.json'
+    old_dict = os.path.join(assets_dir, 'v23_checkpoint', 'cham_dict_v23.txt')
+    if not os.path.exists(old_dict):
+        old_dict = 'ocr-training/data/cham_dict_v23.txt'
+    new_dict = '/kaggle/working/data/cham_dict_v24.txt' if os.path.exists('/kaggle') else 'ocr-training/data/cham_dict_v24.txt'
+    
+    perform_weight_surgery_v24(
+        old_ckpt_path=old_ckpt,
+        new_ckpt_dir=new_ckpt_dir,
+        report_path=report_path,
+        old_dict_path=old_dict,
+        new_dict_path=new_dict
+    )
+
+if __name__ == '__main__':
+    main()