Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Optimeeri pilditokeneid

Õppetund 10 / 12 Värskendatud 30. juuli 2026 Algajatele
Sellel lehel
  1. Kontrolli oma kulusid tootmises
  2. Strategia 1: Vali õige detailitase
  3. Strategia 2: Muuda suurust enne saatmist
  4. Strategia 3: Kaheastmeline töövoog
  5. Strategia 4: Vahemällu salvestamine
  6. Jälgi ja saada hoiatusi
  7. Peamised punktid

Kontrolli oma kulusid tootmises

Tootmiskeskkonnas võivad pilditokenid moodustada olulise osa sinu API arvest. Üksainus pilt režiimis high tarbib kuni 1792 tokenit – see võrdub mitme tekstilõiguga. Korruta see sadade või tuhandete päevaste päringutega ja optimeerimine muutub vajalikuks.

Strategia 1: Vali õige detailitase

Parameeter detail on sinu peamine optimeerimishoob. Kõige levinum viga on kasutada vaikimisi režiimi high, kuigi enamikul juhtudel piisab režiimist low või auto.

Otsustusmaatriks

Ülesanne Soovitatav detailitase Hinnanguline tokenite arv
Pildi klassifitseerimine low ~256
Üldine kirjeldus auto ~512-768
Alternatiivtekst / ligipääsetavus low ~256
Sisu moderatsioon auto ~512-768
OCR / teksti eraldamine high ~1024-1792
Diagrammide analüüs high ~1024-1792
Defektide tuvastamine high ~1024-1792

Strategia 2: Muuda suurust enne saatmist

Kõrge eraldusvõimega pildid (4K, 8K) on tehisintellekti analüüsiks harva vajalikud. Piltide suuruse järjepidev vähendamine enne saatmist vähendab tokenite arvu ilma analüüsi kvaliteeti märgatavalt mõjutamata.

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: Kaheastmeline töövoog

Suurte mahtude korral kasuta kaheastmelist töövoogu: esimene kiire aste režiimis low sorteerimiseks ja teine aste režiimis high ainult nende piltide jaoks, mis seda nõuavad:

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: Vahemällu salvestamine

Kui analüüsid samu pilte korduvalt (testimine, arendus, demo), salvesta tulemused vahemällu:

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

Jälgi ja saada hoiatusi

Seadista kulude jälgimine, et tuvastada ületamisi:

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
    }

Peamised punktid

  • Vali ülesandele sobiv detail tase – kasuta low, kui see piisab
  • Muuda piltide suurust enne saatmist, et vähendada tarbimist
  • Kasuta suurte mahtude korral kaheastmelist töövoogu
  • Salvesta tulemused vahemällu, et vältida korduvaid päringuid
  • Jälgi tootmises pilditokeneid, et ennustada kulusid