Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Optimoi kuvatokenit

Oppitunti 10 / 12 Päivitetty 30. heinäkuuta 2026 Aloittelija
Tällä sivulla
  1. Hallitse kustannuksia tuotannossa
  2. Strategia 1: Valitse oikea tarkkuustaso
  3. Strategia 2: Muuta kokoa ennen lähetystä
  4. Strategia 3: Kahden vaiheen putki
  5. Strategia 4: Välimuisti
  6. Seuraa ja hälytä
  7. Keskeiset asiat

Hallitse kustannuksia tuotannossa

Tuotantoympäristössä kuvatokenit voivat muodostaa merkittävän osan API-laskustasi. Yksi kuva high-tilassa kuluttaa jopa 1 792 tokenia – tämä vastaa useita tekstikappaleita. Kerro tämä sadoilla tai tuhansilla päivittäisillä pyynnöillä, ja optimoinnista tulee välttämättömyys.

Strategia 1: Valitse oikea tarkkuustaso

detail-parametri on ensisijainen optimointivipusi. Yleisin virhe on käyttää oletuksena arvoa high, vaikka low tai auto riittäisivät useimmissa tapauksissa.

Päätösmatriisi

Tehtävä Suositeltu tarkkuus Arvioidut tokenit
Kuvien luokittelu low ~256
Yleiskuvaus auto ~512-768
Alt-teksti / saavutettavuus low ~256
Sisällön moderointi auto ~512-768
OCR / tekstin erottelu high ~1024-1792
Kaavioiden analyysi high ~1024-1792
Vikojen havaitseminen high ~1024-1792

Strategia 2: Muuta kokoa ennen lähetystä

Suuriresoluutioiset kuvat (4K, 8K) ovat harvoin tarpeen tekoälyanalyysille. Kuvien koon johdonmukainen pienentäminen ennen lähetystä vähentää tokenien määrää vaikuttamatta havaittavasti analyysin laatuun.

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}"

Strategia 3: Kahden vaiheen putki

Suurissa volyymeissä käytä kahden vaiheen putkea: nopea ensimmäinen vaihe tilassa low lajittelua varten, ja toinen vaihe tilassa high vain niille kuville, jotka sitä vaativat:

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

Strategia 4: Välimuisti

Jos analysoit samoja kuvia useita kertoja (testaus, kehitys, demo), tallenna tulokset välimuistiin:

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

Seuraa ja hälytä

Ota käyttöön kustannusseuranta havaitaksesi ylitykset:

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
    }

Keskeiset asiat

  • Valitse tehtävään sopiva detail-taso – käytä low, kun se riittää
  • Muuta kuvien kokoa ennen lähetystä kulutuksen vähentämiseksi
  • Käytä kahden vaiheen putkea suurissa volyymeissä
  • Tallenna tulokset välimuistiin välttääksesi tarpeettomia pyyntöjä
  • Seuraa kuvatokeneita tuotannossa ennakoivasti kustannusten hallitsemiseksi