Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimér billed-tokens

Lektion 10 af 12 Opdateret 30. juli 2026 Begynder
På denne side
  1. Styr dine omkostninger i produktion
  2. Strategi 1: Vælg det rette detaljeniveau
  3. Strategi 2: Ændr størrelse før afsendelse
  4. Strategi 3: To-trins pipeline
  5. Strategi 4: Caching
  6. Overvåg og varsling
  7. Vigtige pointer

Styr dine omkostninger i produktion

I produktion kan billed-tokens udgøre en betydelig del af din API-regning. Et enkelt billede i high-tilstand bruger op til 1.792 tokens – svarende til flere tekstafsnit. Gang det med hundredevis eller tusindvis af daglige forespørgsler, og optimering bliver en nødvendighed.

Strategi 1: Vælg det rette detaljeniveau

Parameteren detail er dit primære værktøj til optimering. Den mest almindelige fejl er at bruge high som standard, når low eller auto er tilstrækkeligt i de fleste tilfælde.

Beslutningsmatrix

Opgave Anbefalet detalje Estimerede tokens
Billedklassificering low ~256
Generel beskrivelse auto ~512-768
Alt-tekst / tilgængelighed low ~256
Indholdsmoderation auto ~512-768
OCR / tekstudtræk high ~1024-1792
Diagramanalyse high ~1024-1792
Fejldetektion high ~1024-1792

Strategi 2: Ændr størrelse før afsendelse

Billeder i høj opløsning (4K, 8K) er sjældent nødvendige til AI-analyse. Ved konsekvent at ændre størrelsen på dine billeder, før du sender dem, reducerer du antallet af tokens uden mærkbar påvirkning af analysekvaliteten.

from PIL import Image
import io
import base64

class OptimiseurImage:
    TAILLES_PAR_TACHE = {
        "classification": (512, 512),
        "description": (1024, 1024),
        "ocr": (2048, 2048),
        "comparison": (800, 800),
    }

    @staticmethod
    def optimiser(chemin, tache="description", qualite=85):
        taille_max = OptimiseurImage.TAILLES_PAR_TACHE.get(
            tache, (1024, 1024)
        )

        img = Image.open(chemin)

        # Do not enlarge small images
        if img.width <= taille_max[0] and img.height <= taille_max[1]:
            pass
        else:
            img.thumbnail(taille_max)

        # Convert to JPEG to reduce size
        if img.mode in ("RGBA", "P"):
            img = img.convert("RGB")

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

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

Strategi 3: To-trins pipeline

Ved store mængder bør du bruge en to-trins pipeline: en hurtig første gennemgang i low til sortering, efterfulgt af en anden gennemgang i high kun for de billeder, der kræver det:

def pipeline_deux_passes(images):
    # Pass 1: fast classification (low)
    classifications = []
    for img in images:
        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": img, "detail": "low"},
                {"type": "input_text", "text": "Classify: document, photo, chart, other. One word."}
            ],
            store=False
        )
        classifications.append({
            "url": img,
            "type": response.output_text.strip().lower()
        })

    # Pass 2: detailed analysis (high) only if necessary
    resultats = []
    for item in classifications:
        if item["type"] in ("document", "chart"):
            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": "Detailed analysis of this image."}
            ],
            store=False
        )
        resultats.append(response.output_text)

    return resultats

Strategi 4: Caching

Hvis du analyserer de samme billeder flere gange (tests, udvikling, demo), så cach resultaterne:

import hashlib
import json

cache = {}

def vision_avec_cache(image_url, prompt, detail="auto"):
    # Create a unique key
    cle = hashlib.sha256(
        f"{image_url}:{prompt}:{detail}".encode()
    ).hexdigest()

    if cle in cache:
        return cache[cle]

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

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

Overvåg og varsling

Opsæt omkostningssporing for at opdage overskridelser:

def monitorer_tokens(response, seuil_alerte=5000):
    usage = response.usage
    image_tokens = usage.prompt_tokens_details.image_tokens

    if image_tokens > seuil_alerte:
        print(f"ALERT: {image_tokens} image tokens (threshold: {seuil_alerte})")

    return {
        "image_tokens": image_tokens,
        "text_tokens": usage.prompt_tokens_details.text_tokens,
        "total": usage.total_tokens
    }

Vigtige pointer

  • Vælg det detail-niveau, der passer til opgaven – brug low, når det er tilstrækkeligt
  • Ændr størrelse på billeder før afsendelse for at reducere forbruget
  • Brug en to-trins pipeline ved store mængder
  • Cach resultater for at undgå redundante kald
  • Overvåg billed-tokens i produktion for at forudse omkostninger