T5Gemma-2 का फाइन-ट्यूनिंग

T5Gemma 2, Google की ओर से हल्के, ओपन-वेट एन्कोडर–डिकोडर मॉडल का एक परिवार है, जो Gemma 3 पर आधारित है और बहुभाषी व मल्टीमोडल इनपुट का समर्थन करता है। 

140+ भाषाओं में 128K तक के कॉन्टेक्स्ट विंडो और टाइड एम्बेडिंग्स तथा मर्ज्ड अटेंशन जैसे पैरामीटर-कुशल डिज़ाइन विकल्पों के साथ, ये मॉडल टेक्स्ट जेनरेशन और छवि समझने के कार्यों के लिए उपयुक्त हैं, जबकि इतने छोटे हैं कि लैपटॉप पर भी चल सकें।

इस ट्यूटोरियल में, हम LaTeX OCR डेटासेट पर एक एन्कोडर–डिकोडर मॉडल का फाइन-ट्यूनिंग करना सीखेंगे। लक्ष्य है कि बहुत कम ट्रेनिंग सैंपल के साथ भी अच्छा प्रदर्शन प्राप्त किया जा सके। 

1. RunPod पर A100 GPU परिवेश सेट करना

हालांकि इस मॉडल को Kaggle या Google Colab पर फाइन-ट्यून करना संभव है, लेकिन अक्सर इससे अस्थिर सेशन, संसाधनों का डिसकनेक्ट होना और बहुत धीमी ट्रेनिंग जैसी समस्याएं आती हैं। इन मुश्किलों से बचने और सेटअप को सरल व भरोसेमंद रखने के लिए, हम NVIDIA A100 GPU का उपयोग करेंगे।

आप RunPod पर A100 को लगभग $1.39 प्रति घंटा में किराये पर ले सकते हैं, और इस ट्यूटोरियल में पूरी ट्रेनिंग प्रक्रिया को 30 मिनट से कम समय लगना चाहिए। यह सेटअप आपको मेमोरी सीमाओं से लड़ने के बिना स्थिर प्रदर्शन देता है।

शुरू करने के लिए RunPod पर जाएं और नवीनतम PyTorch इमेज के साथ एक नया पॉड बनाएं। एक 1× A100 मशीन चुनें।

इसके बाद, पॉड कॉन्फ़िगरेशन एडिट करें और HF_TOKEN नाम का एक एनवायरनमेंट वेरिएबल जोड़ें। यह टोकन आवश्यक है:

• Hugging Face से गेटेड मॉडल लोड करने के लिए
• अपने फाइन-ट्यून किए गए मॉडल को Hugging Face Hub पर पुश करने के लिए

पॉड तैयार होते ही, नोटबुक लॉन्च करें और आवश्यक Python पैकेज इंस्टॉल करें। सुनिश्चित करें कि आप transformers का नवीनतम संस्करण उपयोग कर रहे हैं।

!pip -q install -U accelerate datasets pillow sentencepiece safetensors
!pip install --quiet "transformers==5.0.0rc1"
!pip install --quiet --no-deps trlसंचालित द्वारा

अब, उन लाइब्रेरीज़ और यूटिलिटीज़ को इम्पोर्ट करें जिनका उपयोग हम पूरे नोटबुक में करेंगे।

import torch
from datasets import load_dataset
from transformers import AutoProcessor, AutoModelForSeq2SeqLM
from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer, set_seedसंचालित द्वारा

ट्रेनिंग से पहले, हम A100 GPUs के लिए अनुकूलित कुछ कॉन्फ़िगरेशन लागू करते हैं। सीड सेट करना पुनरुत्पादन सुनिश्चित करता है, और TF32 सक्षम करना प्रदर्शन में सुधार करता है, बिना 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())संचालित द्वारा

CUDA: True NVIDIA A100 80GB PCIe
bf16 supported: Trueसंचालित द्वारा

2. लो-डेटा ट्रेनिंग के लिए LaTeX OCR डेटासेट का प्रीप्रोसेसिंग

इस ट्यूटोरियल में, हम Hugging Face पर उपलब्ध LaTeX OCR डेटासेट का उपयोग करते हैं। डेटासेट के प्रत्येक उदाहरण में शामिल है:

• एक छवि जिसमें गणितीय अभिव्यक्ति है, और
• इसके अनुरूप LaTeX सोर्स टेक्स्ट लक्ष्य आउटपुट के रूप में।

डेटासेट कई कॉन्फ़िगरेशन देता है। ट्रेनिंग को कुशल रखने और सीमित डेटा से सीखने के हमारे लक्ष्य के अनुरूप, हम डेटासेट आकार पर स्पष्ट रूप से नियंत्रण रखेंगे।

सबसे पहले, ट्रेनिंग और वैलिडेशन स्प्लिट लोड करें। लो-डेटा फाइन-ट्यूनिंग परिदृश्य को सिम्युलेट करने के लिए, हम डेटासेट को रैंडमली शफल करते हैं और एक छोटा सबसेट चुनते हैं:

• 1,000 सैंपल ट्रेनिंग के लिए
• 200 सैंपल वैलिडेशन के लिए

इससे ट्रेनिंग तेज रहती है, फिर भी मॉडल जनरलाइज़ करना सीखता है।

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)संचालित द्वारा

आउटपुट:

Dataset({
    features: ['image', 'text'],
    num_rows: 1000
}) Dataset({
    features: ['image', 'text'],
    num_rows: 200
})
Columns: ['image', 'text']संचालित द्वारा

डेटा को बेहतर समझने के लिए, एक ट्रेनिंग उदाहरण देखें। पहले, छवि देखें।

train_ds[10]["image"]संचालित द्वारा

इसके बाद, उस छवि से जुड़े कच्चे LaTeX स्ट्रिंग की जाँच करें।

train_ds[10]["text"]संचालित द्वारा

'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 ) ,'संचालित द्वारा

अंत में, हम इस LaTeX अभिव्यक्ति को सीधे नोटबुक में रेंडर कर सकते हैं ताकि यह सत्यापित हो सके कि टेक्स्ट छवि सामग्री से मेल खाता है।

from IPython.display import display, Math, Latex

latex = train_ds[10]["text"]
display(Math(latex))संचालित द्वारा

3. T5Gemma-2 मल्टीमोडल एन्कोडर–डिकोडर को इनिशियलाइज़ करना

अब जब डेटासेट तैयार है, अगला चरण T5Gemma-2 मॉडल और उसके अनुरूप प्रोसेसर को लोड करना है। हम 270M–270M वैरिएंट का उपयोग करेंगे, जो क्षमता और दक्षता के बीच अच्छा संतुलन देता है और उपभोक्ता GPU पर आराम से फिट हो जाता है।

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",
)संचालित द्वारा

टोकनाइज़र को प्रोसेसर के माध्यम से एक्सेस किया जाता है। कुछ एन्कोडर–डिकोडर मॉडल डिफ़ॉल्ट रूप से पैडिंग टोकन परिभाषित नहीं करते, इसलिए आवश्यक होने पर हम एक जोड़ते हैं और मॉडल की टोकन एम्बेडिंग्स का आकार उसी अनुसार बदलते हैं।

tokenizer = processor.tokenizer
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({"pad_token": tokenizer.eos_token})
    model.resize_token_embeddings(len(tokenizer))संचालित द्वारा

LaTeX OCR के लिए, हम इनपुट छवि के साथ एक छोटा पाठ्य प्रॉम्प्ट देकर मॉडल को गाइड करते हैं। यह प्रॉम्प्ट कार्य को स्पष्ट रूप से निर्दिष्ट करता है और आउटपुट फ़ॉर्मैट को सीमित करता है।

अंत में, हम एन्कोडर इनपुट और डिकोडर टार्गेट के लिए अधिकतम अनुक्रम लंबाइयाँ परिभाषित करते हैं। ये मान अधिकांश गणितीय अभिव्यक्तियों के लिए पर्याप्त हैं और मेमोरी उपयोग को नियंत्रित रखते हैं।

PROMPT = "<start_of_image> Convert this image to LaTeX. Output only LaTeX."
MAX_INPUT_LEN  = 128
MAX_TARGET_LEN = 256संचालित द्वारा

4. बेसलाइन इन्फरेंस चलाना: ज़ीरो-शॉट प्रदर्शन जाँच

फाइन-ट्यूनिंग शुरू करने से पहले, प्रीट्रेंड T5Gemma-2 मॉडल का उपयोग करके बेसलाइन इन्फरेंस चलाना उपयोगी होता है। यह हमें यह समझने में मदद करता है कि मॉडल LaTeX OCR कार्य पर बिना किसी कार्य-विशिष्ट ट्रेनिंग के कैसे व्यवहार करता है, और बाद के सुधारों के लिए एक संदर्भ बिंदु देता है।

प्रक्रिया का एक संक्षिप्त खाका इस प्रकार है:

1. ट्रेनिंग डेटासेट से एक सैंपल छवि चुनें।
2. मॉडल इनपुट तैयार करें—छवि और टेक्स्ट प्रॉम्प्ट को आवश्यक टेंसर फ़ॉर्मैट में संयोजित करें।
3. मेमोरी बचाने और जेनरेशन की गति बढ़ाने के लिए, ग्रेडिएंट गणना अक्षम करके इवैल्यूएशन मोड में इन्फरेंस चलाएं।
4. क्लीनर आउटपुट के लिए सीमित बीम और हल्के रिपीटिशन पेनल्टी के साथ बीम सर्च का उपयोग करें।
5. प्रक्रिया पूरी होने पर जेनरेटेड टोकन को फिर से टेक्स्ट में डिकोड करें।

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)संचालित द्वारा

प्रीट्रेंड मॉडल से उदाहरण आउटपुट:

--- 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}(-संचालित द्वारा

अब, उसी छवि के लिए ग्राउंड-ट्रुथ LaTeX देखें।

train_ds[20]["text"]संचालित द्वारा

ग्राउंड-ट्रुथ:

'{ \\cal P } = \\frac { 1 + ( - ) ^ { F } { \\cal I } _ { 4 } ( - ) ^ { F _ { L } } } { 2 } .'संचालित द्वारा

अपेक्षा के अनुरूप, प्रीट्रेंड मॉडल सही LaTeX ट्रांसक्रिप्शन उत्पन्न नहीं करता। इसके बजाय, यह सामान्य LaTeX बोइलरप्लेट और असंबंधित टुकड़े बनाता है। यह व्यवहार सामान्य है, क्योंकि बेस मॉडल को विशेष रूप से LaTeX OCR के लिए प्रशिक्षित नहीं किया गया है।

5. कस्टम इमेज-टेक्स्ट डेटा कोलेटर बनाना

इस खंड में, हम फाइन-ट्यूनिंग के लिए छवियों, प्रॉम्प्ट और LaTeX टार्गेट्स को सही तरीके से बैच करने हेतु एक कस्टम इमेज–टेक्स्ट डेटा कोलेटर बनाते हैं। चूंकि T5Gemma-2 एक मल्टीमोडल एन्कोडर–डिकोडर मॉडल है, इसलिए कोलेटर यह सुनिश्चित करने में महत्वपूर्ण भूमिका निभाता है कि छवियाँ और टेक्स्ट सही ढंग से संरेखित हों और अपेक्षित फ़ॉर्मैट में मॉडल को पास हों।

विशेष रूप से, कोलेटर:

• विभिन्न संभावित फ़ॉर्मैट से छवियाँ लोड करता है और उन्हें एकसमान RGB प्रतिनिधित्व में बदलता है
• यह सुनिश्चित करता है कि प्रत्येक ट्रेनिंग उदाहरण में ठीक एक छवि हो, जिसे प्रोसेसर द्वारा अपेक्षित संरचना में रैप किया गया हो
• OCR कार्य को स्पष्ट रूप से परिभाषित करने के लिए हर छवि से एक फिक्स्ड इंस्ट्रक्शन प्रॉम्प्ट जोड़ता है
• LaTeX टार्गेट्स को नियंत्रित ट्रंकेशन और पैडिंग के साथ अलग से टोकनाइज़ करता है
• लेबल्स में पैडिंग टोकन को मास्क करता है ताकि वे ट्रेनिंग लॉस में योगदान न दें
• इनपुट साइड पर ट्रंकेशन से बचता है ताकि छवि–टोकन मिसमैच न हों

मिलकर, ये चरण 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संचालित द्वारा

6. ट्रेनिंग कॉन्फ़िगरेशन और ऑप्टिमाइज़ेशन सेटिंग्स

इस खंड में, हम LaTeX OCR कार्य पर T5Gemma-2 को फाइन-ट्यून करने के लिए ट्रेनिंग कॉन्फ़िगरेशन और ऑप्टिमाइज़ेशन सेटिंग्स परिभाषित करते हैं। सेटअप जानबूझकर सरल रखा गया है और एक छोटे डेटासेट तथा एकल ट्रेनिंग ईपोक के साथ, एकल A100 GPU पर तेज ट्रेनिंग के लिए अनुकूलित है। 

ओवरहेड कम करने और गति बढ़ाने के लिए, हम इवैल्यूएशन और चेकपॉइंट सेविंग को अक्षम करते हैं और केवल कुशल फॉरवर्ड और बैकवर्ड पास पर ध्यान केंद्रित करते हैं।

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,
)संचालित द्वारा

अंत में, हम Seq2SeqTrainer इनिशियलाइज़ करते हैं। हम स्पष्ट रूप से अपने कस्टम डेटा कोलेटर को पास करते हैं ताकि ट्रेनर ट्रेनिंग के दौरान छवियों, इंस्ट्रक्शन प्रॉम्प्ट और LaTeX टार्गेट सीक्वेंस को मिलाकर मल्टीमोडल बैच सही ढंग से बना सके।

trainer = Seq2SeqTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    data_collator=collate_fn,
)संचालित द्वारा

7. LaTeX OCR पर T5Gemma-2 का फाइन-ट्यूनिंग

सब कुछ सेट होने के साथ, अब हम मॉडल का फाइन-ट्यूनिंग शुरू कर सकते हैं। ट्रेनिंग, ट्रेनर को एकल कॉल से लॉन्च होती है।

trainer.train()संचालित द्वारा

ट्रेनिंग के दौरान, लॉस धीरे-धीरे घटता है, जो इंगित करता है कि मॉडल समीकरण छवियों को उनके अनुरूप LaTeX प्रतिनिधित्व से बेहतर मैप करना सीख रहा है। 

छोटे डेटासेट और केवल एक ईपोक के साथ भी, मॉडल OCR कार्य के लिए तेज़ी से अनुकूल होना शुरू कर देता है।

8. फाइन-ट्यूनिंग के बाद मूल्यांकन

फाइन-ट्यूनिंग के बाद, हम एक ट्रेनिंग सैंपल और एक वैलिडेशन सैंपल पर इन्फरेंस फिर से चलाते हैं ताकि देखें कि मॉडल के आउटपुट कैसे बदले हैं। 

बेसलाइन की तुलना में, जो ज्यादातर सामान्य LaTeX बोइलरप्लेट बनाता था, फाइन-ट्यून किया गया मॉडल अब संरचित LaTeX जनरेट करता है जो लक्ष्य समीकरणों के आकार और प्रतीकों से काफ़ी मेल खाता है।

हम पहले की ही तरह उसी ट्रेनिंग उदाहरण पर टेस्ट करके शुरू करते हैं। छवि को प्रोसेसर से पास किया जाता है, मॉडल द्वारा टोकन जेनरेट किए जाते हैं, और फिर 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)संचालित द्वारा

जैसा कि आप देख सकते हैं, अब हमें सही LaTeX आउटपुट मिलता है, न कि रैंडम या असंबंधित टेक्स्ट। ट्रेनिंग उदाहरण में, प्रेडिक्शन काफी हद तक ग्राउंड ट्रुथ से संरेखित है; शेष त्रुटियाँ मुख्यतः भिन्नों, इंडिसेज़ और कुछ गलत जगह पड़े टोकन में हैं।

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 { \संचालित द्वारा

इसके बाद, हम जनरलाइज़ेशन जाँचने के लिए मॉडल को एक वैलिडेशन सैंपल पर टेस्ट करते हैं।

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)संचालित द्वारा

वैलिडेशन उदाहरण में, मॉडल अब भी सही LaTeX संरचना और प्रतीकों का पालन करता है, हालांकि कभी-कभी ब्रैकेट प्लेसमेंट, ब्रैकेट के अंदर के टर्म्स और लंबी अभिव्यक्तियों में गलती कर देता है।

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 _संचालित द्वारा

ग्राउंड ट्रुथ से तुलना करने पर, समग्र संरचना स्पष्ट रूप से संरेखित है, और मॉडल असंबंधित आउटपुट के बजाय क़रीबी सरलीकरण दे रहा है।

print(val_ds[10]["text"])संचालित द्वारा

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] .संचालित द्वारा

कुल मिलाकर, फाइन-ट्यूनिंग के बाद के परिणाम स्पष्ट सुधार दिखाते हैं। मॉडल अब सामान्य LaTeX टेम्पलेट्स का अनुमान नहीं लगा रहा, बल्कि समीकरण-सदृश LaTeX बना रहा है जो छोटे ट्रेनिंग सेट और कम समय की फाइन-ट्यूनिंग के बावजूद डेटासेट टार्गेट्स से काफ़ी मेल खाता है।

9. फाइन-ट्यून किए गए T5Gemma-2 मॉडल को सहेजना और प्रकाशित करना

ट्रेनिंग पूरी होने पर, पहला चरण फाइन-ट्यून किए गए मॉडल को लोकली सेव करना है ताकि बाद में इन्फरेंस के लिए पुन: उपयोग किया जा सके।

trainer.save_model()संचालित द्वारा

इसके बाद, हम मॉडल को Hugging Face Hub पर पुश करते हैं ताकि अन्य लोग इसे एक्सेस कर सकें, पुन: उपयोग कर सकें और इसके ऊपर निर्माण कर सकें।

trainer.push_to_hub()संचालित द्वारा

रिपोजिटरी फ़ाइलों का निरीक्षण करते समय, आप देख सकते हैं कि ट्रेनर के माध्यम से मॉडल पुश करने पर प्रोसेसर कॉन्फ़िगरेशन हमेशा शामिल नहीं होता। 

चूंकि प्रोसेसर छवियों और टेक्स्ट दोनों को सही ढंग से हैंडल करने के लिए आवश्यक है, हम इसे अलग से स्पष्ट रूप से पुश करते हैं ताकि मॉडल अतिरिक्त सेटअप के बिना लोड और उपयोग किया जा सके।

processor.push_to_hub(repo_id="kingabzpro/t5gemma2-latex-ocr-1k")संचालित द्वारा

इस चरण के साथ, रिपोजिटरी में वह सब कुछ है जो एक ही कॉल से मॉडल और प्रोसेसर को लोड करने के लिए आवश्यक है। अब आप Hugging Face पर kingabzpro/t5gemma2-latex-ocr-1k पर जाकर फाइन-ट्यून किए गए मॉडल तक पहुँच सकते हैं और LaTeX OCR या आगे के प्रयोगों के लिए इसका उपयोग शुरू कर सकते हैं।

10. Pipelines के साथ इन्फरेंस हेतु मॉडल लोड करना

अब जब फाइन-ट्यून किया गया मॉडल Hugging Face Hub पर प्रकाशित है, हम इसे pipeline API का उपयोग करके सीधे इन्फरेंस के लिए लोड कर सकते हैं। यह प्रोसेसर, टोकनाइज़र या जेनरेशन लॉजिक को मैन्युअली संभाले बिना मॉडल को टेस्ट करने का सबसे सरल तरीका है।

हम Hub से मॉडल लोड करते हैं और एक image-text-to-text पाइपलाइन बनाते हैं:

from transformers import pipeline

generator = pipeline(
    "image-text-to-text",
    model="kingabzpro/t5gemma2-latex-ocr-1k",
)संचालित द्वारा

इसके बाद, हम पहले की ही तरह उसी इंस्ट्रक्शन प्रॉम्प्ट का उपयोग करके वैलिडेशन सैंपल पर इन्फरेंस चलाते हैं।

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},
)संचालित द्वारा

जैसा कि आप देख सकते हैं, आउटपुट पहले से ही सही LaTeX के बहुत क़रीब है।

[{'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} {'}]संचालित द्वारा

आइए एक और वैलिडेशन सैंपल आज़माते हैं और आउटपुट को पोस्ट-प्रोसेस करके केवल 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)संचालित द्वारा

इस बार, परिणाम क्लीन है और सीधे 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 ^ {संचालित द्वारा

इस बिंदु पर, मॉडल को एक ड्रॉप-इन LaTeX OCR सिस्टम के रूप में उपयोग किया जा सकता है। आप इसे किसी API के पीछे डिप्लॉय कर सकते हैं, इसे किसी दस्तावेज़ प्रोसेसिंग पाइपलाइन में एकीकृत कर सकते हैं, या और भी बेहतर सटीकता के लिए अधिक डेटा के साथ फाइन-ट्यूनिंग जारी रख सकते हैं।

यदि ऊपर का कोड चलाते समय आपको किसी समस्या का सामना करना पड़े, तो कृपया हेल्पर नोटबुक देखें। इसमें प्रत्येक चरण के कोड के साथ आउटपुट शामिल हैं जो आपको प्रक्रिया के माध्यम से मार्गदर्शन करेंगे।

निष्कर्ष

जब मैंने मॉडल को ट्रेन करना शुरू किया, तो मैंने इसे किसी भी बड़े भाषा मॉडल जैसा ही माना जिसमें इमेज एन्कोडर हो। कई बार असफल होने के बाद मुझे एहसास हुआ कि सीक्वेंस-टू-सीक्वेंस, एन्कोडर–डिकोडर मॉडल के लिए यह तरीका काम नहीं करता। 

मुझे पूरे सेटअप पर फिर से विचार करना पड़ा—डेटा कोलेटर, ट्रेनर और ट्रेनिंग आर्ग्युमेंट्स से लेकर इन्फरेंस कैसे किया जाता है, तक।

इस ट्यूटोरियल में, हमने T5Gemma-2 को LaTeX OCR कार्य पर फाइन-ट्यून करने के लिए एंड-टू-एंड वर्कफ़्लो देखा—पर्यावरण सेटअप और डेटासेट निरीक्षण से लेकर कस्टम डेटा कोलेशन, कुशल ट्रेनिंग और पोस्ट-ट्रेनिंग मूल्यांकन तक। 

एक छोटे डेटासेट और एकल A100 GPU का उपयोग करके, हमने दिखाया कि एक एन्कोडर–डिकोडर मल्टीमोडल मॉडल समीकरण छवियों से संरचित, अर्थपूर्ण LaTeX जल्दी सीख सकता है। 

अंत तक, फाइन-ट्यून किया गया मॉडल सामान्य बोइलरप्लेट आउटपुट से काफी आगे निकल गया और ग्राउंड ट्रुथ से क़रीबी मेल खाने वाला समीकरण-सदृश LaTeX उत्पन्न किया, यह दर्शाते हुए कि वास्तविक दुनिया के OCR और डॉक्यूमेंट अंडरस्टैंडिंग कार्यों के लिए आधुनिक ओपन मॉडल का फाइन-ट्यूनिंग कितना सुलभ और प्रभावी हो सकता है।

यदि आप LLMs के फाइन-ट्यूनिंग के और अधिक व्यावहारिक उदाहरण ढूंढ रहे हैं, तो Fine-Tuning with Llama 3 कोर्स अवश्य देखें।