Fine-tunen van T5Gemma-2

T5Gemma 2 is een familie van lichte, open-gewicht encoder–decoder-modellen van Google, gebouwd op Gemma 3, die meertalige en multimodale input ondersteunen. 

Met een contextvenster tot 128K in meer dan 140 talen en parameter-efficiënte keuzes zoals gekoppelde embeddings en samengevoegde attention, zijn deze modellen geschikt voor tekstgeneratie- en beeldbegriptaken, terwijl ze klein genoeg blijven om op een laptop te draaien.fin

In deze tutorial leren we hoe je een encoder–decoder-model fine-tunet op een LaTeX-OCR-dataset. Het doel is sterke prestaties te behalen met een minimaal aantal trainingsvoorbeelden. 

1. De A100-GPU-omgeving instellen op RunPod

Hoewel het mogelijk is om dit model te fine-tunen op Kaggle of Google Colab, leidt dat vaak tot instabiele sessies, verbroken verbindingen en aanzienlijk tragere training. Om deze frictiepunten te vermijden en de setup eenvoudig en betrouwbaar te houden, gebruiken we een NVIDIA A100-GPU.

Je kunt een A100 huren op RunPod voor ongeveer $1,39 per uur, en het volledige trainingsproces in deze tutorial duurt ruim onder de 30 minuten. Met deze setup krijg je consistente prestaties zonder te worstelen met geheugengrenzen.

Ga naar RunPod en maak een nieuwe pod aan met de nieuwste PyTorch-image. Selecteer een machine met 1× A100.

Bewerk vervolgens de podconfiguratie en voeg een omgevingsvariabele toe met de naam HF_TOKEN. Dit token is nodig om:

• Gedeelde (gated) modellen te laden van Hugging Face
• Je gefinetunede model terug te pushen naar de Hugging Face Hub

Zodra de pod klaar is, start je de notebook en installeer je de benodigde Python-packages. Zorg dat je de laatste versie van transformers gebruikt.

!pip -q install -U accelerate datasets pillow sentencepiece safetensors
!pip install --quiet "transformers==5.0.0rc1"
!pip install --quiet --no-deps trlMogelijk gemaakt door

Importeer nu de libraries en utilities die we in de hele notebook gebruiken.

import torch
from datasets import load_dataset
from transformers import AutoProcessor, AutoModelForSeq2SeqLM
from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer, set_seedMogelijk gemaakt door

Voor het trainen passen we een paar configuraties toe die geoptimaliseerd zijn voor A100-GPU’s. Een seed zetten zorgt voor reproduceerbaarheid, en TF32 inschakelen verbetert de performance zonder de stabiliteit van bf16-training te beïnvloeden.

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())Mogelijk gemaakt door

CUDA: True NVIDIA A100 80GB PCIe
bf16 supported: TrueMogelijk gemaakt door

2. De LaTeX-OCR-dataset preprocessen voor trainen met weinig data

In deze tutorial gebruiken we de LaTeX-OCR-dataset die beschikbaar is op Hugging Face. Elk voorbeeld in de dataset bestaat uit:

• een afbeelding met een wiskundige expressie, en
• de bijbehorende LaTeX-broncode als doeluitvoer.

De dataset biedt meerdere configuraties. Om de training efficiënt te houden en aan te sluiten bij ons doel om van beperkte data te leren, controleren we expliciet de datasetgrootte.

Laad eerst de training- en validatiesplits. Om een low-data fine-tuning scenario te simuleren, schudden we de dataset willekeurig en selecteren we een kleine subset:

• 1.000 samples voor training
• 200 samples voor validatie

Dit houdt de training snel en geeft het model toch de kans om te generaliseren.

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)Mogelijk gemaakt door

Uitvoer:

Dataset({
    features: ['image', 'text'],
    num_rows: 1000
}) Dataset({
    features: ['image', 'text'],
    num_rows: 200
})
Columns: ['image', 'text']Mogelijk gemaakt door

Om de data beter te begrijpen, bekijken we een enkel trainingsexample. Inspecteer eerst de afbeelding.

train_ds[10]["image"]Mogelijk gemaakt door

Bekijk vervolgens de ruwe LaTeX-string die bij die afbeelding hoort.

train_ds[10]["text"]Mogelijk gemaakt door

'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 ) ,'Mogelijk gemaakt door

Tot slot kunnen we deze LaTeX-expressie direct in de notebook renderen om te verifiëren dat de tekst overeenkomt met de inhoud van de afbeelding.

from IPython.display import display, Math, Latex

latex = train_ds[10]["text"]
display(Math(latex))Mogelijk gemaakt door

3. De T5Gemma-2 multimodale encoder–decoder initialiseren

Nu de dataset klaar is, is de volgende stap het laden van het T5Gemma-2-model en de bijbehorende processor. We gebruiken de 270M–270M-variant, die een goede balans biedt tussen capaciteiten en efficiëntie en comfortabel op een consumentengpu past.

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",
)Mogelijk gemaakt door

De tokenizer is toegankelijk via de processor. Sommige encoder–decoder-modellen definiëren standaard geen paddingtoken, dus voegen we er indien nodig een toe en passen we de tokenembeddings van het model hierop aan.

tokenizer = processor.tokenizer
if tokenizer.pad_token is None:
    tokenizer.add_special_tokens({"pad_token": tokenizer.eos_token})
    model.resize_token_embeddings(len(tokenizer))Mogelijk gemaakt door

Voor LaTeX-OCR sturen we het model aan met een korte tekstuele prompt in combinatie met de invoerafbeelding. Deze prompt specificeert de taak duidelijk en begrenst het uitvoerformaat.

Tot slot definiëren we maximale sequentielengtes voor de encoderinput en het decodertarget. Deze waarden zijn voldoende voor de meeste wiskundige expressies, terwijl het geheugengebruik beheersbaar blijft.

PROMPT = "<start_of_image> Convert this image to LaTeX. Output only LaTeX."
MAX_INPUT_LEN  = 128
MAX_TARGET_LEN = 256Mogelijk gemaakt door

4. Baseline-inferentie uitvoeren: zero-shot prestatiecheck

Voordat we beginnen met fine-tunen, is het nuttig om een baseline-inferentie uit te voeren met het voorgetrainde T5Gemma-2-model. Dit helpt te begrijpen hoe het model zich gedraagt op de LaTeX-OCR-taak zonder taak-specifieke training en geeft een referentiepunt voor latere verbeteringen.

Hier is een beknopt overzicht van het proces:

1. Kies een voorbeeldafbeelding uit de trainingsdataset.
2. Bereid modelinputs voor door de afbeelding en de tekstprompt te combineren tot het vereiste tensorformaat.
3. Voer inferentie uit in evaluatiemodus met uitgeschakelde gradientberekening om geheugen te besparen en de generatie te versnellen.
4. Gebruik beam search met een beperkt aantal beams en milde herhalingsstraffen voor schonere output.
5. Decodeer de gegenereerde tokens terug naar tekst zodra het proces is voltooid.

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)Mogelijk gemaakt door

Voorbeelduitvoer van het voorgetrainde model:

--- 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}(-Mogelijk gemaakt door

Bekijk nu de groundtruth LaTeX voor dezelfde afbeelding.

train_ds[20]["text"]Mogelijk gemaakt door

Groundtruth:

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

Zoals verwacht produceert het voorgetrainde model geen correcte LaTeX-transcriptie. In plaats daarvan genereert het generieke LaTeX boilerplate en niet-gerelateerde fragmenten. Dit gedrag is normaal, aangezien het basismodel niet specifiek is getraind voor LaTeX-OCR.

5. Een aangepaste image-tekst datacollator bouwen

In deze sectie bouwen we een aangepaste image–tekst datacollator om afbeeldingen, prompts en LaTeX-doelen correct te batchen voor fine-tuning. Omdat T5Gemma-2 een multimodaal encoder–decoder-model is, speelt de collator een cruciale rol om ervoor te zorgen dat afbeeldingen en tekst correct worden uitgelijnd en in het verwachte formaat naar het model worden doorgegeven.

Specifiek zorgt de collator voor:

• Het laden van afbeeldingen uit verschillende mogelijke formaten en het converteren naar een consistente RGB-weergave
• Zeker stellen dat elk trainingsexample precies één afbeelding bevat, verpakt in de structuur die de processor verwacht
• Een vaste instructieprompt aan elke afbeelding koppelen om de OCR-taak duidelijk te definiëren
• LaTeX-doelen apart tokenizen met gecontroleerde truncatie en padding
• Paddingtokens in de labels maskeren zodat ze niet bijdragen aan de trainingsloss
• Truncatie aan de inputzijde vermijden om mismatches tussen afbeelding en tokens te voorkomen

Samen zorgen deze stappen voor stabiele training, correcte lossberekening en betrouwbare convergentie bij het fine-tunen van het model op LaTeX-OCR-data.

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_inputsMogelijk gemaakt door

6. Trainingsconfiguratie en optimalisatie-instellingen

In deze sectie definiëren we de trainingsconfiguratie en optimalisatie-instellingen voor het fine-tunen van T5Gemma-2 op de LaTeX-OCR-taak. De setup is bewust eenvoudig en geoptimaliseerd voor snelle training op een enkele A100-GPU, met een kleine dataset en één trainingsepoch. 

Om overhead te verminderen en te versnellen, schakelen we evaluatie en het opslaan van checkpoints uit en focussen we alleen op efficiënte forward- en backwardpasses.

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,
)Mogelijk gemaakt door

Tot slot initialiseren we de Seq2SeqTrainer. We geven expliciet onze aangepaste datacollator door zodat de trainer tijdens de training multimodale batches kan samenstellen die afbeeldingen, instructieprompts en LaTeX-doelsequenties combineren.

trainer = Seq2SeqTrainer(
    model=model,
    args=args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    data_collator=collate_fn,
)Mogelijk gemaakt door

7. T5Gemma-2 fine-tunen op LaTeX-OCR

Nu alles klaarstaat, kunnen we het model gaan fine-tunen. De training wordt gestart met één enkele aanroep van de trainer.

trainer.train()Mogelijk gemaakt door

Tijdens de training daalt de loss geleidelijk, wat aangeeft dat het model beter leert om vergelijkingafbeeldingen te koppelen aan hun overeenkomstige LaTeX-weergaven. 

Zelfs met een kleine dataset en slechts één epoch past het model zich snel aan de OCR-taak aan.

8. Evaluatie na het fine-tunen

Na het fine-tunen voeren we opnieuw inferentie uit op zowel een trainingsexample als een validatievoorbeeld om te zien hoe de modeluitvoer is veranderd. 

Vergeleken met de baseline, die vooral generieke LaTeX boilerplate produceerde, genereert het gefinetunede model nu gestructureerde LaTeX die nauw aansluit bij de vorm en symbolen van de doelformules.

We beginnen met testen op hetzelfde trainingsexample als eerder. De afbeelding gaat door de processor, het model genereert tokens en die decoderen we terug naar 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)Mogelijk gemaakt door

Zoals je ziet krijgen we nu correcte LaTeX-uitvoer, niet willekeurige of niet-gerelateerde tekst. In het trainingsexample komt de voorspelling grotendeels overeen met de groundtruth; de resterende fouten zitten vooral in breuken, indices en enkele verkeerd geplaatste tokens.

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 { \Mogelijk gemaakt door

Vervolgens testen we het model op een validatievoorbeeld om de generalisatie te controleren.

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)Mogelijk gemaakt door

In het validatievoorbeeld volgt het model nog steeds de juiste LaTeX-structuur en -symbolen, al maakt het af en toe fouten in haakjesplaatsing, termen tussen haakjes en langere expressies.

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 _Mogelijk gemaakt door

Vergeleken met de groundtruth is de algehele structuur duidelijk in lijn, en produceert het model een nauwkeurige benadering in plaats van niet-gerelateerde output.

print(val_ds[10]["text"])Mogelijk gemaakt door

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] .Mogelijk gemaakt door

Al met al tonen de resultaten na fine-tuning een duidelijke verbetering. Het model gokt niet langer op generieke LaTeX-sjablonen, maar produceert vergelijking-achtige LaTeX die sterk lijkt op de doelsequenties uit de dataset, zelfs met een kleine trainingsset en een korte fine-tuningrun.

9. Het gefinetunede T5Gemma-2-model opslaan en publiceren

Zodra de training voltooid is, is de eerste stap het gefinetunede model lokaal op te slaan zodat je het later kunt hergebruiken voor inferentie.

trainer.save_model()Mogelijk gemaakt door

Vervolgens pushen we het model naar de Hugging Face Hub zodat anderen het kunnen benaderen, hergebruiken en erop kunnen voortbouwen.

trainer.push_to_hub()Mogelijk gemaakt door

Bij inspectie van de repositorybestanden valt mogelijk op dat de processorconfiguratie niet altijd wordt meegepusht via de trainer. 

Omdat de processor nodig is om zowel afbeeldingen als tekst correct te verwerken, pushen we deze expliciet apart, zodat het model zonder extra setup geladen en gebruikt kan worden.

processor.push_to_hub(repo_id="kingabzpro/t5gemma2-latex-ocr-1k")Mogelijk gemaakt door

Met deze stap bevat de repository alles wat nodig is om het model en de processor met één enkele aanroep te laden. Je kunt nu kingabzpro/t5gemma2-latex-ocr-1k bezoeken op Hugging Face om toegang te krijgen tot het gefinetunede model en het te gebruiken voor LaTeX-OCR of verdere experimenten.

10. Het model laden voor inferentie met Pipelines

Nu het gefinetunede model is gepubliceerd op de Hugging Face Hub, kunnen we het rechtstreeks laden voor inferentie met de pipeline-API. Dit is de eenvoudigste manier om het model te testen zonder processors, tokenizers of generatielogica handmatig af te handelen.

We laden het model van de Hub en maken een image-text-to-text-pipeline aan:

from transformers import pipeline

generator = pipeline(
    "image-text-to-text",
    model="kingabzpro/t5gemma2-latex-ocr-1k",
)Mogelijk gemaakt door

Vervolgens voeren we inferentie uit op een validatievoorbeeld met dezelfde instructieprompt als eerder.

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},
)Mogelijk gemaakt door

Zoals je ziet, ligt de output al heel dicht bij de juiste 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} {'}]Mogelijk gemaakt door

Laten we een ander validatievoorbeeld proberen en de output nabewerken om alleen de LaTeX-string over te houden.

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)Mogelijk gemaakt door

Dit keer is het resultaat schoon en direct bruikbaar als 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 ^ {Mogelijk gemaakt door

Op dit punt kun je het model inzetten als een kant-en-klaar LaTeX-OCR-systeem. Je kunt het achter een API plaatsen, integreren in een documentverwerkingspipeline, of verder fine-tunen met meer data voor nog betere nauwkeurigheid.

Loop je tegen problemen aan bij het uitvoeren van bovenstaande code, bekijk dan de hulpmiddel-notebook. Deze bevat de volledige code met outputs bij elke stap om je door het proces te leiden.

Conclusie

Toen ik begon met het trainen van het model, behandelde ik het als elk groot taalmodel met een image-encoder. Na meerdere keren falen, realiseerde ik me dat deze aanpak niet werkt voor sequence-to-sequence, encoder–decoder-modellen. 

Ik moest de hele setup herzien, inclusief de datacollator, de trainer en trainingsargumenten, en zelfs hoe inferentie wordt uitgevoerd.

In deze tutorial liepen we een end-to-end workflow door voor het fine-tunen van T5Gemma-2 op een LaTeX-OCR-taak, van het opzetten van de omgeving en het inspecteren van de dataset tot aangepaste datacollatie, efficiënte training en evaluatie na de training. 

Met een kleine dataset en een enkele A100-GPU lieten we zien dat een multimodaal encoder–decoder-model snel kan leren om gestructureerde, betekenisvolle LaTeX te genereren uit vergelijkingafbeeldingen. 

Uiteindelijk ging het gefinetunede model ruim voorbij generieke boilerplate-uitvoer en produceerde het vergelijking-achtige LaTeX die nauw aansluit bij de groundtruth, wat laat zien hoe toegankelijk en effectief het fine-tunen van moderne open modellen kan zijn voor realistische OCR- en documentbegriptaken.

Als je op zoek bent naar meer praktische voorbeelden van het fine-tunen van LLM’s, raad ik aan om de Fine-Tuning with Llama 3-cursus te bekijken.