Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Optimizuokite vaizdo žetonus

Paskaita 10 iš 12 Atnaujinta 2026 m. liepos 30 d. Pradedantisiems
Šiame puslapyje
  1. Valdymo išlaidos gamyboje
  2. 1 strategija: Pasirinkite tinkamą detalumo lygį
  3. 2 strategija: Keiskite dydį prieš siųsdami
  4. 3 strategija: Dviejų etapų konvejeris
  5. 4 strategija: Talpykla (Caching)
  6. Stebėkite ir nustatykite įspėjimus
  7. Svarbiausi punktai

Valdymo išlaidos gamyboje

Gamyboje vaizdo žetonai gali sudaryti didelę jūsų API sąskaitos dalį. Vienas vaizdas „high“ režimu sunaudoja iki 1 792 žetonų – tai prilygsta keliems teksto pastraipoms. Padauginkite tai iš šimtų ar tūkstančių kasdienių užklausų, ir optimizavimas tampa būtinybe.

1 strategija: Pasirinkite tinkamą detalumo lygį

Parametras detail yra jūsų pagrindinis optimizavimo svertas. Dažniausia klaida – pagal nutylėjimą naudoti high, kai daugeliu atvejų pakanka low arba auto.

Sprendimų matrica

Užduotis Rekomenduojamas detalumas Apytikslis žetonų skaičius
Vaizdų klasifikavimas low ~256
Bendras aprašymas auto ~512-768
Alternatyvusis tekstas / prieinamumas low ~256
Turinio moderavimas auto ~512-768
OCR / teksto ištraukimas high ~1024-1792
Diagramų analizė high ~1024-1792
Defektų aptikimas high ~1024-1792

2 strategija: Keiskite dydį prieš siųsdami

Didelės raiškos vaizdai (4K, 8K) dirbtinio intelekto analizei retai kada yra būtini. Nuosekliai keisdami vaizdų dydį prieš siųsdami juos, sumažinsite žetonų skaičių nepaveikdami analizės kokybės.

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 strategija: Dviejų etapų konvejeris

Dirbdami su dideliais kiekiais, naudokite dviejų etapų konvejerį – greitą pirmąjį etapą režimu low rūšiavimui, o antrąjį etapą režimu high – tik tiems vaizdams, kuriems to reikia:

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 strategija: Talpykla (Caching)

Jei tuos pačius vaizdus analizuojate kelis kartus (testavimas, kūrimas, demonstravimas), saugokite rezultatus talpykloje:

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

Stebėkite ir nustatykite įspėjimus

Nustatykite išlaidų stebėseną, kad aptiktumėte viršijimus:

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
    }

Svarbiausi punktai

  • Pasirinkite užduočiai tinkamą detail lygį – naudokite low, kai to pakanka
  • Prieš siųsdami pakeiskite vaizdų dydį, kad sumažintumėte suvartojimą
  • Dideliems kiekiams naudokite dviejų etapų konvejerį
  • Saugokite rezultatus talpykloje, kad išvengtumėte pasikartojančių užklausų
  • Gamyboje stebėkite vaizdo žetonus, kad galėtumėte numatyti išlaidas