Optimera bildtoken
På denna sida
Kontrollera dina kostnader i produktion
I produktionsmiljöer kan bildtoken utgöra en betydande del av din API-faktura. En enda bild i läget high förbrukar upp till 1 792 token – vilket motsvarar flera stycken text. Multiplicera detta med hundratals eller tusentals dagliga förfrågningar, så blir optimering en nödvändighet.
Strategi 1: Välj rätt detaljnivå
Parametern detail är din främsta hävstång för optimering. Det vanligaste misstaget är att använda high som standard när low eller auto räcker i de flesta fall.
Beslutsmatris
| Uppgift | Rekommenderad detaljnivå | Uppskattade token |
|---|---|---|
| Bildklassificering | low | ~256 |
| Generell beskrivning | auto | ~512-768 |
| Alt-text / tillgänglighet | low | ~256 |
| Innehållsmoderering | auto | ~512-768 |
| OCR / textextrahering | high | ~1024-1792 |
| Diagramanalys | high | ~1024-1792 |
| Feldetektering | high | ~1024-1792 |
Strategi 2: Ändra storlek innan sändning
Högupplösta bilder (4K, 8K) är sällan nödvändiga för AI-analys. Genom att konsekvent ändra storlek på dina bilder innan du skickar dem minskar du antalet token utan märkbar påverkan på analyskvaliteten.
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: Pipeline i två steg
För höga volymer bör du använda en pipeline i två steg: en snabb första omgång med low för sortering, följt av en andra omgång med high endast för de bilder som 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: Cachelagring
Om du analyserar samma bilder flera gånger (tester, utveckling, demo) bör du cachelagra resultaten:
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
Övervaka och varna
Sätt upp kostnadsövervakning för att upptäcka överskridanden:
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
}
Viktiga punkter
- Välj den
detail-nivå som passar uppgiften – användlownär det räcker - Ändra storlek på bilder innan sändning för att minska förbrukningen
- Använd en pipeline i två steg för höga volymer
- Cachelagra resultat för att undvika onödiga anrop
- Övervaka bildtoken i produktion för att förutse kostnader