AI Lab: Experimenteeromgeving en tutorials voor AI

AI lab is je hands-on werkbank voor AI-experimenten: een reproduceerbare omgeving, snelle iteraties in notebooks, en concrete workflows voor model training, fine-tuning en prompt engineering. Dit artikel geeft je een code-first aanpak, met een werkbare projectstructuur, training- en fine-tuning-patronen, en een checklist om je experimenten debugbaar en herhaalbaar te houden.

Wat je bedoelt met een “AI lab” (en wat het moet kunnen)

Een AI lab is geen tool, maar een werkstijl plus een omgeving. Zet minimaal deze bouwstenen klaar.

1) Reproduceerbare omgeving

• Één dependency set (requirements of lockfile).
• Één dataset versie, via bestandshash, of via een vast pad plus versie-indeling.
• Één training config (optimizer, LR, seeds, batch size, max sequence length).
• Één logformat (per run: config, metrics, checkpoints).

2) Notebooks als uitvoerbare spec

Notebooks zijn niet alleen voor uitleg, maar voor uitvoeren. Houd executie volgorde bewust, en maak elke cel idempotent waar mogelijk. Als je in Jupyter of vergelijkbaar werkt, is “run cell” de kern interactie, maar je moet ook rekening houden met kernel en execution state. (Jupyter is beschreven als web-based interactieve omgeving, met uitvoering via kernels.)

Als je merkt dat Jupyter-output en code drift ontstaat, overweeg een notebook-variant die consistente execution afdwingt; bijvoorbeeld marimo positioneert zichzelf als reactive notebook, waarbij afhankelijke cellen automatisch herberekend worden of als stale worden gemarkeerd. (docs.marimo.io)

3) Workflow voor training en fine-tuning

• Training: dataloaders, loss, evaluatie, checkpoints.
• Fine-tuning: leesbaar datamodel, tokenisatie, trainer of custom loop.
• Vergelijking: baseline, ablations, en één variabele tegelijk wijzigen.

4) Prompt engineering die meetbaar is

Prompt engineering zonder evaluatie is gokken. Je AI lab moet prompts kunnen:

• testen op een vast set voorbeelden (eval split),
• scoren op automatische metrics of rubric,
• variëren (temperatuur, few-shot, instructies) zonder je hele pipeline te slopen.

Projectopzet voor een AI lab (kort, werkend, notebook-first)

Maak je AI lab zo dat je binnen 30 minuten een run kunt herhalen. Gebruik deze structuur als starting point.

Aanbevolen mappen

ai-lab/
  notebooks/
    01_setup.ipynb
    02_data.ipynb
    03_train_baseline.ipynb
    04_finetune.ipynb
    05_prompt_eval.ipynb
  src/
    data.py
    tokenize.py
    train.py
    finetune.py
    eval.py
  configs/
    baseline.yaml
    finetune.yaml
  data/
    raw/
    processed/
  runs/
    2026-06-24_2200_seed42/
      config.yaml
      metrics.json
      checkpoints/
  requirements.txt

Notebooks als uitvoer, src als motor

Ruwe vuistregel:

• Notebooks: experiment orchestration, visualisaties, snelle inspectie.
• src/: deterministische functies, training en evaluatie die je zonder notebook kunt draaien.

Install en kernel sanity check

Minimaal doe je twee checks:

1. Kernel klopt: imports werken, GPU device zichtbaar.
2. Determinisme: seeds gezet, waar mogelijk deterministische ops.

Een snelle “setup cel” doet dit:

# notebooks/01_setup.ipynb (cel)
import os, json, random
import numpy as np

SEED = 42
os.environ["PYTHONHASHSEED"] = str(SEED)
random.seed(SEED)
np.random.seed(SEED)

try:
    import torch
    torch.manual_seed(SEED)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(SEED)
except ImportError:
    torch = None

print("torch:", torch.__version__ if torch else None)
print("cuda_available:", bool(torch and torch.cuda.is_available()))

Model training in je AI lab (baseline eerst)

Train eerst een baseline die “werkt” voordat je gaat fine-tunen. Dit voorkomt dat je later debugt op twee variabelen tegelijk: data en loss. In een technisch lab wil je dat elke run een reproduceerbare uitkomst heeft.

Baselines die je meestal nodig hebt

• Van scratch: zelden nodig, vaak te duur.
• Transfer learning zonder fine-tune: prompt of embedding-only baseline.
• Fine-tune met kleine LR: vaak beste startpunt.

Fine-tuning in de praktijk met Hugging Face Transformers

Voor fine-tuning kun je Transformers gebruiken met de Trainer en bijbehorende training arguments. De Transformers documentatie beschrijft het trainings- en fine-tuning framework via Trainer en gerelateerde pagina’s. (huggingface.co)

Als je al een data format hebt (bijvoorbeeld instructie-text of prompt-completion pairs), ziet het skeleton er conceptueel zo uit:

Dataset voorbereiding

# src/tokenize.py (schets)
from dataclasses import dataclass

def build_tokenized_dataset(dataset, tokenizer, text_field="text", max_length=512):
    def tokenize_fn(examples):
        return tokenizer(
            examples[text_field],
            truncation=True,
            padding="max_length",
            max_length=max_length,
        )

    return dataset.map(tokenize_fn, batched=True)

Trainer skeleton

# src/train.py (skelet)
from transformers import AutoModelForCausalLM, Trainer, TrainingArguments

def train_causal_lm(model_name, tokenized_train, tokenized_eval, output_dir, lr=5e-5):
    model = AutoModelForCausalLM.from_pretrained(model_name)

    args = TrainingArguments(
        output_dir=output_dir,
        learning_rate=lr,
        per_device_train_batch_size=2,
        per_device_eval_batch_size=2,
        evaluation_strategy="steps",
        eval_steps=200,
        logging_steps=50,
        save_steps=200,
        num_train_epochs=1,
        weight_decay=0.01,
        fp16=True,
        report_to=[],
        seed=42,
    )

    trainer = Trainer(
        model=model,
        args=args,
        train_dataset=tokenized_train,
        eval_dataset=tokenized_eval,
        tokenizer=None,
    )

    trainer.train()
    return trainer

Belangrijk voor je AI lab: fix alles dat niet hoeft te variëren, en laat één knop tegelijk bewegen (bijvoorbeeld learning rate, max length, of dataset slice).

Performance zonder te gokken: torch.compile

Voor sommige setups kan torch.compile helpen, maar test op jouw model. PyTorch documentatie positioneert torch.compile als een wrapper die een gecompileerde module teruggeeft, met de verwachting dat de eerste runs mogelijk trager zijn. (docs.pytorch.org)

Minimal voorbeeld:

# optioneel, src/train.py (fragment)
if use_compile:
    import torch
    model = torch.compile(model)

Fine-tuning workflow: van data naar checkpoints

Fine-tuning in een AI lab is het onderdeel waar de meeste fouten zitten. Data is vaak de grootste bron van “het werkt niet”. Dus: valideer data en verliescurve vóór je grote runs draait.

Data contract: prompt-completion of instruction

Kies één contract en blijf erbij.

• Prompt-completion: één input string, één target string.
• Instruction format: systeem + instructie + input, target is output.

Maak een kleine sanity set van 20 samples en print token counts. Als token lengths extreme outliers hebben, trim of filter vroeg.

Eval set isoleren

Splits op deterministische manier, bijvoorbeeld hash op voorbeeld-ID. Doe dit in notebooks/02_data.ipynb en zet de output vast in data/processed.

Fine-tuning met Transformers Trainer

Transforms documentatie beschrijft fine-tuning training via de Trainer API. (huggingface.co)

Voor je AI lab betekent dit praktisch:

• Je bouwt tokenized datasets of een dataset die door Trainer begrepen wordt.
• Je zet TrainingArguments consistent (eval steps, save steps).
• Je logt metrics per run.

Config als single source of truth

Werk vanuit YAML, zodat je niet per notebook cellen vergeet te wisselen.

# configs/finetune.yaml (voorbeeld)
model_name: "gpt2"
output_dir: "runs/2026-06-24_2200_seed42"
lr: 2e-5
max_length: 256
eval_steps: 100
save_steps: 100
num_train_epochs: 1
fp16: true

In je notebook laad je config en start je training:

# notebooks/04_finetune.ipynb (fragment)
import yaml
from src.finetune import finetune

with open("configs/finetune.yaml", "r", encoding="utf-8") as f:
    cfg = yaml.safe_load(f)

trainer = finetune(cfg)

Checkpoints en vroeg stoppen

In een lab wil je snel beslissingen. Voeg “early evidence” toe:

• Eval loss na N steps vergelijken met baseline.
• Als loss na twee eval windows slechter is, stop of verlaag LR.

Prompt engineering met evaluatie: prompts als experimenten

Prompt engineering is alleen nuttig als je het experimenteel behandelt. In je AI lab maak je prompts reproduceerbaar en vergelijkbaar.

Prompts als template, niet als losse tekst

Gebruik templates met vaste variabelen:

• {instruction}
• {context}
• {format_rules}

Eval procedure: deterministisch waar mogelijk

Voor evaluatie wil je zoveel mogelijk determinisme:

• temperatuur laag (of nul waar toegestaan),
• vaste max tokens,
• zelfde decoding settings per run.

Prompt varianten genereren en score berekenen

Maak één notebookcel die varianten draait.

# notebooks/05_prompt_eval.ipynb (skelet, pseudo-API call)
from dataclasses import dataclass

@dataclass
class PromptVariant:
    name: str
    system: str
    user_template: str

variants = [
    PromptVariant(
        name="base",
        system="Je bent een assistent.",
        user_template="Schrijf een samenvatting van: {text}"
    ),
    PromptVariant(
        name="format",
        system="Je bent een assistent.",
        user_template="Geef een samenvatting in 3 bullets: {text}"
    ),
]

# Voorbeeld: roep je eigen model wrapper aan.
# score_fn vergelijkt output met referentie.
results = []
for v in variants:
    for ex in eval_examples:
        prompt_user = v.user_template.format(text=ex["text"])
        output = generate(system=v.system, user=prompt_user, temperature=0)
        score = score_fn(output, ex["label"])
        results.append({"variant": v.name, "id": ex["id"], "score": score})

# aggregeer metrics per variant

Fine-tuning vs prompt engineering, wanneer kiezen?

• Als je taak verandert maar de outputstijl blijft gelijk, probeer eerst prompt en few-shot.
• Als je model consistent fouten maakt op vaste patronen, fine-tuning loont.
• Als je data beschikbaar hebt, combineer: fine-tune voor formaat consistentie, prompts voor taakvariatie.

Als je aan OpenAI fine-tuning doet, check de status van de platform features

Let op: fine-tuning platformmogelijkheden kunnen veranderen. OpenAI publiceerde updates over fine-tuning waarbij het platform wordt “winding down” genoemd, met een update op 8 mei 2026. (openai.com)

Praktisch advies voor je AI lab: behandel dit als “external dependency”. Bij voorkeur ontwerp je je pipeline zodanig dat je kan overschakelen naar een alternatieve fine-tuning route (bijvoorbeeld Hugging Face) als een provider wijzigt.

Hands-on opdrachten (direct toepasbaar in je AI lab)

Hier zijn opdrachten die je vandaag kunt doen. Elke opdracht levert een meetbaar artefact op: metrics of checkpoints.

Opdracht 1: reproducibility test

• Doe twee runs met identieke config en seed.
• Vergelijk eval loss curve of eindmetric.

Als je verschil groot is, is je lab niet reproduceerbaar. Fix: seeds, determinisme, dataloader shuffle, en tokenisatie-pad.

Opdracht 2: data ablation

• Maak drie dataset varianten: full, 80 percent, filtered (trim lange inputs).
• Train elk met dezelfde hyperparameters.

Leg in je run log vast welke filtering rules je toepaste. Dit is meestal de snelste winst.

Opdracht 3: prompt-eval matrix

• Neem 10 prompts varianten (alleen 1 regel per keer aanpassen).
• Gebruik een vaste eval set van 100 items.

Output: tabel met variant, gemiddelde score, en top 3 varianten. Stop zodra je een duidelijke winnaar hebt.

Opdracht 4: performance experiment met torch.compile

• Run baseline training met en zonder torch.compile.
• Meet alleen totale trainingstijd voor dezelfde steps.

Houd rekening met de initiële overhead die PyTorch documenteert. (docs.pytorch.org)

Opdracht 5: schrijf een “lab readme” per run

Elke run krijgt een korte tekst file met:

• Doel van de run (wat test je?),
• Wijziging t.o.v. baseline,
• Belangrijkste metric en conclusie.

Dit maakt AI lab iteraties sneller, omdat je zelf terug kunt naar de juiste context zonder notebooks door te ploegen.

Veelgemaakte fouten in AI labs (en snelle fixes)

• Je evalueert op training data: fix door strikt splitten.
• Je wijzigt twee dingen tegelijk: wijzig één variabele per run.
• Je tokeniseert inconsistent: centraliseer tokenisatie in één functie in src/.
• Geen seed, geen lockfile: maak environment reproducible, anders debug je ruis.
• Geen early evidence: voeg eval windows toe en stop bij regressie.

Bonus: leertraject voor training en fine-tuning

Als je een overzicht wil van trainingsroutes en curricula, kun je dit interne artikel gebruiken als startpunt voor structuur: AI-cursus: Complete training overzicht 2024.

Conclusie: bouw een AI lab dat je kunt herhalen

Een AI lab is succesvol als je drie dingen samenbrengt: reproduceerbare omgeving, code-first notebooks die echt uitvoer zijn, en evaluatie die je beslissingen onderbouwt. Start met een baseline, maak fine-tuning pas interessant als data en eval set kloppen, en behandel prompt engineering als experimenten met score en varianten. Als je dit doet, worden iteraties voorspelbaar, debugbaar, en snel.

Pak meteen de volgende stap: kies één baseline run, voeg een eval split toe, en maak daarna een prompt variantenmatrix. Zodra je meetbare winst ziet, ga je fine-tunen op de foutpatronen die je in de eval hebt gevonden.