Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Optimiziraj tokene slika

Lekcija 10 od 12 Ažurirano 30. srpnja 2026. Početnik
Na ovoj stranici
  1. Kontroliraj troškove u proizvodnji
  2. Strategija 1: Odaberi pravu razinu detalja
  3. Strategija 2: Promijeni veličinu prije slanja
  4. Strategija 3: Cjevovod s dva prolaza
  5. Strategija 4: Predmemoriranje (Caching)
  6. Praćenje i upozorenja
  7. Ključne točke

Kontroliraj troškove u proizvodnji

U proizvodnom okruženju, tokeni slika mogu činiti značajan dio tvog računa za API. Jedna slika u načinu high troši do 1.792 tokena—što odgovara nekoliko odlomaka teksta. Pomnoži li to sa stotinama ili tisućama dnevnih zahtjeva, optimizacija postaje nužnost.

Strategija 1: Odaberi pravu razinu detalja

Parametar detail tvoja je glavna poluga za optimizaciju. Najčešća greška je korištenje high kao zadane vrijednosti kada su low ili auto u većini slučajeva sasvim dovoljni.

Matrica odlučivanja

Zadatak Preporučeni detalj Procijenjeni tokeni
Klasifikacija slike low ~256
Opći opis auto ~512-768
Alt tekst / pristupačnost low ~256
Moderacija sadržaja auto ~512-768
OCR / izvlačenje teksta high ~1024-1792
Analiza grafikona high ~1024-1792
Detekcija nedostataka high ~1024-1792

Strategija 2: Promijeni veličinu prije slanja

Slike visoke rezolucije (4K, 8K) rijetko su potrebne za AI analizu. Dosljedna promjena veličine tvojih slika prije slanja smanjuje broj tokena bez primjetnog utjecaja na kvalitetu 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: Cjevovod s dva prolaza

Za velike volumene podataka koristi cjevovod s dva prolaza—brzi prvi prolaz u načinu low za sortiranje, zatim drugi prolaz u načinu high samo za slike koje to zahtijevaju:

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

Ako analiziraš iste slike više puta (testovi, razvoj, demo), predmemoriraj 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

Praćenje i upozorenja

Postavi praćenje troškova kako bi otkrio/la prekoračenja:

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 točke

  • Odaberi razinu detail prilagođenu zadatku—low kada je dovoljna
  • Promijeni veličinu slika prije slanja kako bi smanjio/la potrošnju
  • Koristi cjevovod s dva prolaza za velike volumene
  • Predmemoriraj rezultate kako bi izbjegao/la suvišne pozive
  • Prati tokene slika u proizvodnji kako bi anticipirao/la troškove