Optimizați tokenii pentru imagini
Pe această pagină
Controlați-vă costurile în producție
În mediul de producție, tokenii pentru imagini pot reprezenta o parte semnificativă din factura dvs. API. O singură imagine în modul high consumă până la 1.792 de tokeni—echivalentul a câtorva paragrafe de text. Dacă înmulțiți acest număr cu sute sau mii de cereri zilnice, optimizarea devine o necesitate.
Strategia 1: Alegeți nivelul potrivit de detaliu
Parametrul detail este pârghia principală de optimizare. Cea mai frecventă greșeală este utilizarea implicită a modului high, atunci când low sau auto sunt suficiente în majoritatea cazurilor.
Matrice de decizie
| Sarcină | Detaliu recomandat | Tokeni estimați |
|---|---|---|
| Clasificare imagini | low | ~256 |
| Descriere generală | auto | ~512-768 |
| Text alternativ / accesibilitate | low | ~256 |
| Moderare conținut | auto | ~512-768 |
| OCR / extragere text | high | ~1024-1792 |
| Analiză grafice | high | ~1024-1792 |
| Detectare defecte | high | ~1024-1792 |
Strategia 2: Redimensionați înainte de trimitere
Imaginile la rezoluție înaltă (4K, 8K) sunt rareori necesare pentru analiza AI. Redimensionarea constantă a imaginilor înainte de trimitere reduce numărul de tokeni fără a afecta perceptibil calitatea analizei.
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: Pipeline în doi pași
Pentru volume mari, utilizați un pipeline în doi pași: o primă trecere rapidă în modul low pentru sortare, urmată de o a doua trecere în modul high doar pentru imaginile care o necesită:
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: Cache
Dacă analizați aceleași imagini de mai multe ori (teste, dezvoltare, demo), stocați rezultatele în cache:
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
Monitorizare și alerte
Configurați urmărirea costurilor pentru a detecta depășirile:
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
}
Puncte cheie
- Alegeți nivelul
detailadaptat sarcinii—lowatunci când este suficient - Redimensionați imaginile înainte de trimitere pentru a reduce consumul
- Utilizați un pipeline în doi pași pentru volume mari
- Stocați rezultatele în cache pentru a evita apelurile redundante
- Monitorizați tokenii pentru imagini în producție pentru a anticipa costurile