Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Immagini illimitate per richiesta

Lezione 11 di 12 Aggiornata il 30 luglio 2026 Principiante
In questa pagina
  1. Un vantaggio competitivo dell’API xAI
  2. Cosa significa davvero “illimitato”
  3. Raccomandazioni pratiche per volume
  4. Architetture multi-immagine in produzione
  5. Gestione degli errori con grandi set di immagini
  6. Punti chiave

Un vantaggio competitivo dell’API xAI

L’API xAI si distingue dalla concorrenza su un punto tecnico fondamentale: non impone alcun limite al numero di immagini inviate in una singola richiesta. Mentre altre API ti limitano a 4, 10 o 20 immagini, Grok ne accetta quante ne desideri.

Questa flessibilità sblocca casi d’uso impossibili altrove, ma richiede anche una solida comprensione delle implicazioni pratiche.

Cosa significa davvero “illimitato”

Nessun limite sul conteggio delle immagini non significa assenza di vincoli. Diversi fattori limitano naturalmente il numero di immagini che puoi inviare efficacemente:

Finestra di contesto

Il modello dispone di una finestra di contesto fissa. Ogni immagine consuma tra 256 e 1792 token. Se invii 50 immagini in modalità high, potresti utilizzare potenzialmente 89.600 token solo per le immagini, lasciando poco spazio per il testo e la risposta.

Qualità dell’analisi

Oltre un certo numero di immagini, la qualità dell’analisi diminuisce. Il modello deve distribuire la sua attenzione su tutte le immagini, il che può portare a descrizioni superficiali o omissioni.

Latenza e timeout

Più immagini invii, più lungo sarà il tempo di elaborazione. Con un timeout consigliato di 3600 secondi per i modelli di ragionamento, le richieste molto grandi possono avvicinarsi a questo limite.

Raccomandazioni pratiche per volume

Numero di immagini Raccomandazione Dettaglio suggerito
1-3 Analisi dettagliata possibile high
4-10 Confronto efficiente auto
11-20 Classificazione in batch low
20+ Dividi in sotto-richieste low

Architetture multi-immagine in produzione

Schema: Elaborazione sequenziale con aggregazione

Per analizzare un gran numero di immagini, elaborale in batch e poi aggrega i risultati:

import json

def analyser_catalogue(images, taille_lot=8):
    """Analizza un catalogo di immagini in batch."""
    tous_resultats = []

    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]

        input_data = []
        for j, img in enumerate(lot, 1):
            input_data.append({
                "type": "input_text",
                "text": f"Image {i + j}:"
            })
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })

        input_data.append({
            "type": "input_text",
            "text": """For each image, identify in JSON:
{"number": N, "category": "...", "short_description": "..."}
Return a JSON array."""
        })

        response = client.responses.create(
            model="grok-4.5",
            input=input_data,
            store=False
        )

        try:
            resultats_lot = json.loads(response.output_text)
            tous_resultats.extend(resultats_lot)
        except json.JSONDecodeError:
            tous_resultats.append({"batch": i, "raw": response.output_text})

    return tous_resultats

Schema: Filtro a imbuto

Inizia con un ordinamento rapido su tutte le immagini, quindi approfondisci solo quelle rilevanti:

def entonnoir_analyse(images, critere):
    """Filtra e poi analizza in profondità."""
    # Passo 1: Filtro rapido
    input_data = []
    for i, img in enumerate(images):
        input_data.append({"type": "input_image", "image_url": img, "detail": "low"})

    input_data.append({
        "type": "input_text",
        "text": f"""Among these {len(images)} images, which ones
match the criteria: "{critere}"?
Return only the numbers (0-based index) in JSON: [0, 3, 7]"""
    })

    response = client.responses.create(
        model="grok-4.5", input=input_data, store=False
    )

    indices = json.loads(response.output_text)

    # Passo 2: Analisi approfondita delle immagini filtrate
    resultats = []
    for idx in indices:
        response_detail = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": images[idx], "detail": "high"},
                {"type": "input_text", "text": "Detailed analysis of this image."}
            ],
            store=False
        )
        resultats.append({"index": idx, "analysis": response_detail.output_text})

    return resultats

Gestione degli errori con grandi set di immagini

Quando lavori con un gran numero di immagini, gli errori sono più probabili. Implementa una gestione robusta:

import time

def requete_avec_retry(input_data, max_retries=3):
    for tentative in range(max_retries):
        try:
            response = client.responses.create(
                model="grok-4.5",
                input=input_data,
                store=False
            )
            return response
        except Exception as e:
            if tentative < max_retries - 1:
                delai = 2 ** tentative  # Exponential backoff
                time.sleep(delai)
            else:
                raise e

Punti chiave

  • L’API xAI accetta un numero illimitato di immagini, ma la finestra di contesto rimane finita
  • Oltre 10 immagini, usa detail: "low" per preservare la qualità dell’analisi
  • Oltre 20 immagini, dividi in sotto-richieste per garantire l’affidabilità
  • Lo schema a “imbuto” (filtro rapido seguito da analisi dettagliata) è il più efficace per grandi volumi
  • Implementa nuovi tentativi con backoff esponenziale per le richieste di grandi dimensioni