Ottimizza i token delle immagini
In questa pagina
Controlla i costi in produzione
In produzione, i token delle immagini possono rappresentare una parte significativa della tua fattura API. Una singola immagine in modalità high consuma fino a 1.792 token, l’equivalente di diversi paragrafi di testo. Moltiplica questo valore per centinaia o migliaia di richieste giornaliere e l’ottimizzazione diventa una necessità.
Strategia 1: Scegli il livello di dettaglio appropriato
Il parametro detail è la tua leva principale di ottimizzazione. L’errore più comune è usare high come predefinito quando low o auto sono sufficienti nella maggior parte dei casi.
Matrice decisionale
| Compito | Dettaglio consigliato | Token stimati |
|---|---|---|
| Classificazione immagini | low | ~256 |
| Descrizione generale | auto | ~512-768 |
| Testo alternativo / accessibilità | low | ~256 |
| Moderazione dei contenuti | auto | ~512-768 |
| OCR / estrazione testo | high | ~1024-1792 |
| Analisi grafici | high | ~1024-1792 |
| Rilevamento difetti | high | ~1024-1792 |
Strategia 2: Ridimensiona prima dell’invio
Le immagini ad alta risoluzione (4K, 8K) sono raramente necessarie per l’analisi AI. Ridimensionare costantemente le immagini prima di inviarle riduce i token senza un impatto percepibile sulla qualità dell’analisi.
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 a due passaggi
Per volumi elevati, usa una pipeline a due passaggi: un primo passaggio veloce in low per smistare, poi un secondo passaggio in high solo per le immagini che lo richiedono:
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: Caching
Se analizzi le stesse immagini più volte (test, sviluppo, demo), memorizza nella cache i risultati:
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
Monitora e genera avvisi
Configura il tracciamento dei costi per rilevare sforamenti:
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
}
Punti chiave
- Scegli il livello di
detailadatto al compito:lowquando sufficiente - Ridimensiona le immagini prima dell’invio per ridurre il consumo
- Usa una pipeline a due passaggi per volumi elevati
- Memorizza i risultati nella cache per evitare chiamate ridondanti
- Monitora i token delle immagini in produzione per anticipare i costi