Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Ottimizza i token delle immagini

Lezione 10 di 12 Aggiornata il 30 luglio 2026 Principiante
In questa pagina
  1. Controlla i costi in produzione
  2. Strategia 1: Scegli il livello di dettaglio appropriato
  3. Strategia 2: Ridimensiona prima dell’invio
  4. Strategia 3: Pipeline a due passaggi
  5. Strategia 4: Caching
  6. Monitora e genera avvisi
  7. Punti chiave

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 detail adatto al compito: low quando 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