Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Optimalizáld a képtokeneket

10. lecke 12 közül Frissítve 2026. július 30. Kezdő
Ezen az oldalon
  1. Tartsd kordában a költségeidet éles környezetben
  2. 1. stratégia: Válaszd ki a megfelelő részletességi szintet
  3. 2. stratégia: Méretezés küldés előtt
  4. 3. stratégia: Kétlépcsős folyamat
  5. 4. stratégia: Gyorsítótárazás
  6. Monitorozás és riasztás
  7. Főbb megállapítások

Tartsd kordában a költségeidet éles környezetben

Éles környezetben a képtokenek jelentős részét tehetik ki az API-számládnak. Egyetlen kép high módban akár 1792 tokent is felemészthet – ez több bekezdésnyi szövegnek felel meg. Szorozd ezt meg napi több száz vagy ezer kéréssel, és az optimalizálás szükségszerűvé válik.

1. stratégia: Válaszd ki a megfelelő részletességi szintet

A detail paraméter a legfőbb optimalizálási eszközöd. A leggyakoribb hiba, ha alapértelmezetten a high értéket használod, amikor a legtöbb esetben a low vagy az auto is elegendő.

Döntési mátrix

Feladat Ajánlott részletesség Becsült tokenek
Képosztályozás low ~256
Általános leírás auto ~512-768
Alt szöveg / akadálymentesítés low ~256
Tartalommoderálás auto ~512-768
OCR / szövegkinyerés high ~1024-1792
Diagram-elemzés high ~1024-1792
Hibadetektálás high ~1024-1792

2. stratégia: Méretezés küldés előtt

A nagy felbontású képek (4K, 8K) ritkán szükségesek az AI-elemzéshez. Ha küldés előtt következetesen átméretezed a képeidet, csökkentheted a tokenfelhasználást anélkül, hogy az elemzés minősége észrevehetően romlana.

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

3. stratégia: Kétlépcsős folyamat

Nagy mennyiségű adat esetén alkalmazz kétlépcsős folyamatot: egy gyors első lépést low módban a rendezéshez, majd egy második lépést high módban csak azoknál a képeknél, amelyeknél ez szükséges:

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

4. stratégia: Gyorsítótárazás

Ha ugyanazokat a képeket többször is elemzed (tesztelés, fejlesztés, bemutató), gyorsítótárazd az eredményeket:

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

Monitorozás és riasztás

Állíts be költségkövetést a túllépések észlelésére:

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
    }

Főbb megállapítások

  • Válaszd a feladathoz illő detail szintet – használd a low értéket, amikor az elegendő
  • Méretezd át a képeket küldés előtt a fogyasztás csökkentése érdekében
  • Alkalmazz kétlépcsős folyamatot nagy mennyiségű adat esetén
  • Gyorsítótárazd az eredményeket a felesleges hívások elkerülése végett
  • Monitorozd a képtokeneket éles környezetben a költségek előrejelzése érdekében