Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Optimizē attēlu tokenus

Nodarbība 10 no 12 Atjaunota 2026. gada 30. jūlijs Iesācējs
Šajā lapā
  1. Kontrolē izmaksas ražošanas vidē
  2. 1. stratēģija: izvēlies pareizo detalizācijas līmeni
  3. 2. stratēģija: maini izmēru pirms nosūtīšanas
  4. 3. stratēģija: divu posmu konveijers
  5. 4. stratēģija: kešošana
  6. Uzraugi un brīdini
  7. Galvenās atziņas

Kontrolē izmaksas ražošanas vidē

Ražošanas vidē attēlu tokeni var veidot ievērojamu daļu no tava API rēķina. Viens attēls režīmā high patērē līdz 1792 tokeniem – tas ir līdzvērtīgs vairākiem teksta rindkopām. Reizini to ar simtiem vai tūkstošiem ikdienas pieprasījumu, un optimizācija kļūst par nepieciešamību.

1. stratēģija: izvēlies pareizo detalizācijas līmeni

Parametrs detail ir tavs galvenais optimizācijas instruments. Visbiežākā kļūda ir pēc noklusējuma lietot high, lai gan vairumā gadījumu pietiek ar low vai auto.

Lēmumu matrica

Uzdevums Ieteicamais detalizācijas līmenis Aplēstais tokenu skaits
Attēlu klasifikācija low ~256
Vispārīgs apraksts auto ~512-768
Alternatīvais teksts / pieejamība low ~256
Satura moderācija auto ~512-768
OCR / teksta ekstrakcija high ~1024-1792
Diagrammu analīze high ~1024-1792
Defektu noteikšana high ~1024-1792

2. stratēģija: maini izmēru pirms nosūtīšanas

Augstas izšķirtspējas attēli (4K, 8K) AI analīzei reti ir nepieciešami. Konsekventa attēlu izmēra mainīšana pirms nosūtīšanas samazina tokenus, neietekmējot uztverami analīzes kvalitāti.

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ēģija: divu posmu konveijers

Lieliem apjomiem izmanto divu posmu konveijeru – ātru pirmo posmu režīmā low šķirošanai, un tad otro posmu režīmā high tikai tiem attēliem, kuriem tas nepieciešams:

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ēģija: kešošana

Ja analizē tos pašus attēlus vairākas reizes (testēšana, izstrāde, demonstrācijas), kešo rezultātus:

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

Uzraugi un brīdini

Izveido izmaksu izsekošanu, lai noteiktu pārsniegumus:

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
    }

Galvenās atziņas

  • Izvēlies uzdevumam piemērotu detail līmeni – lieto low, ja tas ir pietiekami
  • Maini attēlu izmēru pirms nosūtīšanas, lai samazinātu patēriņu
  • Lieliem apjomiem izmanto divu posmu konveijeru
  • Kešo rezultātus, lai izvairītos no liekiem izsaukumiem
  • Ražošanas vidē uzraugi attēlu tokenus, lai prognozētu izmaksas