Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Ubegrænset antal billeder pr. anmodning

Lektion 11 af 12 Opdateret 30. juli 2026 Begynder
På denne side
  1. En konkurrencemæssig fordel ved xAI API’et
  2. Hvad “ubegrænset” virkelig betyder
  3. Praktiske anbefalinger efter volumen
  4. Multi-billede arkitekturer i produktion
  5. Håndtering af fejl med store billedsæt
  6. Vigtige pointer

En konkurrencemæssig fordel ved xAI API’et

xAI API’et skiller sig ud fra konkurrenterne på ét centralt teknisk punkt: Det sætter ingen grænse for antallet af billeder, du kan sende i en enkelt anmodning. Hvor andre API’er begrænser dig til 4, 10 eller 20 billeder, accepterer Grok så mange, du ønsker.

Denne fleksibilitet låser op for brugstilfælde, der er umulige andre steder, men det kræver også en solid forståelse af de praktiske konsekvenser.

Hvad “ubegrænset” virkelig betyder

Ingen grænse for antallet af billeder betyder ikke ingen begrænsninger. Flere faktorer sætter naturlige grænser for, hvor mange billeder du effektivt kan sende:

Kontekstvindue

Modellen har et fast kontekstvindue. Hvert billede bruger mellem 256 og 1792 tokens. Hvis du sender 50 billeder i high-tilstand, bruger du potentielt 89.600 tokens alene på billeder, hvilket efterlader lidt plads til tekst og svaret.

Analyse-kvalitet

Ud over et vist antal billeder falder analysekvaliteten. Modellen skal sprede sin opmærksomhed på tværs af alle billeder, hvilket kan føre til overfladiske beskrivelser eller udeladelser.

Latens og timeout

Jo flere billeder du sender, jo længere tid tager behandlingen. Med en anbefalet timeout på 3600 sekunder for ræsonnementsmodeller kan meget store anmodninger nærme sig denne grænse.

Praktiske anbefalinger efter volumen

Antal billeder Anbefaling Foreslået detaljeringsgrad
1-3 Detaljeret analyse mulig high
4-10 Effektiv sammenligning auto
11-20 Batch-klassificering low
20+ Opdel i del-anmodninger low

Multi-billede arkitekturer i produktion

Mønster: Sekventiel behandling med aggregering

For at analysere et stort antal billeder behandler du dem i batches og aggregerer derefter resultaterne:

import json

def analyser_catalogue(images, taille_lot=8):
    """Analyserer et billedkatalog i batches."""
    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"Billede {i + j}:"
            })
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })

        input_data.append({
            "type": "input_text",
            "text": """Identificer for hvert billede i JSON:
{"number": N, "category": "...", "short_description": "..."}
Returner et 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

Mønster: Tragt-filtrering

Start med en hurtig sortering på tværs af alle billeder, og dyk derefter kun ned i dem, der er relevante:

def entonnoir_analyse(images, critere):
    """Filtrerer og analyserer derefter i dybden."""
    # Trin 1: Hurtig filtrering
    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"""Hvilke af disse {len(images)} billeder
matcher kriteriet: "{critere}"?
Returner kun numrene (0-baseret indeks) i JSON: [0, 3, 7]"""
    })

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

    indices = json.loads(response.output_text)

    # Trin 2: Dybdegående analyse af filtrerede billeder
    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": "Detaljeret analyse af dette billede."}
            ],
            store=False
        )
        resultats.append({"index": idx, "analysis": response_detail.output_text})

    return resultats

Håndtering af fejl med store billedsæt

Når du arbejder med et stort antal billeder, er fejl mere sandsynlige. Implementer robust håndtering:

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  # Eksponentiel backoff
                time.sleep(delai)
            else:
                raise e

Vigtige pointer

  • xAI API’et accepterer et ubegrænset antal billeder, men kontekstvinduet forbliver endeligt
  • Ved mere end 10 billeder skal du bruge detail: "low" for at bevare analysekvaliteten
  • Ved mere end 20 billeder skal du opdele i del-anmodninger for pålidelighed
  • “Tragt”-mønsteret (hurtig filtrering efterfulgt af detaljeret analyse) er mest effektivt ved store volumener
  • Implementer genforsøg med eksponentiel backoff ved store anmodninger