Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Optimalizace tokenů obrázků

Lekce 10 z 12 Aktualizováno 30. července 2026 Začátečník
Na této stránce
  1. Kontroluj své náklady v produkci
  2. Strategie 1: Vyber správnou úroveň detailu
  3. Strategie 2: Změň velikost před odesláním
  4. Strategie 3: Dvouprůchodový pipeline
  5. Strategie 4: Mezipaměť (Caching)
  6. Sledování a alerty
  7. Klíčové poznatky

Kontroluj své náklady v produkci

V produkčním prostředí mohou tokeny za obrázky tvořit významnou část tvého účtu za API. Jediný obrázek v režimu high spotřebuje až 1 792 tokenů – což odpovídá několika odstavcům textu. Vynásob si to stovkami či tisíci denních požadavků a optimalizace se stane nutností.

Strategie 1: Vyber správnou úroveň detailu

Parametr detail je tvým hlavním nástrojem pro optimalizaci. Nejčastější chybou je výchozí používání režimu high, když ve většině případů stačí low nebo auto.

Rozhodovací matice

Úkol Doporučený detail Odhadovaný počet tokenů
Klasifikace obrázků low ~256
Obecný popis auto ~512-768
Alternativní text / přístupnost low ~256
Moderace obsahu auto ~512-768
OCR / extrakce textu high ~1024-1792
Analýza grafů high ~1024-1792
Detekce vad high ~1024-1792

Strategie 2: Změň velikost před odesláním

Obrázky s vysokým rozlišením (4K, 8K) jsou pro analýzu AI zřídka nutné. Důsledná změna velikosti obrázků před jejich odesláním sníží počet tokenů bez znatelného dopadu na kvalitu analýzy.

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

Strategie 3: Dvouprůchodový pipeline

Při vysokých objemech použij dvouprůchodový pipeline – rychlý první průchod v režimu low pro třídění a následně druhý průchod v režimu high pouze pro obrázky, které to vyžadují:

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

Strategie 4: Mezipaměť (Caching)

Pokud analyzuješ stejné obrázky vícekrát (testy, vývoj, demo), ukládej výsledky do mezipaměti:

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

Sledování a alerty

Nastav si sledování nákladů, abys odhalil překročení limitů:

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
    }

Klíčové poznatky

  • Vyber úroveň detail přizpůsobenou úkolu – použij low, když to stačí
  • Změň velikost obrázků před odesláním, abys snížil spotřebu
  • Pro vysoké objemy použij dvouprůchodový pipeline
  • Ukládej výsledky do mezipaměti, abys předešel zbytečným voláním
  • Sleduj tokeny obrázků v produkci, abys dokázal předvídat náklady