Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Optimiziraj žetone slik

Lekcija 10 od 12 Posodobljeno 30. julij 2026 Začetnik
Na tej strani
  1. Nadzoruj svoje stroške v produkciji
  2. Strategija 1: Izberi ustrezno raven podrobnosti
  3. Strategija 2: Spremeni velikost pred pošiljanjem
  4. Strategija 3: Cevovod z dvema prehodoma
  5. Strategija 4: Predpomnenje
  6. Spremljaj in opozarjaj
  7. Ključne ugotovitve

Nadzoruj svoje stroške v produkciji

V produkcijskem okolju lahko žetoni za slike predstavljajo znaten del vašega računa za API. Ena sama slika v načinu high porabi do 1.792 žetonov, kar ustreza več odstavkom besedila. To pomnožite s stotinami ali tisoči dnevnih zahtevkov in optimizacija postane nujnost.

Strategija 1: Izberi ustrezno raven podrobnosti

Parameter detail je tvoja glavna vzvod za optimizacijo. Najpogostejša napaka je privzeta uporaba vrednosti high, čeprav v večini primerov zadostujeta low ali auto.

Matrika odločanja

Naloga Priporočena podrobnost Ocenjeni žetoni
Klasifikacija slik low ~256
Splošen opis auto ~512-768
Nadomestno besedilo / dostopnost low ~256
Moderacija vsebine auto ~512-768
OCR / ekstrakcija besedila high ~1024-1792
Analiza grafikona high ~1024-1792
Zaznavanje napak high ~1024-1792

Strategija 2: Spremeni velikost pred pošiljanjem

Slike z visoko ločljivostjo (4K, 8K) so za analizo z umetno inteligenco redko potrebne. Dosledna sprememba velikosti slik pred pošiljanjem zmanjša število žetonov brez opaznega vpliva na kakovost analize.

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

Strategija 3: Cevovod z dvema prehodoma

Pri velikih količinah uporabi cevovod z dvema prehodoma – hiter prvi prehod v načinu low za razvrščanje, nato pa drugi prehod v načinu high samo za slike, ki to zahtevajo:

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

Strategija 4: Predpomnenje

Če iste slike analiziraš večkrat (testiranje, razvoj, demonstracije), predpomni rezultate:

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

Spremljaj in opozarjaj

Nastavi sledenje stroškom za zaznavanje presežkov:

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
    }

Ključne ugotovitve

  • Izberi raven detail, ki ustreza nalogi – uporabi low, kadar je to dovolj
  • Spremeni velikost slik pred pošiljanjem, da zmanjšaš porabo
  • Za velike količine uporabi cevovod z dvema prehodoma
  • Predpomni rezultate, da se izogneš odvečnim klicem
  • V produkciji spremljaj žetone slik, da predvidiš stroške