Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Optimera bildtoken

Lektion 10 av 12 Uppdaterad 30 juli 2026 Nybörjare
På denna sida
  1. Kontrollera dina kostnader i produktion
  2. Strategi 1: Välj rätt detaljnivå
  3. Strategi 2: Ändra storlek innan sändning
  4. Strategi 3: Pipeline i två steg
  5. Strategi 4: Cachelagring
  6. Övervaka och varna
  7. Viktiga punkter

Kontrollera dina kostnader i produktion

I produktionsmiljöer kan bildtoken utgöra en betydande del av din API-faktura. En enda bild i läget high förbrukar upp till 1 792 token – vilket motsvarar flera stycken text. Multiplicera detta med hundratals eller tusentals dagliga förfrågningar, så blir optimering en nödvändighet.

Strategi 1: Välj rätt detaljnivå

Parametern detail är din främsta hävstång för optimering. Det vanligaste misstaget är att använda high som standard när low eller auto räcker i de flesta fall.

Beslutsmatris

Uppgift Rekommenderad detaljnivå Uppskattade token
Bildklassificering low ~256
Generell beskrivning auto ~512-768
Alt-text / tillgänglighet low ~256
Innehållsmoderering auto ~512-768
OCR / textextrahering high ~1024-1792
Diagramanalys high ~1024-1792
Feldetektering high ~1024-1792

Strategi 2: Ändra storlek innan sändning

Högupplösta bilder (4K, 8K) är sällan nödvändiga för AI-analys. Genom att konsekvent ändra storlek på dina bilder innan du skickar dem minskar du antalet token utan märkbar påverkan på analyskvaliteten.

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: Pipeline i två steg

För höga volymer bör du använda en pipeline i två steg: en snabb första omgång med low för sortering, följt av en andra omgång med high endast för de bilder som 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: Cachelagring

Om du analyserar samma bilder flera gånger (tester, utveckling, demo) bör du cachelagra resultaten:

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

Övervaka och varna

Sätt upp kostnadsövervakning för att upptäcka överskridanden:

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
    }

Viktiga punkter

  • Välj den detail-nivå som passar uppgiften – använd low när det räcker
  • Ändra storlek på bilder innan sändning för att minska förbrukningen
  • Använd en pipeline i två steg för höga volymer
  • Cachelagra resultat för att undvika onödiga anrop
  • Övervaka bildtoken i produktion för att förutse kostnader