Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Bild-Token optimieren

Lektion 10 von 12 Aktualisiert am 30. Juli 2026 Anfänger
Auf dieser Seite
  1. Kosten in der Produktion steuern
  2. Strategie 1: Das richtige Detailniveau wählen
  3. Strategie 2: Vor dem Senden vergrößern
  4. Strategie 3: Zweistufiges Pipeline
  5. Strategie 4: Caching
  6. Überwachen und Alarm setzen
  7. Kernaussagen

Kosten in der Produktion steuern

In der Produktion können Bild-Token einen erheblichen Teil Ihrer API-Rechnung ausmachen. Ein einzelnes Bild im high-Modus verbraucht bis zu 1.792 Token – das entspricht mehreren Absätzen Text. Multipliziert man dies mit hunderten oder tausenden täglichen Anfragen, wird Optimierung zur Notwendigkeit.

Strategie 1: Das richtige Detailniveau wählen

Der Parameter detail ist Ihr primärer Hebel zur Optimierung. Der häufigste Fehler besteht darin, standardmäßig high zu verwenden, obwohl low oder auto in den meisten Fällen ausreichen.

Entscheidungsmatrix

Aufgabe Empfohlenes Detail Geschätzte Token
Bildklassifizierung low ~256
Allgemeine Beschreibung auto ~512-768
Alt-Text / Barrierefreiheit low ~256
Inhaltsmoderation auto ~512-768
OCR / Textextraktion high ~1024-1792
Diagrammanalyse high ~1024-1792
Fehlererkennung high ~1024-1792

Strategie 2: Vor dem Senden vergrößern

Hochauflösende Bilder (4K, 8K) sind für KI-Analysen selten notwendig. Das konsequente Verkleinern Ihrer Bilder vor dem Senden reduziert den Tokenverbrauch, ohne die Analysequalität spürbar zu beeinträchtigen.

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)

        # Kleine Bilder nicht vergrößern
        if img.width <= taille_max[0] and img.height <= taille_max[1]:
            pass
        else:
            img.thumbnail(taille_max)

        # In JPEG umwandeln, um die Größe zu reduzieren
        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}"

Strategie 3: Zweistufiges Pipeline

Bei hohen Volumina nutzen Sie ein zweistufiges Pipeline: eine schnelle erste Stufe mit low, um zu sortieren, und eine zweite Stufe mit high nur für Bilder, die dies erfordern:

def pipeline_deux_passes(images):
    # Pass 1: schnelle Klassifizierung (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: detaillierte Analyse (high) nur wenn notwendig
    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

Strategie 4: Caching

Wenn Sie dieselben Bilder mehrmals analysieren (Tests, Entwicklung, Demo), speichern Sie die Ergebnisse im Cache:

import hashlib
import json

cache = {}

def vision_avec_cache(image_url, prompt, detail="auto"):
    # Ein eindeutigen Schlüssel erstellen
    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

Überwachen und Alarm setzen

Richten Sie eine Kostenverfolgung ein, um Überschreitungen zu erkennen:

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
    }

Kernaussagen

  • Wählen Sie das detail-Niveau, das der Aufgabe entspricht – low, wenn dies ausreicht.
  • Verkleinern Sie Bilder vor dem Senden, um den Verbrauch zu reduzieren.
  • Nutzen Sie ein zweistufiges Pipeline für hohe Volumina.
  • Speichern Sie Ergebnisse im Cache, um redundante Aufrufe zu vermeiden.
  • Überwachen Sie Bild-Token in der Produktion, um Kosten frühzeitig zu antizipieren.