Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Optimalizácia tokenov obrázkov

Lekcia 10 z 12 Aktualizované 30. júla 2026 Začiatočník
Na tejto strane
  1. Kontroluj svoje náklady v produkcii
  2. Stratégia 1: Vyber si správnu úroveň detailu
  3. Stratégia 2: Zmeň veľkosť pred odoslaním
  4. Stratégia 3: Dvojfázový pipeline
  5. Stratégia 4: Ukladanie do vyrovnávacej pamäte (Caching)
  6. Monitorovanie a alerty
  7. Kľúčové poznatky

Kontroluj svoje náklady v produkcii

V produkčnom prostredí môžu tokeny za obrázky tvoriť významnú časť vášho účtu za API. Jediný obrázok v režime high spotrebuje až 1 792 tokenov – čo zodpovedá niekoľkým odstavcom textu. Vynásobte to stovkami alebo tisíckami denných požiadaviek a optimalizácia sa stáva nevyhnutnosťou.

Stratégia 1: Vyber si správnu úroveň detailu

Parameter detail je tvojím hlavným nástrojom na optimalizáciu. Najčastejšou chybou je používať predvolene hodnotu high, hoci vo väčšine prípadov stačí low alebo auto.

Rozhodovacia matica

Úloha Odporúčaný detail Odhadovaný počet tokenov
Klasifikácia obrázkov low ~256
Všeobecný opis auto ~512-768
Alternatívny text / prístupnosť low ~256
Moderovanie obsahu auto ~512-768
OCR / extrakcia textu high ~1024-1792
Analýza grafov high ~1024-1792
Detekcia defektov high ~1024-1792

Stratégia 2: Zmeň veľkosť pred odoslaním

Obrázky s vysokým rozlíšením (4K, 8K) sú pre analýzu AI zriedka potrebné. Dôsledná zmena veľkosti obrázkov pred ich odoslaním znižuje počet tokenov bez citeľného vplyvu 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}"

Stratégia 3: Dvojfázový pipeline

Pri vysokých objemoch použij dvojfázový pipeline – rýchly prvý prechod v režime low na triedenie a následne druhý prechod v režime high len pre obrázky, ktoré si 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

Stratégia 4: Ukladanie do vyrovnávacej pamäte (Caching)

Ak analyzuješ tie isté obrázky viackrát (testy, vývoj, demo), ukladaj výsledky do vyrovnávacej pamäte:

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

Monitorovanie a alerty

Nastav si sledovanie nákladov na odhalenie prekročenia limitov:

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
    }

Kľúčové poznatky

  • Vyber si úroveň detail primeranú úlohe – použij low, keď to stačí
  • Zmeň veľkosť obrázkov pred odoslaním, aby si znížil spotrebu
  • Pre vysoké objemy použij dvojfázový pipeline
  • Ukladaj výsledky do vyrovnávacej pamäte, aby si sa vyhol zbytočným volaniam
  • Monitoruj tokeny obrázkov v produkcii, aby si predvídal náklady