Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Optimaliseer imagetokens

Les 10 van 12 Bijgewerkt op 30 juli 2026 Beginner
Op deze pagina
  1. Beheer uw kosten in productie
  2. Strategie 1: Kies het juiste detailniveau
  3. Strategie 2: Formaat wijzigen voordat u verzendt
  4. Strategie 3: Tweefasen-pipeline
  5. Strategie 4: Caching
  6. Bewaken en waarschuwen
  7. Belangrijkste punten

Beheer uw kosten in productie

In productieomgevingen kunnen imagetokens een aanzienlijk deel van uw API-factuur uitmaken. Een enkele afbeelding in de high-modus verbruikt tot 1.792 tokens—het equivalent van meerdere alinea’s tekst. Vermenigvuldig dit met honderden of duizenden dagelijkse verzoeken, en optimalisatie wordt een noodzaak.

Strategie 1: Kies het juiste detailniveau

De parameter detail is uw belangrijkste hefboom voor optimalisatie. De meest gemaakte fout is standaard high gebruiken wanneer low of auto in de meeste gevallen volstaan.

Beslissingsmatrix

Taak Aanbevolen detail Geschatte tokens
Afbeeldingsclassificatie low ~256
Algemene beschrijving auto ~512-768
Alt-tekst / toegankelijkheid low ~256
Contentmoderatie auto ~512-768
OCR / tekstextractie high ~1024-1792
Grafiekanalyse high ~1024-1792
Defectdetectie high ~1024-1792

Strategie 2: Formaat wijzigen voordat u verzendt

Afbeeldingen met hoge resolutie (4K, 8K) zijn zelden nodig voor AI-analyse. Door uw afbeeldingen consequent te verkleinen voordat u ze verzendt, reduceert u het aantal tokens zonder merkbare impact op de analysekwaliteit.

from PIL import Image
import io
import base64

class ImageOptimalisator:
    GROOTTES_PER_TAAK = {
        "classificatie": (512, 512),
        "beschrijving": (1024, 1024),
        "ocr": (2048, 2048),
        "vergelijking": (800, 800),
    }

    @staticmethod
    def optimaliseer(pad, taak="beschrijving", kwaliteit=85):
        max_grootte = ImageOptimalisator.GROOTTES_PER_TAAK.get(
            taak, (1024, 1024)
        )

        img = Image.open(pad)

        # Kleine afbeeldingen niet vergroten
        if img.width <= max_grootte[0] and img.height <= max_grootte[1]:
            pass
        else:
            img.thumbnail(max_grootte)

        # Converteren naar JPEG om grootte te verkleinen
        if img.mode in ("RGBA", "P"):
            img = img.convert("RGB")

        buffer = io.BytesIO()
        img.save(buffer, "JPEG", quality=kwaliteit)
        buffer.seek(0)

        encoded = base64.standard_b64encode(buffer.read()).decode()
        return f"data:image/jpeg;base64,{encoded}"

Strategie 3: Tweefasen-pipeline

Voor grote volumes gebruikt u een tweefasen-pipeline: een snelle eerste fase in low om te sorteren, gevolgd door een tweede fase in high alleen voor afbeeldingen die dit vereisen:

def pipeline_twee_fasen(afbeeldingen):
    # Fase 1: snelle classificatie (low)
    classificaties = []
    for img in afbeeldingen:
        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": img, "detail": "low"},
                {"type": "input_text", "text": "Classificeer: document, foto, grafiek, overig. Eén woord."}
            ],
            store=False
        )
        classificaties.append({
            "url": img,
            "type": response.output_text.strip().lower()
        })

    # Fase 2: gedetailleerde analyse (high) alleen indien nodig
    resultaten = []
    for item in classificaties:
        if item["type"] in ("document", "grafiek"):
            detail = "high"
        else:
            detail = "auto"

        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": item["url"], "detail": detail},
                {"type": "input_text", "text": "Gedetailleerde analyse van deze afbeelding."}
            ],
            store=False
        )
        resultaten.append(response.output_text)

    return resultaten

Strategie 4: Caching

Als u dezelfde afbeeldingen meerdere keren analyseert (tests, ontwikkeling, demo’s), cache dan de resultaten:

import hashlib
import json

cache = {}

def visie_met_cache(afbeelding_url, prompt, detail="auto"):
    # Maak een unieke sleutel
    sleutel = hashlib.sha256(
        f"{afbeelding_url}:{prompt}:{detail}".encode()
    ).hexdigest()

    if sleutel in cache:
        return cache[sleutel]

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": afbeelding_url, "detail": detail},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )

    cache[sleutel] = response.output_text
    return response.output_text

Bewaken en waarschuwen

Stel kostentracking in om overschrijdingen te detecteren:

def tokens_bewaken(response, drempel_waarschuwing=5000):
    gebruik = response.usage
    image_tokens = gebruik.prompt_tokens_details.image_tokens

    if image_tokens > drempel_waarschuwing:
        print(f"WAARSCHUWING: {image_tokens} imagetokens (drempel: {drempel_waarschuwing})")

    return {
        "image_tokens": image_tokens,
        "text_tokens": gebruik.prompt_tokens_details.text_tokens,
        "totaal": gebruik.total_tokens
    }

Belangrijkste punten

  • Kies het detail-niveau dat bij de taak past—gebruik low wanneer dit voldoende is
  • Wijzig het formaat van afbeeldingen voordat u ze verzendt om het verbruik te verlagen
  • Gebruik een tweefasen-pipeline voor grote volumes
  • Cache resultaten om redundante oproepen te voorkomen
  • Bewaak imagetokens in productie om kosten te anticiperen