Fine-tune T5Gemma-2

T5Gemma 2 là một họ mô hình encoder–decoder gọn nhẹ, open-weight từ Google, xây dựng trên Gemma 3, hỗ trợ đầu vào đa ngôn ngữ và đa phương thức. 

Với cửa sổ ngữ cảnh lên đến 128K trên hơn 140 ngôn ngữ và các lựa chọn thiết kế tiết kiệm tham số như ràng buộc embedding và hợp nhất attention, các mô hình này phù hợp cho nhiệm vụ sinh văn bản và hiểu hình ảnh, đồng thời vẫn đủ nhỏ để chạy trên laptop.

Trong hướng dẫn này, chúng ta sẽ học cách fine-tune một mô hình encoder–decoder trên tập dữ liệu LaTeX OCR. Mục tiêu là đạt hiệu năng tốt với số lượng mẫu huấn luyện tối thiểu. 

1. Thiết lập môi trường GPU A100 trên RunPod

Mặc dù có thể fine-tune mô hình này trên Kaggle hoặc Google Colab, nhưng làm vậy thường dẫn đến phiên làm việc không ổn định, ngắt kết nối tài nguyên và tốc độ huấn luyện chậm đáng kể. Để tránh những vướng mắc này và giữ cấu hình đơn giản, tin cậy, chúng ta sẽ dùng GPU NVIDIA A100.

Bạn có thể thuê một A100 trên RunPod với khoảng $1,39 mỗi giờ, và toàn bộ quá trình huấn luyện trong hướng dẫn này sẽ mất dưới 30 phút. Thiết lập này giúp bạn có hiệu năng ổn định mà không phải vật lộn với giới hạn bộ nhớ.

Bắt đầu bằng cách truy cập RunPod và tạo một pod mới dùng image PyTorch mới nhất. Chọn máy 1× A100.

Tiếp theo, chỉnh cấu hình pod và thêm biến môi trường tên là HF_TOKEN. Token này cần để:

• Tải các mô hình bị khóa trên Hugging Face
• Đẩy mô hình đã fine-tune trở lại Hugging Face Hub

Khi pod sẵn sàng, hãy mở notebook và cài đặt các gói Python cần thiết. Đảm bảo bạn đang dùng phiên bản mới nhất của transformers.

!pip -q install -U accelerate datasets pillow sentencepiece safetensors
!pip install --quiet "transformers==5.0.0rc1"
!pip install --quiet --no-deps trlĐược hỗ trợ bởi

Giờ hãy import các thư viện và tiện ích sẽ dùng xuyên suốt notebook.

import torch
from datasets import load_dataset
from transformers import AutoProcessor, AutoModelForSeq2SeqLM
from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer, set_seedĐược hỗ trợ bởi

Trước khi huấn luyện, chúng ta áp dụng một vài cấu hình tối ưu cho GPU A100. Đặt seed để đảm bảo tái lập, và bật TF32 để cải thiện hiệu năng mà không ảnh hưởng đến độ ổn định của huấn luyện bf16.

set_seed(42)

torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True

print("CUDA:", torch.cuda.is_available(), torch.cuda.get_device_name(0) if torch.cuda.is_available() else None)
print("bf16 supported:", torch.cuda.is_available() and torch.cuda.is_bf16_supported())Được hỗ trợ bởi

CUDA: True NVIDIA A100 80GB PCIe
bf16 supported: TrueĐược hỗ trợ bởi

2. Tiền xử lý tập dữ liệu LaTeX OCR cho huấn luyện ít dữ liệu

Trong hướng dẫn này, chúng ta dùng tập dữ liệu LaTeX OCR có sẵn trên Hugging Face. Mỗi ví dụ trong tập dữ liệu gồm:

• một hình ảnh chứa biểu thức toán học, và
• phần văn bản nguồn LaTeX tương ứng làm đầu ra mục tiêu.

Tập dữ liệu cung cấp nhiều cấu hình. Để giữ việc huấn luyện hiệu quả và phù hợp với mục tiêu học từ dữ liệu hạn chế, chúng ta sẽ chủ động kiểm soát kích thước tập dữ liệu.

Đầu tiên, tải các tập train và validation. Để mô phỏng kịch bản fine-tune với ít dữ liệu, chúng ta xáo trộn ngẫu nhiên tập dữ liệu và chọn một tập con nhỏ:

• 1.000 mẫu cho huấn luyện
• 200 mẫu cho validation

Cách này giúp huấn luyện nhanh mà vẫn cho phép mô hình khái quát hóa.

DATASET_NAME = "full"
raw_train = load_dataset("linxy/LaTeX_OCR", name=DATASET_NAME, split="train")
raw_val   = load_dataset("linxy/LaTeX_OCR", name=DATASET_NAME, split="validation")

train_ds = raw_train.shuffle(seed=42).select(range(1000))
val_ds   = raw_val.shuffle(seed=42).select(range(200)) 

print(train_ds, val_ds)
print("Columns:", train_ds.column_names)Được hỗ trợ bởi

Đầu ra:

Dataset({
    features: ['image', 'text'],
    num_rows: 1000
}) Dataset({
    features: ['image', 'text'],
    num_rows: 200
})
Columns: ['image', 'text']Được hỗ trợ bởi

Để hiểu rõ dữ liệu hơn, hãy xem một ví dụ huấn luyện. Trước hết, kiểm tra hình ảnh.

train_ds[10]["image"]Được hỗ trợ bởi

Tiếp theo, xem chuỗi LaTeX thô đi kèm với hình ảnh đó.

train_ds[10]["text"]Được hỗ trợ bởi

'G ( \\beta , \\tilde { \\mu } ) = \\left( \\frac { \\pi \\mu \\Gamma ( \\frac { \\lambda } { \\lambda + 1 } ) } { 2 \\Gamma ( \\frac { 1 } { \\lambda + 1 } ) } \\right) ^ { \\frac { 1 } { 2 \\lambda } } g _ { 0 } ( \\beta ) g _ { S } ( \\beta , Z ) ,'Được hỗ trợ bởi

Cuối cùng, chúng ta có thể render biểu thức LaTeX này trực tiếp trong notebook để kiểm chứng văn bản khớp với nội dung hình ảnh.

from IPython.display import display, Math, Latex

latex = train_ds[10]["text"]
display(Math(latex))Được hỗ trợ bởi

3. Khởi tạo encoder–decoder đa phương thức T5Gemma-2

Khi tập dữ liệu đã sẵn sàng, bước tiếp theo là tải mô hình T5Gemma-2 và processor tương ứng. Chúng ta sẽ dùng biến thể 270M–270M, cung cấp cân bằng tốt giữa khả năng và hiệu quả, vừa vặn trên GPU phổ thông.

MODEL_ID = "google/t5gemma-2-270m-270m"

processor = AutoProcessor.from_pretrained(MODEL_ID, use_fast=True)
model = AutoModelForSeq2SeqLM.from_pretrained(
    MODEL_ID,
    dtype=torch.bfloat16,   # A100 -> bf16
    device_map="auto",
)Được hỗ trợ bởi

Tokenizer được truy cập qua processor. Một số mô hình encoder–decoder không định nghĩa token padding theo mặc định, vì vậy chúng ta thêm nếu cần và resize embedding token của mô hình cho phù hợp.

tokenizer = processor.tokenizer
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({"pad_token": tokenizer.eos_token})
    model.resize_token_embeddings(len(tokenizer))Được hỗ trợ bởi

Đối với LaTeX OCR, chúng ta hướng dẫn mô hình bằng một prompt văn bản ngắn đi kèm hình ảnh đầu vào. Prompt này nêu rõ nhiệm vụ và ràng buộc định dạng đầu ra.

Cuối cùng, chúng ta đặt độ dài chuỗi tối đa cho đầu vào encoder và mục tiêu decoder. Các giá trị này đủ cho hầu hết biểu thức toán học trong khi vẫn kiểm soát tiêu thụ bộ nhớ.

PROMPT = "<start_of_image> Convert this image to LaTeX. Output only LaTeX."
MAX_INPUT_LEN  = 128
MAX_TARGET_LEN = 256Được hỗ trợ bởi

4. Chạy suy luận cơ bản: Kiểm tra hiệu năng zero-shot

Trước khi bắt đầu fine-tune, hữu ích khi chạy một suy luận cơ bản với mô hình T5Gemma-2 pretrained. Điều này giúp hiểu mô hình ứng xử ra sao với nhiệm vụ LaTeX OCR khi chưa có huấn luyện đặc thù nhiệm vụ và cung cấp mốc tham chiếu cho cải thiện sau này.

Dưới đây là phác thảo ngắn gọn quy trình:

1. Chọn một hình mẫu từ tập huấn luyện.
2. Chuẩn bị đầu vào mô hình bằng cách kết hợp hình ảnh và prompt văn bản thành định dạng tensor yêu cầu.
3. Chạy suy luận ở chế độ đánh giá với tính toán gradient tắt để tiết kiệm bộ nhớ và tăng tốc sinh.
4. Dùng beam search với số beam hạn chế và phạt lặp nhẹ để có đầu ra sạch hơn.
5. Giải mã token sinh ra về văn bản khi quá trình hoàn tất.

image = train_ds[20]["image"]

# prepare inputs
model_inputs = processor(text=PROMPT, images=image, return_tensors="pt")
model_inputs = {k: v.to("cuda") for k, v in model_inputs.items()}

# run inference
model = model.eval()
with torch.inference_mode():
    generation = model.generate(
        **model_inputs,
        max_new_tokens=100,
        do_sample=False,
        num_beams=3,    
        repetition_penalty=1.2,
        no_repeat_ngram_size=4,
        early_stopping=True,
    )

# decode
pred = processor.decode(generation[0], skip_special_tokens=True)

print("\n--- Model output ---")
print(pred)Được hỗ trợ bởi

Ví dụ đầu ra từ mô hình pretrained:

--- Model output ---
Use this command to change this image's format:\usepackage[T1]{fontenc}\usepackage[utf8]{inputenc}\DeclareUnicodeUTF8{1234567890123}\begin{document}<tex>$\begin{equation}\begin{aligned}P=&\frac{1+(-)\frac{1}{2}\left(F_{1}(-)\frac{F_{2}(-Được hỗ trợ bởi

Giờ, hãy xem LaTeX ground-truth cho cùng hình ảnh đó.

train_ds[20]["text"]Được hỗ trợ bởi

Ground-truth:

'{ \\cal P } = \\frac { 1 + ( - ) ^ { F } { \\cal I } _ { 4 } ( - ) ^ { F _ { L } } } { 2 } .'Được hỗ trợ bởi

Đúng như dự đoán, mô hình pretrained không tạo ra bản chép LaTeX chính xác. Thay vào đó, nó sinh phần khung LaTeX chung chung và các mảnh không liên quan. Hành vi này là bình thường, vì mô hình gốc chưa được huấn luyện đặc thù cho LaTeX OCR.

5. Xây dựng data collator văn bản–hình ảnh tùy chỉnh

Ở phần này, chúng ta xây dựng một data collator văn bản–hình ảnh tùy chỉnh để gom lô đúng cách hình ảnh, prompt và mục tiêu LaTeX cho fine-tuning. Vì T5Gemma-2 là mô hình encoder–decoder đa phương thức, collator đóng vai trò quan trọng đảm bảo hình ảnh và văn bản được căn chỉnh chính xác và truyền vào mô hình theo định dạng mong đợi.

Cụ thể, collator sẽ:

• Tải hình ảnh từ nhiều định dạng có thể và chuyển về biểu diễn RGB thống nhất
• Đảm bảo mỗi ví dụ huấn luyện chứa đúng một hình ảnh, được bọc trong cấu trúc mà processor mong đợi
• Gắn một prompt hướng dẫn cố định cho mọi hình ảnh để xác định rõ nhiệm vụ OCR
• Tokenize mục tiêu LaTeX riêng với kiểm soát cắt ngắn và padding
• Che token padding trong nhãn để chúng không đóng góp vào loss huấn luyện
• Tránh cắt ngắn phía đầu vào để ngăn lệch giữa hình ảnh và token

Tổng hợp lại, các bước này đảm bảo huấn luyện ổn định, tính toán loss đúng và hội tụ tin cậy khi fine-tune mô hình trên dữ liệu LaTeX OCR.

from typing import Any, Dict, List
import torch
from PIL import Image as PILImage

tokenizer = processor.tokenizer
tokenizer.padding_side = "right"

if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({"pad_token": tokenizer.eos_token})

pad_id = tokenizer.pad_token_id

PROMPT = "<start_of_image> Convert this equation image to LaTeX. Output only LaTeX."
MAX_TARGET_LEN = 256

def collate_fn(examples: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
    images, prompts, targets = [], [], []

    for ex in examples:
        im = ex["image"]
        if isinstance(im, PILImage.Image):
            im = im.convert("RGB")
        elif isinstance(im, dict) and "path" in im:
            im = PILImage.open(im["path"]).convert("RGB")
        else:
            raise ValueError(f"Unexpected image type: {type(im)}")

        # IMPORTANT: one image per sample -> nested list
        images.append([im])

        prompts.append(PROMPT)
        targets.append(ex["text"])

    # ✅ NO truncation here (prevents image-token mismatch)
    model_inputs = processor(
        text=prompts,
        images=images,
        padding=True,
        truncation=False,
        return_tensors="pt",
    )

    labels = tokenizer(
        targets,
        padding=True,
        truncation=True,
        max_length=MAX_TARGET_LEN,
        return_tensors="pt",
    )["input_ids"]

    labels[labels == pad_id] = -100
    model_inputs["labels"] = labels
    return model_inputsĐược hỗ trợ bởi

6. Cấu hình huấn luyện và thiết lập tối ưu hóa

Ở phần này, chúng ta định nghĩa cấu hình huấn luyện và thiết lập tối ưu hóa để fine-tune T5Gemma-2 cho nhiệm vụ LaTeX OCR. Thiết lập được cố ý đơn giản và tối ưu cho huấn luyện nhanh trên một GPU A100, dùng tập dữ liệu nhỏ và một epoch duy nhất. 

Để giảm overhead và tăng tốc, chúng ta tắt đánh giá và lưu checkpoint, tập trung vào các lượt truyền xuôi và ngược hiệu quả.

from transformers import Seq2SeqTrainingArguments

args = Seq2SeqTrainingArguments(
    output_dir="t5gemma2-latex-ocr-1k",

    # --- core training ---
    num_train_epochs=1,
    per_device_train_batch_size=8, 
    gradient_accumulation_steps=1,

    learning_rate=1e-4,
    warmup_steps=15,
    lr_scheduler_type="linear",

    # --- precision / speed ---
    bf16=True,    
    fp16=False,
    tf32=True,     

    # --- memory ---
    gradient_checkpointing=True,

    # --- stop extra work (this is the big speed win) ---
    eval_strategy="no",           
    predict_with_generate=False,          
    save_strategy="no",                 
    report_to="none",

    # --- dataloader ---
    dataloader_num_workers=0,         
    remove_unused_columns=False,

    # --- logging ---
    logging_steps=10,
)Được hỗ trợ bởi

Cuối cùng, khởi tạo Seq2SeqTrainer. Chúng ta truyền rõ data collator tùy chỉnh để trainer có thể dựng các batch đa phương thức đúng cách, kết hợp hình ảnh, prompt hướng dẫn và chuỗi mục tiêu LaTeX trong quá trình huấn luyện.

trainer = Seq2SeqTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    data_collator=collate_fn,
)Được hỗ trợ bởi

7. Fine-tune T5Gemma-2 cho LaTeX OCR

Với mọi thứ đã sẵn sàng, giờ chúng ta có thể bắt đầu fine-tune mô hình. Huấn luyện được khởi chạy bằng một lệnh gọi trainer duy nhất.

trainer.train()Được hỗ trợ bởi

Trong quá trình huấn luyện, loss giảm dần, cho thấy mô hình đang học cách ánh xạ tốt hơn giữa hình ảnh phương trình và biểu diễn LaTeX tương ứng. 

Ngay cả với tập dữ liệu nhỏ và chỉ một epoch, mô hình vẫn bắt đầu thích ứng nhanh với nhiệm vụ OCR.

8. Đánh giá sau khi fine-tune

Sau khi fine-tune, chúng ta chạy lại suy luận trên cả mẫu huấn luyện và mẫu validation để xem đầu ra của mô hình thay đổi thế nào. 

So với baseline vốn chủ yếu sinh khung LaTeX chung chung, mô hình đã fine-tune giờ tạo ra LaTeX có cấu trúc, gần khớp với hình dạng và ký hiệu của phương trình mục tiêu.

Chúng ta bắt đầu bằng cách kiểm tra trên cùng ví dụ huấn luyện như trước. Hình ảnh được truyền qua processor, mô hình sinh token, rồi giải mã về LaTeX.

# pick a sample
image = train_ds[10]["image"]

# prepare inputs
model_inputs = processor(text=PROMPT, images=image, return_tensors="pt")
model_inputs = {k: v.to("cuda") for k, v in model_inputs.items()}

# run inference
model = model.eval()
with torch.inference_mode():
    generation = model.generate(
        **model_inputs,
        max_new_tokens=100,
        do_sample=False,
        num_beams=3,    
        repetition_penalty=1.2,
        no_repeat_ngram_size=4,
        early_stopping=True,
    )

# decode
pred = processor.decode(generation[0], skip_special_tokens=True)
print(pred)Được hỗ trợ bởi

Như bạn thấy, giờ chúng ta nhận được đầu ra LaTeX đúng đắn, không còn ngẫu nhiên hay không liên quan. Ở ví dụ huấn luyện, dự đoán chủ yếu khớp ground truth, lỗi còn lại chủ yếu ở phân số, chỉ số và một vài token đặt sai chỗ.

G ( \beta , \tilde { \mu } ) = \left( \frac { \pi \mu \Gamma } { 2 \Gamma } \lambda _ { + 1 } ^ { \lambda } \right) \right) ^ { \frac { 1 } { 9 \Gamma } g _ { 0 } ( \beta ) g _ { S } ( \theta , Z ) , \right) , \qquad G ( \bar { \Được hỗ trợ bởi

Tiếp theo, chúng ta thử mô hình trên một mẫu validation để kiểm tra khả năng khái quát hóa.

image = val_ds[10]["image"]

# prepare inputs
model_inputs = processor(text=PROMPT, images=image, return_tensors="pt")
model_inputs = {k: v.to("cuda") for k, v in model_inputs.items()}

# run inference
model = model.eval()
with torch.inference_mode():
    generation = model.generate(
        **model_inputs,
        max_new_tokens=100,
        do_sample=False,
        num_beams=3,    
        repetition_penalty=1.2,
        no_repeat_ngram_size=4,
        early_stopping=True,
    )

# decode
pred = processor.decode(generation[0], skip_special_tokens=True)
print(pred)Được hỗ trợ bởi

Ở ví dụ validation, mô hình vẫn tuân theo cấu trúc và ký hiệu LaTeX đúng, dù đôi khi mắc lỗi ở việc đặt ngoặc, các hạng trong dấu ngoặc và các biểu thức dài.

f ( p , p ^ { \prime } ) = \ln \left\{ \frac { ( p _ { i } - p _ { j } ) ^ { 2 } } { \left( \frac { \psi ( p _ j ) - g ( p ; p _ { s } ) \psi ( \psi _ { i ] } ) \right\} . . . g ( \psi ; \psi ) - g \left( p ; \psi _Được hỗ trợ bởi

Khi so với ground truth, cấu trúc tổng thể rõ ràng đã được căn chỉnh, và mô hình đang tạo ra xấp xỉ gần thay vì đầu ra không liên quan.

print(val_ds[10]["text"])Được hỗ trợ bởi

f ( p , p ^ { \prime } ) = \ln \left\{ \frac { ( p _ { i } - p _ { j } ) ^ { 2 } } { ( p _ { i } + p _ { j } ) ^ { 2 } } \right\} \left[ \psi ( p _ { j } ) - g ( p _ { i } , p _ { j } ) \psi ( p _ { i } ) \right] .Được hỗ trợ bởi

Nhìn chung, kết quả sau fine-tune cho thấy cải thiện rõ rệt. Mô hình không còn đoán các mẫu LaTeX chung chung mà thay vào đó sinh LaTeX giống phương trình, gần giống mục tiêu trong tập dữ liệu, ngay cả với tập huấn luyện nhỏ và thời gian fine-tune ngắn.

9. Lưu và xuất bản mô hình T5Gemma-2 đã fine-tune

Khi huấn luyện hoàn tất, bước đầu tiên là lưu mô hình đã fine-tune cục bộ để dùng lại cho suy luận sau này.

trainer.save_model()Được hỗ trợ bởi

Tiếp theo, chúng ta đẩy mô hình lên Hugging Face Hub để người khác có thể truy cập, tái sử dụng và phát triển tiếp.

trainer.push_to_hub()Được hỗ trợ bởi

Khi kiểm tra các tệp trong repository, bạn có thể thấy cấu hình processor không phải lúc nào cũng được bao gồm khi đẩy mô hình qua trainer. 

Vì processor cần thiết để xử lý đúng cả hình ảnh và văn bản, chúng ta đẩy nó riêng để đảm bảo mô hình có thể được tải và sử dụng mà không cần thiết lập bổ sung.

processor.push_to_hub(repo_id="kingabzpro/t5gemma2-latex-ocr-1k")Được hỗ trợ bởi

Với bước này, repository chứa mọi thứ cần thiết để tải mô hình và processor bằng một lệnh gọi. Bạn có thể truy cập kingabzpro/t5gemma2-latex-ocr-1k trên Hugging Face để truy cập mô hình đã fine-tune và bắt đầu dùng cho LaTeX OCR hoặc thử nghiệm thêm.

10. Tải mô hình để suy luận với Pipelines

Giờ mô hình đã fine-tune được xuất bản trên Hugging Face Hub, chúng ta có thể tải trực tiếp để suy luận bằng API pipeline. Đây là cách đơn giản nhất để thử mô hình mà không cần xử lý thủ công processor, tokenizer hay logic sinh.

Chúng ta tải mô hình từ Hub và tạo một pipeline image-text-to-text:

from transformers import pipeline

generator = pipeline(
    "image-text-to-text",
    model="kingabzpro/t5gemma2-latex-ocr-1k",
)Được hỗ trợ bởi

Tiếp theo, chúng ta chạy suy luận trên một mẫu validation với cùng prompt hướng dẫn như trước.

generator(
    val_ds[10]["image"],
    text="<start_of_image> Convert this image to LaTeX. Output only LaTeX.",
    generate_kwargs={"do_sample": False, "max_new_tokens": 100},
)Được hỗ trợ bởi

Như bạn thấy, đầu ra đã rất gần với LaTeX đúng.

[{'input_text': '<start_of_image> Convert this image to LaTeX. Output only LaTeX.',
  'generated_text': '<start_of_image> Convert this image to LaTeX. Output only LaTeX.f ( p , p ^ { \\prime } ) = \\ln \\left\\{ \\begin{array} { \\begin{array} { \\begin{array} { \\begin{array} { \\begin{array} { \\end{array} \\right\\} \\begin{array} { \\begin{array} { \\begin{array} { \\end{array} \\right\\} \\begin{array} { \\begin{array} { \\begin{array} {'}]Được hỗ trợ bởi

Hãy thử một mẫu validation khác và hậu xử lý đầu ra để chỉ giữ chuỗi LaTeX.

preds = generator(
    val_ds[30]["image"],
    text="<start_of_image> Convert this image to LaTeX. Output only LaTeX.",
    generate_kwargs={"do_sample": False, "max_new_tokens": 100},
)

prompt = preds[0]["input_text"]
gen = preds[0]["generated_text"]

# remove the prompt if the model echoed it
if gen.startswith(prompt):
    gen = gen[len(prompt):]

# remove any leftover special tokens / separators
gen = gen.replace("<start_of_image>", "").strip()
if gen.startswith("."):
    gen = gen[1:].strip()

print("\nCLEAN PREDICTED LaTeX:\n", gen)Được hỗ trợ bởi

Lần này, kết quả sạch và có thể dùng trực tiếp như LaTeX:

CLEAN PREDICTED LaTeX:
 T _ { M N } = \left\{ g N \nu \partial _ { M P _ { } } \cdot \left\{ g ^ { N } \nu \partial _ { M P _ { } } \cdot \left\{ g ^ { N } \nu \partial _ { M P _ { } } \cdot \left\{ g ^ { N } \nu \partial _ { M P _ { } } \cdot \left\{ g ^ {Được hỗ trợ bởi

Ở thời điểm này, mô hình có thể dùng như một hệ thống LaTeX OCR sẵn sàng tích hợp. Bạn có thể triển khai sau API, tích hợp vào pipeline xử lý tài liệu, hoặc tiếp tục fine-tune với thêm dữ liệu để tăng độ chính xác.

Nếu bạn gặp vấn đề khi chạy đoạn mã trên, hãy xem notebook hỗ trợ. Notebook chứa đầy đủ mã cùng đầu ra ở mỗi bước để hướng dẫn bạn qua quy trình.

Kết luận

Khi bắt đầu huấn luyện mô hình, tôi đã xem nó giống bất kỳ LLM nào có image encoder. Sau nhiều lần thất bại, tôi nhận ra cách tiếp cận này không hiệu quả với các mô hình sequence-to-sequence, encoder–decoder. 

Tôi phải nghĩ lại toàn bộ thiết lập, bao gồm data collator, trainer và tham số huấn luyện, thậm chí cả cách thực hiện suy luận.

Trong hướng dẫn này, chúng ta đã đi qua quy trình end-to-end để fine-tune T5Gemma-2 cho nhiệm vụ LaTeX OCR, từ thiết lập môi trường và kiểm tra tập dữ liệu đến collate dữ liệu tùy chỉnh, huấn luyện hiệu quả và đánh giá sau huấn luyện. 

Dùng tập dữ liệu nhỏ và một GPU A100, chúng ta cho thấy một mô hình encoder–decoder đa phương thức có thể nhanh chóng học sinh LaTeX có cấu trúc, có ý nghĩa từ hình ảnh phương trình. 

Cuối cùng, mô hình đã fine-tune vượt xa đầu ra khung sườn chung chung và sinh LaTeX giống phương trình, gần khớp ground truth, minh họa mức độ dễ tiếp cận và hiệu quả của việc fine-tune các mô hình mở hiện đại cho các tác vụ OCR và hiểu tài liệu trong thực tế.

Nếu bạn muốn xem thêm các ví dụ thực hành về fine-tune LLM, tôi khuyến nghị xem khóa học Fine-Tuning with Llama 3.