Bild-Token optimieren
Auf dieser Seite
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.