T5Gemma-2 İnce Ayarı (Fine-Tuning)

T5Gemma 2, Google tarafından Gemma 3 üzerine inşa edilen, çok dilli ve çok modlu girdileri destekleyen hafif, açık ağırlıklı kodlayıcı–çözücü modeller ailesidir. 

140+ dilde 128K’ya kadar bağlam penceresi ve bağlı gömme (tied embeddings) ile birleştirilmiş dikkat (merged attention) gibi parametre-verimli tasarım tercihleri sayesinde, bu modeller metin üretimi ve görüntü anlama görevleri için uygundur ve bir dizüstü bilgisayarda çalışacak kadar küçüktür.

Bu eğitimde, bir kodlayıcı–çözücü modeli bir LaTeX OCR veri kümesi üzerinde nasıl ince ayarlayacağımızı öğreneceğiz. Amaç, minimum sayıda eğitim örneğiyle güçlü performans elde etmektir. 

1. RunPod Üzerinde A100 GPU Ortamını Hazırlama

Bu modeli Kaggle veya Google Colab’de ince ayarlamak mümkün olsa da, bu genellikle kararsız oturumlara, kaynak bağlantı kopmalarına ve belirgin şekilde daha yavaş eğitime yol açar. Bu sürtünme noktalarından kaçınmak ve kurulumu basit ve güvenilir tutmak için NVIDIA A100 GPU kullanacağız.

RunPod üzerinde bir A100’ü saatlik yaklaşık $1,39 karşılığında kiralayabilir ve bu eğitimdeki tam eğitim süreci 30 dakikanın çok altında tamamlanmalıdır. Bu kurulum, bellek kısıtlarıyla uğraşmadan tutarlı performans sağlar.

Önce RunPod’a gidin ve en güncel PyTorch imajını kullanarak yeni bir pod oluşturun. 1× A100 makine seçin.

Ardından pod yapılandırmasını düzenleyin ve HF_TOKEN adlı bir ortam değişkeni ekleyin. Bu belirteç şunlar için gereklidir:

• Hugging Face’ten kısıtlı modellere erişmek
• İnce ayarlı modelinizi Hugging Face Hub’a geri göndermek

Pod hazır olduğunda not defterini başlatın ve gerekli Python paketlerini kurun. En güncel transformers sürümünü kullandığınızdan emin olun.

!pip -q install -U accelerate datasets pillow sentencepiece safetensors
!pip install --quiet "transformers==5.0.0rc1"
!pip install --quiet --no-deps trlAltyapı:

Şimdi, not defteri boyunca kullanacağımız kütüphane ve yardımcıları içe aktarın.

import torch
from datasets import load_dataset
from transformers import AutoProcessor, AutoModelForSeq2SeqLM
from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer, set_seedAltyapı:

Eğitime başlamadan önce, A100 GPU’lar için optimize edilmiş birkaç yapılandırma uygularız. Bir tohum (seed) belirlemek tekrarlanabilirlik sağlar ve TF32’yi etkinleştirmek, bf16 eğitim kararlılığını etkilemeden performansı artırır.

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())Altyapı:

CUDA: True NVIDIA A100 80GB PCIe
bf16 supported: TrueAltyapı:

2. Az Veriyle Eğitim için LaTeX OCR Veri Kümesini Ön İşlemek

Bu eğitimde, Hugging Face üzerinde bulunan LaTeX OCR veri kümesini kullanıyoruz. Veri kümesindeki her bir örnek şunlardan oluşur:

• matematiksel bir ifadeyi içeren bir görüntü ve
• hedef çıktı olarak karşılık gelen LaTeX kaynak metni.

Veri kümesi birden fazla yapılandırma sunar. Eğitimi verimli tutmak ve sınırlı veriden öğrenme hedefimizle uyumlu olmak için veri kümesi boyutunu açıkça kontrol edeceğiz.

Önce eğitim ve doğrulama bölümlerini yükleyin. Az verili bir ince ayar senaryosunu taklit etmek için veri kümesini rastgele karıştırır ve küçük bir alt küme seçeriz:

• 1.000 örnek eğitim için
• 200 örnek doğrulama için

Bu, eğitimi hızlı tutarken modelin genellemesine de olanak tanır.

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)Altyapı:

Çıktı:

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

Veriyi daha iyi anlamak için tek bir eğitim örneğine bakalım. Önce görüntüyü inceleyin.

train_ds[10]["image"]Altyapı:

Sonra, bu görüntüyle ilişkili ham LaTeX dizesini inceleyin.

train_ds[10]["text"]Altyapı:

'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 ) ,'Altyapı:

Son olarak, metnin görüntü içeriğiyle eşleştiğini doğrulamak için bu LaTeX ifadesini doğrudan not defterinde oluşturabiliriz.

from IPython.display import display, Math, Latex

latex = train_ds[10]["text"]
display(Math(latex))Altyapı:

3. T5Gemma-2 Çok Modlu Kodlayıcı–Çözücüyü Başlatma

Artık veri kümesi hazır olduğuna göre, T5Gemma-2 modelini ve karşılık gelen işleyicisini (processor) yükleme adımına geçiyoruz. 270M–270M varyantını kullanacağız; bu varyant yetenek ve verimlilik arasında güçlü bir denge sunar ve tüketici sınıfı bir GPU’ya rahatça sığar.

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",
)Altyapı:

Belirteçleyiciye (tokenizer) işleyici üzerinden erişilir. Bazı kodlayıcı–çözücü modeller varsayılan olarak dolgu (padding) belirteci tanımlamaz; bu nedenle gerekirse bir tane ekler ve modele ait belirteç gömmelerini buna göre yeniden boyutlandırırız.

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

LaTeX OCR için, modele giriş görüntüsüyle eşleştirilmiş kısa bir metinsel istem (prompt) vererek yönlendirme yaparız. Bu istem, görevi açıkça belirtir ve çıktı formatını sınırlar.

Son olarak, kodlayıcı girişi ve çözücü hedefi için azami dizi uzunluklarını tanımlarız. Bu değerler, çoğu matematiksel ifade için yeterlidir ve bellek kullanımını kontrol altında tutar.

PROMPT = "<start_of_image> Convert this image to LaTeX. Output only LaTeX."
MAX_INPUT_LEN  = 128
MAX_TARGET_LEN = 256Altyapı:

4. Başlangıç Çıkarımı: Sıfır-Örnek (Zero-Shot) Performans Kontrolü

İnce ayara başlamadan önce, önceden eğitilmiş T5Gemma-2 modeliyle bir başlangıç çıkarımı çalıştırmak faydalıdır. Bu, modele herhangi bir görev-özel eğitim olmadan LaTeX OCR görevinde nasıl davrandığını anlamamıza yardımcı olur ve sonraki iyileştirmeler için bir referans noktası sağlar.

Sürecin kısa bir özeti şöyledir:

1. Eğitim veri kümesinden bir örnek görüntü seçin.
2. Görüntü ve metinsel istemi birleştirerek model girdilerini gerekli tensör formatında hazırlayın.
3. Bellek tasarrufu ve üretim hızını artırmak için gradyan hesaplaması devre dışı bırakılmış değerlendirme kipinde çıkarım çalıştırın.
4. Daha temiz çıktı için sınırlı sayıda ışınla (beam) ışın araması ve hafif tekrar cezaları kullanın.
5. İşlem tamamlandığında oluşturulan belirteçleri tekrar metne çözümleyin.

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)Altyapı:

Önceden eğitilmiş modelden örnek çıktı:

--- 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}(-Altyapı:

Şimdi, aynı görüntü için gerçeğe uygun (ground-truth) LaTeX’e bakalım.

train_ds[20]["text"]Altyapı:

Gerçek değer:

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

Beklendiği üzere, önceden eğitilmiş model doğru bir LaTeX transkripsiyonu üretmiyor. Bunun yerine genel LaTeX kalıp metinleri ve ilgisiz parçalar oluşturuyor. Bu davranış normaldir; zira temel model LaTeX OCR için özel olarak eğitilmemiştir.

5. Özel Bir Görüntü-Metin Veri Birleştirici (Data Collator) Oluşturma

Bu bölümde, ince ayar için görüntüleri, istemleri ve LaTeX hedeflerini doğru şekilde toplu işlemek üzere özel bir görüntü–metin veri birleştirici oluşturuyoruz. T5Gemma-2 çok modlu bir kodlayıcı–çözücü model olduğundan, birleştirici; görüntü ve metinlerin doğru hizalanmasını ve beklenen formatta modele aktarılmasını sağlamak açısından kritik öneme sahiptir.

Özellikle, birleştirici şunları yapar:

• Görüntüleri farklı olası biçimlerden yükler ve tutarlı bir RGB temsiline dönüştürür
• Her eğitim örneğinin, işleyicinin beklediği yapıya sarılmış şekilde tam olarak bir görüntü içermesini sağlar
• OCR görevini açıkça tanımlamak için her görüntüye sabit bir talimat istemi ekler
• LaTeX hedeflerini, kontrollü kesme (truncation) ve dolgu ile ayrı ayrı belirteçler
• Etiketlerdeki dolgu belirteçlerini eğitim kaybına (loss) katkı vermeyecek şekilde maskeler
• Girdi tarafında kesmeyi önleyerek görüntü–belirteç uyumsuzluklarını engeller

Bu adımlar birlikte, modelin LaTeX OCR verisi üzerinde ince ayar sırasında kararlı eğitim, doğru kayıp hesaplaması ve güvenilir yakınsamayı sağlar.

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_inputsAltyapı:

6. Eğitim Yapılandırması ve Optimizasyon Ayarları

Bu bölümde, T5Gemma-2’yi LaTeX OCR görevi üzerinde ince ayarlamak için eğitim yapılandırmasını ve optimizasyon ayarlarını tanımlıyoruz. Kurulum, küçük bir veri kümesi ve tek bir eğitim dönemi kullanarak tek bir A100 GPU üzerinde hızlı eğitim için kasıtlı olarak basit ve optimize edilmiştir. 

Ek yükü azaltmak ve işleri hızlandırmak için değerlendirmeyi ve kontrol noktası kaydetmeyi devre dışı bırakıyor, yalnızca verimli ileri ve geri geçişlere odaklanıyoruz.

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,
)Altyapı:

Son olarak, Seq2SeqTrainer’ı başlatıyoruz. Eğiticiye (trainer) özel veri birleştiricimizi açıkça geçiriyoruz; böylece eğitim sırasında görüntüler, talimat istemleri ve LaTeX hedef dizilerini birleştiren çok modlu yığınları doğru şekilde oluşturabilir.

trainer = Seq2SeqTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    data_collator=collate_fn,
)Altyapı:

7. T5Gemma-2’yi LaTeX OCR Üzerinde İnce Ayarlama

Her şey hazır olduğuna göre modeli şimdi ince ayarlamaya başlayabiliriz. Eğitim, eğiticiye tek bir çağrıyla başlatılır.

trainer.train()Altyapı:

Eğitim sırasında kayıp kademeli olarak azalır; bu da modelin denklem görüntülerini karşılık gelen LaTeX gösterimlerine daha iyi eşlemeyi öğrendiğini gösterir. 

Küçük bir veri kümesi ve yalnızca bir dönemle bile model OCR görevine hızlıca uyum sağlamaya başlar.

8. İnce Ayar Sonrası Değerlendirme

İnce ayardan sonra, model çıktılarının nasıl değiştiğini görmek için hem bir eğitim örneğinde hem de bir doğrulama örneğinde çıkarımı yeniden çalıştırırız. 

Genel kalıp LaTeX üreten başlangıca kıyasla, ince ayarlı model artık hedef denklemlerin biçimi ve sembollerine yakından uyan yapılandırılmış LaTeX üretir.

Önce, daha öncekiyle aynı eğitim örneği üzerinde test ederiz. Görüntü işleyiciden geçirilir, belirteçler model tarafından üretilir ve ardından LaTeX’e çözülür.

# 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)Altyapı:

Gördüğünüz gibi, artık rastgele veya ilgisiz metin değil, düzgün LaTeX çıktısı alıyoruz. Eğitim örneğinde tahmin büyük ölçüde gerçeğe uygundur; kalan hatalar çoğunlukla kesirler, indisler ve birkaç yanlış konumlandırılmış belirteçtedir.

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 { \Altyapı:

Sonra, genelleme kontrolü için modeli bir doğrulama örneğinde test ederiz.

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)Altyapı:

Doğrulama örneğinde model, parantez yerleşimi, parantez içi terimler ve daha uzun ifadelerde zaman zaman hatalar yapsa da doğru LaTeX yapısı ve sembollerini izlemeyi sürdürüyor.

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 _Altyapı:

Gerçek değerle karşılaştırıldığında, genel yapı açıkça hizalıdır ve model ilgisiz çıktı yerine yakın bir yaklaşım üretmektedir.

print(val_ds[10]["text"])Altyapı:

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] .Altyapı:

Genel olarak, ince ayar sonrası sonuçlar belirgin bir iyileşme gösteriyor. Model artık genel LaTeX şablonları tahmin etmiyor; bunun yerine, küçük bir eğitim seti ve kısa bir ince ayar çalışmasıyla bile veri kümesi hedeflerine yakından benzeyen denklem-vari LaTeX üretiyor.

9. İnce Ayarlı T5Gemma-2 Modelini Kaydetme ve Yayınlama

Eğitim tamamlandığında, ilk adım modeli yerel olarak kaydetmektir; böylece daha sonra çıkarım için yeniden kullanılabilir.

trainer.save_model()Altyapı:

Ardından, modele başkalarının erişebilmesi, yeniden kullanması ve üzerine inşa edebilmesi için Hugging Face Hub’a göndeririz.

trainer.push_to_hub()Altyapı:

Depo dosyalarını incelerken, eğitici üzerinden model gönderildiğinde işleyici yapılandırmasının her zaman dahil edilmediğini fark edebilirsiniz. 

İşleyici, hem görüntüleri hem de metni doğru şekilde ele almak için gerekli olduğundan, ek kurulum gerektirmeden modelin yüklenip kullanılabilmesini sağlamak için onu ayrıca açıkça gönderiyoruz.

processor.push_to_hub(repo_id="kingabzpro/t5gemma2-latex-ocr-1k")Altyapı:

Bu adımla birlikte, depoda model ve işleyiciyi tek bir çağrıyla yüklemek için gereken her şey bulunur. Artık Hugging Face üzerindeki kingabzpro/t5gemma2-latex-ocr-1k deposunu ziyaret ederek ince ayarlı modele erişebilir ve onu LaTeX OCR veya daha ileri denemeler için kullanmaya başlayabilirsiniz.

10. Pipelines ile Çıkarım için Modeli Yükleme

İnce ayarlı model Hugging Face Hub’da yayınlandığına göre, onu doğrudan pipeline API’sini kullanarak çıkarım için yükleyebiliriz. Bu, işleyicileri, belirteçleyicileri veya üretim mantığını elle yönetmeden modeli test etmenin en basit yoludur.

Modeli Hub’dan yüklüyor ve bir image-text-to-text hattı (pipeline) oluşturuyoruz:

from transformers import pipeline

generator = pipeline(
    "image-text-to-text",
    model="kingabzpro/t5gemma2-latex-ocr-1k",
)Altyapı:

Ardından, öncekiyle aynı talimat istemini kullanarak bir doğrulama örneğinde çıkarım çalıştırıyoruz.

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},
)Altyapı:

Gördüğünüz gibi, çıktı zaten doğru LaTeX’e oldukça yakındır.

[{'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} {'}]Altyapı:

Başka bir doğrulama örneğini deneyelim ve yalnızca LaTeX dizesini tutmak için çıktıyı son işlemden geçirelim.

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)Altyapı:

Bu kez sonuç temiz ve doğrudan LaTeX olarak kullanılabilir:

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 ^ {Altyapı:

Bu noktada, model bir LaTeX OCR sistemi olarak doğrudan kullanılabilir. Onu bir API arkasında dağıtabilir, bir belge işleme hattına entegre edebilir veya daha yüksek doğruluk için daha fazla veriye sahip ince ayarla devam edebilirsiniz.

Yukarıdaki kodu çalıştırırken herhangi bir sorunla karşılaşırsanız, lütfen yardımcı not defterine göz atın. Süreç boyunca her adımda çıktıların da yer aldığı tam kodu içerir.

Sonuç

Modeli eğitmeye başladığımda, onu bir görüntü kodlayıcısına sahip herhangi bir büyük dil modeli gibi ele aldım. Birkaç kez başarısız olduktan sonra, bu yaklaşımın dizi-ötesi-dizi (sequence-to-sequence) kodlayıcı–çözücü modeller için işe yaramadığını fark ettim. 

Veri birleştirici, eğitici ve eğitim argümanları ile hatta çıkarımın nasıl yapıldığı dahil olmak üzere tüm kurulumu yeniden düşünmem gerekti.

Bu eğitimde, ortam kurulumundan ve veri kümesi incelemesinden özel veri birleştirmeye, verimli eğitime ve eğitim sonrası değerlendirmeye kadar T5Gemma-2’yi bir LaTeX OCR görevi üzerinde ince ayarlamaya yönelik uçtan uca bir iş akışını adım adım ele aldık. 

Küçük bir veri kümesi ve tek bir A100 GPU kullanarak, bir kodlayıcı–çözücü çok modlu modelin denklem görüntülerinden yapılandırılmış ve anlamlı LaTeX’i hızla öğrenebildiğini gösterdik. 

Sonunda, ince ayarlı model genel kalıp çıktının çok ötesine geçerek gerçeğe yakın, denklem benzeri LaTeX üretti ve modern açık modellerin, gerçek dünya OCR ve belge anlama görevleri için ince ayarının ne kadar erişilebilir ve etkili olabileceğini gösterdi.

LLM’lerin ince ayarına dair daha fazla uygulamalı örnek arıyorsanız, Llama 3 ile İnce Ayar kursuna göz atmanızı öneririm.