Przejdź do głównej treści
Polski— Wybierz język
Menu

Optymalizacja tokenów obrazowych

Lekcja 10 z 12 Zaktualizowano 30 lipca 2026 Początkujący
Na tej stronie
  1. Kontroluj koszty w środowisku produkcyjnym
  2. Strategia 1: Wybierz odpowiedni poziom szczegółowości
  3. Strategia 2: Zmiana rozmiaru przed wysłaniem
  4. Strategia 3: Potok dwuetapowy
  5. Strategia 4: Buforowanie (Caching)
  6. Monitorowanie i alerty
  7. Kluczowe wnioski

Kontroluj koszty w środowisku produkcyjnym

W środowisku produkcyjnym tokeny obrazowe mogą stanowić znaczną część Twojego rachunku za API. Pojedynczy obraz w trybie high zużywa do 1792 tokenów – co odpowiada kilku akapitom tekstu. Pomnóż to przez setki lub tysiące codziennych żądań, a optymalizacja staje się koniecznością.

Strategia 1: Wybierz odpowiedni poziom szczegółowości

Parametr detail to Twój główny dźwignia optymalizacji. Najczęstszym błędem jest domyślne używanie high, gdy w większości przypadków wystarczające są low lub auto.

Macierz decyzyjna

Zadanie Zalecany poziom szczegółowości Szacowana liczba tokenów
Klasyfikacja obrazów low ~256
Ogólny opis auto ~512-768
Tekst alternatywny / dostępność low ~256
Moderacja treści auto ~512-768
OCR / ekstrakcja tekstu high ~1024-1792
Analiza wykresów high ~1024-1792
Wykrywanie дефекtów high ~1024-1792

Strategia 2: Zmiana rozmiaru przed wysłaniem

Obrazy o wysokiej rozdzielczości (4K, 8K) rzadko są niezbędne do analizy przez AI. Konsekwentna zmiana rozmiaru obrazów przed ich wysłaniem redukuje liczbę tokenów bez zauważalnego wpływu na jakość analizy.

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: Potok dwuetapowy

Przy dużych wolumenach zastosuj potok dwuetapowy – szybkie pierwsze przejście w trybie low do sortowania, a następnie drugie przejście w trybie high tylko dla obrazów, które tego wymagają:

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

Jeśli analizujesz te same obrazy wielokrotnie (testy, rozwój, demonstracje), buforuj wyniki:

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

Monitorowanie i alerty

Skonfiguruj śledzenie kosztów, aby wykrywać przekroczenia:

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
    }

Kluczowe wnioski

  • Wybierz poziom detail dostosowany do zadania – używaj low, gdy to wystarczające
  • Zmień rozmiar obrazów przed wysłaniem, aby zmniejszyć zużycie
  • Stosuj potok dwuetapowy przy dużych wolumenach
  • Buforuj wyniki, aby uniknąć nadmiarowych wywołań
  • Monitoruj tokeny obrazowe w środowisku produkcyjnym, aby przewidzieć koszty