Optimér billed-tokens
På denne side
Styr dine omkostninger i produktion
I produktion kan billed-tokens udgøre en betydelig del af din API-regning. Et enkelt billede i high-tilstand bruger op til 1.792 tokens – svarende til flere tekstafsnit. Gang det med hundredevis eller tusindvis af daglige forespørgsler, og optimering bliver en nødvendighed.
Strategi 1: Vælg det rette detaljeniveau
Parameteren detail er dit primære værktøj til optimering. Den mest almindelige fejl er at bruge high som standard, når low eller auto er tilstrækkeligt i de fleste tilfælde.
Beslutningsmatrix
| Opgave | Anbefalet detalje | Estimerede tokens |
|---|---|---|
| Billedklassificering | low | ~256 |
| Generel beskrivelse | auto | ~512-768 |
| Alt-tekst / tilgængelighed | low | ~256 |
| Indholdsmoderation | auto | ~512-768 |
| OCR / tekstudtræk | high | ~1024-1792 |
| Diagramanalyse | high | ~1024-1792 |
| Fejldetektion | high | ~1024-1792 |
Strategi 2: Ændr størrelse før afsendelse
Billeder i høj opløsning (4K, 8K) er sjældent nødvendige til AI-analyse. Ved konsekvent at ændre størrelsen på dine billeder, før du sender dem, reducerer du antallet af tokens uden mærkbar påvirkning af analysekvaliteten.
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}"
Strategi 3: To-trins pipeline
Ved store mængder bør du bruge en to-trins pipeline: en hurtig første gennemgang i low til sortering, efterfulgt af en anden gennemgang i high kun for de billeder, der kræver det:
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
Strategi 4: Caching
Hvis du analyserer de samme billeder flere gange (tests, udvikling, demo), så cach resultaterne:
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
Overvåg og varsling
Opsæt omkostningssporing for at opdage overskridelser:
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
}
Vigtige pointer
- Vælg det
detail-niveau, der passer til opgaven – bruglow, når det er tilstrækkeligt - Ændr størrelse på billeder før afsendelse for at reducere forbruget
- Brug en to-trins pipeline ved store mængder
- Cach resultater for at undgå redundante kald
- Overvåg billed-tokens i produktion for at forudse omkostninger