Fine-Tuning T5Gemma-2

T5Gemma 2 adalah keluarga model encoder–decoder ringan dengan bobot terbuka dari Google, dibangun di atas Gemma 3, yang mendukung masukan multibahasa dan multimodal. 

Dengan jendela konteks hingga 128K di lebih dari 140 bahasa dan pilihan desain efisien seperti tied embeddings dan merged attention, model-model ini sangat cocok untuk tugas pemrosesan teks dan pemahaman gambar sekaligus tetap cukup kecil untuk dijalankan di laptop.

Dalam tutorial ini, kita akan mempelajari cara melakukan fine-tuning model encoder–decoder pada dataset LaTeX OCR. Tujuannya adalah mencapai kinerja yang kuat dengan jumlah sampel pelatihan minimal. 

1. Menyiapkan Lingkungan GPU A100 di RunPod

Meskipun memungkinkan untuk melakukan fine-tuning model ini di Kaggle atau Google Colab, hal tersebut sering kali menyebabkan sesi tidak stabil, putusnya sumber daya, dan pelatihan yang jauh lebih lambat. Untuk menghindari friksi tersebut dan menjaga penyiapan tetap sederhana serta andal, kita akan menggunakan GPU NVIDIA A100.

Anda dapat menyewa A100 di RunPod dengan biaya sekitar $1,39 per jam, dan seluruh proses pelatihan dalam tutorial ini seharusnya memakan waktu jauh di bawah 30 menit. Penyiapan ini memberi Anda kinerja yang konsisten tanpa harus berjuang dengan batasan memori.

Mulailah dengan membuka RunPod dan membuat pod baru menggunakan image PyTorch terbaru. Pilih mesin 1× A100.

Selanjutnya, edit konfigurasi pod dan tambahkan variabel lingkungan bernama HF_TOKEN. Token ini diperlukan untuk:

• Memuat model berpagar (gated) dari Hugging Face
• Mendorong (push) model yang telah di-fine-tune kembali ke Hugging Face Hub

Setelah pod siap, luncurkan notebook dan pasang paket-paket Python yang diperlukan. Pastikan Anda menggunakan versi terbaru transformers.

!pip -q install -U accelerate datasets pillow sentencepiece safetensors
!pip install --quiet "transformers==5.0.0rc1"
!pip install --quiet --no-deps trlDidukung oleh

Sekarang, impor pustaka dan utilitas yang akan kita gunakan di seluruh notebook.

import torch
from datasets import load_dataset
from transformers import AutoProcessor, AutoModelForSeq2SeqLM
from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer, set_seedDidukung oleh

Sebelum pelatihan, kita menerapkan beberapa konfigurasi yang dioptimalkan untuk GPU A100. Menetapkan seed memastikan reprodusibilitas, dan mengaktifkan TF32 meningkatkan kinerja tanpa memengaruhi stabilitas pelatihan 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())Didukung oleh

CUDA: True NVIDIA A100 80GB PCIe
bf16 supported: TrueDidukung oleh

2. Prapemrosesan Dataset LaTeX OCR untuk Pelatihan Data Minim

Dalam tutorial ini, kita menggunakan dataset LaTeX OCR yang tersedia di Hugging Face. Setiap contoh dalam dataset terdiri dari:

• sebuah gambar yang berisi ekspresi matematika, dan
• teks sumber LaTeX yang sesuai sebagai keluaran target.

Dataset menyediakan beberapa konfigurasi. Untuk menjaga pelatihan tetap efisien dan selaras dengan tujuan kita belajar dari data terbatas, kita akan mengontrol ukuran dataset secara eksplisit.

Pertama, muat split pelatihan dan validasi. Untuk mensimulasikan skenario fine-tuning dengan data sedikit, kita mengacak dataset secara acak dan memilih subset kecil:

• 1.000 sampel untuk pelatihan
• 200 sampel untuk validasi

Ini menjaga pelatihan tetap cepat sambil tetap memungkinkan model melakukan generalisasi.

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)Didukung oleh

Keluaran:

Dataset({
    features: ['image', 'text'],
    num_rows: 1000
}) Dataset({
    features: ['image', 'text'],
    num_rows: 200
})
Columns: ['image', 'text']Didukung oleh

Untuk lebih memahami data, mari lihat satu contoh pelatihan. Pertama, periksa gambarnya.

train_ds[10]["image"]Didukung oleh

Berikutnya, periksa string LaTeX mentah yang terkait dengan gambar tersebut.

train_ds[10]["text"]Didukung oleh

'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 ) ,'Didukung oleh

Terakhir, kita dapat merender ekspresi LaTeX ini langsung di notebook untuk memverifikasi bahwa teks sesuai dengan konten gambar.

from IPython.display import display, Math, Latex

latex = train_ds[10]["text"]
display(Math(latex))Didukung oleh

3. Inisialisasi Encoder–Decoder Multimodal T5Gemma-2

Setelah dataset siap, langkah berikutnya adalah memuat model T5Gemma-2 dan prosesor yang sesuai. Kita akan menggunakan varian 270M–270M, yang memberikan keseimbangan kuat antara kapabilitas dan efisiensi, serta muat dengan nyaman pada GPU konsumen.

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",
)Didukung oleh

Tokenizer diakses melalui prosesor. Beberapa model encoder–decoder tidak mendefinisikan token padding secara bawaan, jadi kita menambahkannya jika perlu dan mengubah ukuran embedding token model sesuai.

tokenizer = processor.tokenizer
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({"pad_token": tokenizer.eos_token})
    model.resize_token_embeddings(len(tokenizer))Didukung oleh

Untuk LaTeX OCR, kita membimbing model menggunakan prompt tekstual singkat yang dipasangkan dengan gambar masukan. Prompt ini secara jelas menentukan tugas dan membatasi format keluaran.

Terakhir, kita mendefinisikan panjang urutan maksimum untuk masukan encoder dan target decoder. Nilai-nilai ini cukup untuk sebagian besar ekspresi matematika sambil menjaga penggunaan memori tetap terkendali.

PROMPT = "<start_of_image> Convert this image to LaTeX. Output only LaTeX."
MAX_INPUT_LEN  = 128
MAX_TARGET_LEN = 256Didukung oleh

4. Menjalankan Inferensi Baseline: Pemeriksaan Performa Zero-Shot

Sebelum memulai fine-tuning, ada baiknya menjalankan inferensi baseline menggunakan model T5Gemma-2 pralatih. Ini membantu kita memahami bagaimana model berperilaku pada tugas LaTeX OCR tanpa pelatihan khusus tugas dan memberi titik acuan untuk peningkatan selanjutnya.

Berikut garis besar prosesnya secara ringkas:

1. Pilih satu gambar sampel dari dataset pelatihan.
2. Siapkan masukan model dengan menggabungkan gambar dan prompt tekstual ke dalam format tensor yang diperlukan.
3. Jalankan inferensi dalam mode evaluasi dengan komputasi gradien dinonaktifkan untuk menghemat memori dan meningkatkan kecepatan generasi.
4. Gunakan beam search dengan jumlah beam terbatas dan penalti pengulangan ringan untuk keluaran yang lebih bersih.
5. Decode token yang dihasilkan kembali menjadi teks setelah proses selesai.

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)Didukung oleh

Contoh keluaran dari model pralatih:

--- 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}(-Didukung oleh

Sekarang, mari lihat LaTeX ground-truth untuk gambar yang sama.

train_ds[20]["text"]Didukung oleh

Ground-truth:

'{ \\cal P } = \\frac { 1 + ( - ) ^ { F } { \\cal I } _ { 4 } ( - ) ^ { F _ { L } } } { 2 } .'Didukung oleh

Seperti yang diharapkan, model pralatih tidak menghasilkan transkripsi LaTeX yang benar. Alih-alih, ia menghasilkan boilerplate LaTeX umum dan potongan yang tidak terkait. Perilaku ini normal, karena model dasar belum dilatih khusus untuk LaTeX OCR.

5. Membangun Data Collator Kustom Gambar-Teks

Di bagian ini, kita membangun data collator kustom gambar–teks untuk membentuk batch gambar, prompt, dan target LaTeX secara benar untuk fine-tuning. Karena T5Gemma-2 adalah model encoder–decoder multimodal, collator berperan penting untuk memastikan gambar dan teks selaras dengan benar dan diteruskan ke model dalam format yang diharapkan.

Secara khusus, collator ini:

• Memuat gambar dari berbagai format yang mungkin dan mengonversinya ke representasi RGB yang konsisten
• Memastikan setiap contoh pelatihan berisi tepat satu gambar, dibungkus dalam struktur yang diharapkan oleh prosesor
• Melampirkan prompt instruksi tetap ke setiap gambar untuk mendefinisikan tugas OCR dengan jelas
• Melakukan tokenisasi target LaTeX secara terpisah dengan pemangkasan dan padding terkontrol
• Memasker token padding pada label agar tidak berkontribusi pada loss pelatihan
• Menghindari pemangkasan pada sisi masukan untuk mencegah ketidakcocokan gambar–token

Bersama-sama, langkah-langkah ini memastikan pelatihan stabil, perhitungan loss yang benar, dan konvergensi yang andal saat melakukan fine-tuning model pada data 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_inputsDidukung oleh

6. Konfigurasi Pelatihan dan Pengaturan Optimasi

Di bagian ini, kita mendefinisikan konfigurasi pelatihan dan pengaturan optimasi untuk fine-tuning T5Gemma-2 pada tugas LaTeX OCR. Penyiapan ini sengaja dibuat sederhana dan dioptimalkan untuk pelatihan cepat pada satu GPU A100, menggunakan dataset kecil dan satu epoch pelatihan. 

Untuk mengurangi overhead dan mempercepat proses, kita menonaktifkan evaluasi dan penyimpanan checkpoint serta fokus hanya pada forward dan backward pass yang efisien.

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,
)Didukung oleh

Terakhir, kita inisialisasi Seq2SeqTrainer. Kita secara eksplisit meneruskan data collator kustom sehingga trainer dapat membentuk batch multimodal yang menggabungkan gambar, prompt instruksi, dan urutan target LaTeX dengan benar selama pelatihan.

trainer = Seq2SeqTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    data_collator=collate_fn,
)Didukung oleh

7. Fine-Tuning T5Gemma-2 pada LaTeX OCR

Dengan semua penyiapan selesai, kini kita dapat memulai fine-tuning model. Pelatihan dijalankan dengan satu pemanggilan trainer.

trainer.train()Didukung oleh

Selama pelatihan, loss menurun secara bertahap, menunjukkan bahwa model belajar memetakan gambar persamaan ke representasi LaTeX yang sesuai. 

Bahkan dengan dataset kecil dan hanya satu epoch, model mulai beradaptasi cepat dengan tugas OCR.

8. Evaluasi Setelah Fine-Tuning

Setelah fine-tuning, kita menjalankan kembali inferensi pada sampel pelatihan dan sampel validasi untuk melihat bagaimana keluaran model berubah. 

Dibandingkan baseline, yang sebagian besar menghasilkan boilerplate LaTeX generik, model yang telah di-fine-tune kini menghasilkan LaTeX terstruktur yang sangat mendekati bentuk dan simbol dari persamaan target.

Kita mulai dengan menguji pada contoh pelatihan yang sama seperti sebelumnya. Gambar dilewatkan melalui prosesor, token dihasilkan oleh model, lalu didekode kembali menjadi 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)Didukung oleh

Seperti yang Anda lihat, kini kita mendapatkan keluaran LaTeX yang semestinya, bukan teks acak atau tidak terkait. Pada contoh pelatihan, prediksi sebagian besar selaras dengan ground-truth, dengan sisa kesalahan terutama pada pecahan, indeks, dan beberapa token yang salah tempat.

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 { \Didukung oleh

Berikutnya, kita uji model pada sampel validasi untuk memeriksa generalisasi.

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)Didukung oleh

Pada contoh validasi, model masih mengikuti struktur dan simbol LaTeX yang benar, meskipun sesekali membuat kesalahan pada penempatan kurung, istilah dalam tanda kurung, dan ekspresi yang lebih panjang.

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 _Didukung oleh

Jika dibandingkan dengan ground-truth, struktur keseluruhan jelas selaras, dan model menghasilkan pendekatan yang dekat alih-alih keluaran yang tidak terkait.

print(val_ds[10]["text"])Didukung oleh

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] .Didukung oleh

Secara keseluruhan, hasil pasca fine-tuning menunjukkan peningkatan yang jelas. Model tidak lagi menebak template LaTeX generik dan sebagai gantinya menghasilkan LaTeX mirip persamaan yang sangat menyerupai target dataset, bahkan dengan set pelatihan kecil dan durasi fine-tuning singkat.

9. Menyimpan dan Mempublikasikan Model T5Gemma-2 yang Telah Di-Fine-Tune

Setelah pelatihan selesai, langkah pertama adalah menyimpan model yang telah di-fine-tune secara lokal agar dapat digunakan kembali nanti untuk inferensi.

trainer.save_model()Didukung oleh

Berikutnya, kita dorong model ke Hugging Face Hub agar orang lain dapat mengaksesnya, menggunakannya kembali, dan membangunnya lebih lanjut.

trainer.push_to_hub()Didukung oleh

Saat memeriksa berkas repositori, Anda mungkin melihat bahwa konfigurasi prosesor tidak selalu disertakan saat mendorong model melalui trainer. 

Karena prosesor diperlukan untuk menangani gambar dan teks dengan benar, kita secara eksplisit mendorongnya secara terpisah untuk memastikan model dapat dimuat dan digunakan tanpa penyiapan tambahan.

processor.push_to_hub(repo_id="kingabzpro/t5gemma2-latex-ocr-1k")Didukung oleh

Dengan langkah ini, repositori berisi semua yang diperlukan untuk memuat model dan prosesor dengan satu pemanggilan. Anda kini dapat mengunjungi kingabzpro/t5gemma2-latex-ocr-1k di Hugging Face untuk mengakses model yang telah di-fine-tune dan mulai menggunakannya untuk LaTeX OCR atau eksperimen lebih lanjut.

10. Memuat Model untuk Inferensi dengan Pipelines

Kini model yang telah di-fine-tune dipublikasikan di Hugging Face Hub, kita dapat memuatnya langsung untuk inferensi menggunakan API pipeline. Ini cara paling sederhana untuk menguji model tanpa perlu menangani prosesor, tokenizer, atau logika generasi secara manual.

Kita memuat model dari Hub dan membuat pipeline image-text-to-text:

from transformers import pipeline

generator = pipeline(
    "image-text-to-text",
    model="kingabzpro/t5gemma2-latex-ocr-1k",
)Didukung oleh

Berikutnya, kita jalankan inferensi pada sampel validasi menggunakan prompt instruksi yang sama seperti sebelumnya.

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},
)Didukung oleh

Seperti yang Anda lihat, keluarannya sudah sangat dekat dengan LaTeX yang benar.

[{'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} {'}]Didukung oleh

Mari coba sampel validasi lain dan pascaproses keluaran untuk menyisakan hanya string 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)Didukung oleh

Kali ini, hasilnya bersih dan dapat langsung digunakan sebagai 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 ^ {Didukung oleh

Pada titik ini, model dapat digunakan sebagai sistem LaTeX OCR siap pakai. Anda dapat menerapkannya di balik API, mengintegrasikannya ke dalam pipeline pemrosesan dokumen, atau melanjutkan fine-tuning dengan lebih banyak data untuk akurasi yang lebih baik lagi.

Jika Anda mengalami masalah saat menjalankan kode di atas, silakan lihat notebook pembantu. Di dalamnya terdapat kode lengkap beserta keluaran di setiap langkah untuk memandu Anda melalui prosesnya.

Kesimpulan

Saat mulai melatih model, saya memperlakukannya seperti model bahasa besar dengan encoder gambar. Setelah beberapa kali gagal, saya menyadari pendekatan ini tidak cocok untuk model sequence-to-sequence, encoder–decoder. 

Saya harus memikirkan ulang seluruh penyiapan, termasuk data collator, trainer, dan argumen pelatihan, bahkan cara melakukan inferensi.

Dalam tutorial ini, kita menelusuri alur kerja end-to-end untuk fine-tuning T5Gemma-2 pada tugas LaTeX OCR, mulai dari penyiapan lingkungan dan inspeksi dataset hingga kolasi data kustom, pelatihan efisien, dan evaluasi pascapelatihan. 

Dengan menggunakan dataset kecil dan satu GPU A100, kami menunjukkan bahwa model multimodal encoder–decoder dapat dengan cepat belajar menghasilkan LaTeX yang terstruktur dan bermakna dari gambar persamaan. 

Pada akhirnya, model yang telah di-fine-tune bergerak jauh melampaui keluaran boilerplate generik dan menghasilkan LaTeX mirip persamaan yang sangat sesuai dengan ground-truth, menunjukkan betapa mudah diakses dan efektifnya fine-tuning model terbuka modern untuk tugas OCR dan pemahaman dokumen di dunia nyata.

Jika Anda mencari lebih banyak contoh praktis fine-tuning LLM, saya sarankan melihat kursus Fine-Tuning with Llama 3.