# Afbeeldingen batchgewijs verwerken

[[TOC]]

## Wanneer batchverwerking

Handmatig afbeeldingen genereren in een tool als ImageFX of Gemini werkt prima voor tien tot twintig afbeeldingen. Heb je een productcatalogus met driehonderd items, een sjabloonreeks van vijftig varianten, of een wekelijkse batch van tachtig socialmediabeelden, dan wordt handmatig werk onhaalbaar.

Batchverwerking via de Imagen API op Vertex AI maakt het mogelijk om honderden afbeeldingen onbeheerd te genereren vanuit een script, met consistente stijl en voorspelbare bestandsnamen.

:::warn title="Vereist een Cloud-account en kost geld"
Batchverwerking vereist een Google Cloud-account met de Vertex AI API ingeschakeld en basiskennis van Python. Vertex AI rekent per gegenereerde afbeelding af. Voor Imagen 4 is dat ongeveer `$0,02` (Fast), `$0,04` (Standard) en `$0,06` (Ultra) per afbeelding. Controleer de actuele tarieven op de prijzenpagina van Vertex AI voordat je een grote batch start.
:::

## Welke SDK gebruik je in 2026

De oudere aanpak met `vertexai.preview.vision_models.ImageGenerationModel` en het modelpunt `imagegeneration@006` is afgeschreven. Google verving die generatieve modules in de oude Vertex AI SDK door de **Google Gen AI SDK** (`google-genai`). Bouw nieuwe scripts daarom direct op die SDK en op een Imagen 4-model zoals `imagen-4.0-generate-001`.

:::tip title="Imagen 4-varianten"
Er zijn drie modelpunten: `imagen-4.0-fast-generate-001` (snel en goedkoop), `imagen-4.0-generate-001` (standaard, de prettige middenweg) en `imagen-4.0-ultra-generate-001` (hoogste detail). Begin een nieuwe batch met Fast om je prompts te testen en schakel pas naar Standard of Ultra als de richting klopt. Dat scheelt kosten tijdens het afstellen.
:::

## Vereisten instellen

### Google Cloud setup

:::howto title="Vertex AI klaarzetten"
1. Maak een Google Cloud-project aan en activeer de **Vertex AI API**.
2. Maak een serviceaccount aan met de rol `Vertex AI User`.
3. Download de JSON-sleutel van dat serviceaccount.
4. Stel de omgevingsvariabelen in:
:::

```bash
export GOOGLE_APPLICATION_CREDENTIALS="/pad/naar/credentials.json"
export GOOGLE_CLOUD_PROJECT="jouw-project-id"
export GOOGLE_CLOUD_LOCATION="us-central1"
```

### Python-omgeving

```bash
pip install google-genai Pillow
```

## Promptbestand voorbereiden

Maak een CSV-bestand met minimaal twee kolommen: `bestandsnaam` en `prompt`. De bestandsnaam bepaalt straks de uitvoernaam, dus kies meteen beschrijvende, SEO-vriendelijke namen.

```csv
bestandsnaam,prompt
product-koffiemachine-zwart,fotorealistische productfoto van een zwarte koffiemachine op witte achtergrond met zachte studioverlichting
product-koffiemachine-zilver,fotorealistische productfoto van een zilveren koffiemachine op witte achtergrond met zachte studioverlichting
blog-header-ai-tools,abstracte digitale illustratie van AI-tools in een blauw kleurenpalet met techsfeer in liggend formaat
```

## Batchgeneratie-script

Dit script leest de CSV, maakt een client voor Vertex AI en genereert per rij een afbeelding. Bestaat het uitvoerbestand al, dan slaat het script de rij over zodat je een onderbroken batch later kunt hervatten.

```python
import csv
import os
import time
from pathlib import Path

from google import genai
from google.genai.types import GenerateImagesConfig

client = genai.Client(
    vertexai=True,
    project=os.environ["GOOGLE_CLOUD_PROJECT"],
    location=os.environ.get("GOOGLE_CLOUD_LOCATION", "us-central1"),
)

MODEL = "imagen-4.0-generate-001"
OUTPUT_MAP = Path("output")
OUTPUT_MAP.mkdir(exist_ok=True)

def genereer_afbeelding(bestandsnaam: str, prompt: str) -> bool:
    uitvoerpad = OUTPUT_MAP / f"{bestandsnaam}.png"
    if uitvoerpad.exists():
        print(f"Overgeslagen (bestaat al): {bestandsnaam}")
        return True
    try:
        antwoord = client.models.generate_images(
            model=MODEL,
            prompt=prompt,
            config=GenerateImagesConfig(
                number_of_images=1,
                aspect_ratio="16:9",
                safety_filter_level="BLOCK_MEDIUM_AND_ABOVE",
                person_generation="DONT_ALLOW",
                output_mime_type="image/png",
            ),
        )
        antwoord.generated_images[0].image.save(str(uitvoerpad))
        print(f"Gegenereerd: {bestandsnaam}")
        return True
    except Exception as fout:
        print(f"Fout bij {bestandsnaam}: {fout}")
        return False

with open("prompts.csv", newline="", encoding="utf-8") as csvbestand:
    reader = csv.DictReader(csvbestand)
    for rij in reader:
        succes = genereer_afbeelding(rij["bestandsnaam"], rij["prompt"])
        if succes:
            time.sleep(1)
```

## PNG naar WebP converteren

Na generatie converteer je de PNG-bestanden naar WebP voor een veel kleinere bestandsgrootte, handig voor webgebruik.

```python
from PIL import Image
from pathlib import Path

def converteer_naar_webp(invoermap: Path, uitvoermap: Path, kwaliteit: int = 85):
    uitvoermap.mkdir(exist_ok=True)
    for png_bestand in invoermap.glob("*.png"):
        webp_pad = uitvoermap / png_bestand.with_suffix(".webp").name
        with Image.open(png_bestand) as img:
            img.save(webp_pad, "WEBP", quality=kwaliteit, method=6)
        print(f"Geconverteerd: {webp_pad.name}")

converteer_naar_webp(Path("output"), Path("output_webp"))
```

## Foutafhandeling en hervatten

Bij grote batches kunnen API-fouten optreden door quota of netwerkproblemen. Het script slaat bestanden die al bestaan over, zodat je de batch kunt hervatten zonder al gegenereerde afbeeldingen opnieuw te maken. Voeg daarnaast een foutlogboek toe zodat je achteraf precies ziet welke rijen faalden.

```python
import logging

logging.basicConfig(
    filename="batch_log.txt",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
)

logging.info("Gegenereerd: %s", bestandsnaam)
logging.error("Fout: %s - %s", bestandsnaam, fout)
```

## Rate limiting

Vertex AI hanteert quota voor het aantal aanvragen per minuut, en de exacte limiet hangt af van je project en het gekozen model. Loop je tegen `RESOURCE_EXHAUSTED`-fouten aan, verlaag dan het tempo of bouw exponential backoff in.

```python
import time

def met_backoff(func, max_pogingen=5):
    for poging in range(max_pogingen):
        try:
            return func()
        except Exception as fout:
            if poging == max_pogingen - 1:
                raise
            wacht = 2 ** poging
            print(f"Poging {poging + 1} mislukt ({fout}). Wacht {wacht}s...")
            time.sleep(wacht)
```

:::warn title="Vraag quotaverhoging op tijd aan"
Een verhoging van je quota voor afbeeldingen per minuut kan even duren om goedgekeurd te krijgen. Wil je een grote batch onder tijdsdruk draaien, vraag de verhoging dan ruim van tevoren aan via de quotapagina in de Cloud-console.
:::

## Resultaten organiseren

Na de batch heb je een map vol WebP-bestanden met beschrijvende namen. Orden ze automatisch per categorie op basis van het naamvoorvoegsel.

```python
import shutil
from pathlib import Path

categorie_map = {
    "product-": Path("output_webp/producten"),
    "blog-": Path("output_webp/blog"),
    "social-": Path("output_webp/social"),
}

for webp_bestand in Path("output_webp").glob("*.webp"):
    for prefix, bestemming in categorie_map.items():
        if webp_bestand.name.startswith(prefix):
            bestemming.mkdir(parents=True, exist_ok=True)
            shutil.move(str(webp_bestand), bestemming / webp_bestand.name)
            break
```

## Consistente stijl over de hele batch

Wil je dat alle afbeeldingen op elkaar lijken, voeg dan een vaste stijlsuffix toe aan elke prompt. Zet die als constante boven in je script, dan pas je hem op één plek aan.

```python
STIJL_SUFFIX = ", consistente vlakke illustratiestijl, zachte pastelkleuren, geen tekst in beeld"

prompt_volledig = rij["prompt"] + STIJL_SUFFIX
```

:::faq
### Hoeveel afbeeldingen kan ik in één batch verwerken?
Technisch is er geen harde bovengrens, maar in de praktijk wordt de batch begrensd door je Vertex AI-quota en je budget. Een batch van honderd afbeeldingen kost bij het standaardmodel grofweg vier euro en duurt afhankelijk van je quota en de `time.sleep` enkele minuten tot een kwartier.

### Kan ik de batch in de cloud draaien zodat mijn laptop niet aan hoeft te staan?
Ja. Verpak het script in een Docker-container en draai het eenmalig als een Cloud Run Job, of plan herhaalde batches via Cloud Scheduler die zo'n job aftrapt. Het serviceaccount van de job heeft dan de rol `Vertex AI User` nodig.

### Waarom werkt mijn oude script met imagegeneration@006 niet meer?
Het oude modelpunt en de module `vertexai.preview.vision_models` zijn afgeschreven en worden in de loop van 2026 verwijderd. Stap over op de Google Gen AI SDK (`google-genai`) en een Imagen 4-model zoals `imagen-4.0-generate-001`, zoals in het script hierboven.

### Hoe zorg ik dat alle afbeeldingen dezelfde stijl hebben?
Voeg een vaste stijlsuffix toe aan elke prompt en beheer die als één constante in je script. Houd ook overige parameters zoals `aspect_ratio` en het model gelijk over de hele batch.

### Kan ik meerdere variaties per prompt genereren?
Ja. Zet `number_of_images` op een hogere waarde (tot vier) en sla elke variant op met een eigen achtervoegsel, bijvoorbeeld van `_v1` tot `_v4`. Loop daarvoor over `antwoord.generated_images` in plaats van alleen index nul te gebruiken.

### Krijgen de afbeeldingen een watermerk?
Imagen voegt standaard een onzichtbaar SynthID-watermerk toe dat aangeeft dat het beeld door AI is gemaakt. Dat watermerk is niet zichtbaar in de afbeelding zelf en hoeft je workflow niet in de weg te zitten.
:::