Przejdź do głównej treści
Polski— Wybierz język
Menu

Nieograniczona liczba obrazów na żądanie

Lekcja 11 z 12 Zaktualizowano 30 lipca 2026 Początkujący
Na tej stronie
  1. Przewaga konkurencyjna interfejsu API xAI
  2. Co naprawdę oznacza „nieograniczona liczba“
  3. Praktyczne rekomendacje w zależności od wolumenu
  4. Architektury wieloobrazowe w środowisku produkcyjnym
  5. Obsługa błędów przy dużych zestawach obrazów
  6. Kluczowe wnioski

Przewaga konkurencyjna interfejsu API xAI

Interfejs API xAI wyróżnia się na tle konkurencji pod jednym kluczowym względem technicznym: nie nakłada żadnego limitu na liczbę obrazów wysyłanych w pojedynczym żądaniu. Podczas gdy inne interfejsy ograniczają Cię do 4, 10 lub 20 obrazów, Grok przyjmuje ich dowolną liczbę.

Ta elastyczność odblokowuje przypadki użycia niemożliwe do zrealizowania gdzie indziej, ale wymaga też solidnego zrozumienia praktycznych konsekwencji.

Co naprawdę oznacza „nieograniczona liczba“

Brak limitu liczby obrazów nie oznacza braku jakichkolwiek ograniczeń. Kilka czynników naturalnie ogranicza to, ile obrazów możesz skutecznie przesłać:

Okno kontekstowe

Model posiada stałe okno kontekstowe. Każdy obraz zużywa od 256 do 1792 tokenów. Jeśli wyślesz 50 obrazów w trybie high, potencjalnie zużyjesz 89 600 tokenów wyłącznie na obrazy, zostawiając mało miejsca na tekst i odpowiedź.

Jakość analizy

Po przekroczeniu pewnej liczby obrazów jakość analizy spada. Model musi rozłożyć swoją uwagę na wszystkie obrazy, co może prowadzić do powierzchownych opisów lub pominięć.

Opóźnienia i limit czasu

Im więcej obrazów wyślesz, tym dłuższy jest czas przetwarzania. Przy zalecanym limicie czasu wynoszącym 3600 sekund dla modeli rozumujących, bardzo duże żądania mogą zbliżyć się do tego progu.

Praktyczne rekomendacje w zależności od wolumenu

Liczba obrazów Rekomendacja Sugerowany poziom szczegółowości
1–3 Możliwa szczegółowa analiza high
4–10 Efektywne porównanie auto
11–20 Klasyfikacja wsadowa low
20+ Podział na podżądania low

Architektury wieloobrazowe w środowisku produkcyjnym

Wzorzec: Przetwarzanie sekwencyjne z agregacją

Aby przeanalizować dużą liczbę obrazów, przetwarzaj je partiami, a następnie agreguj wyniki:

import json

def analyser_catalogue(images, taille_lot=8):
    """Analizuje katalog obrazów w partiach."""
    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

Wzorzec: Filtrowanie lejkowe

Rozpocznij od szybkiego sortowania wszystkich obrazów, a następnie przeprowadź dogłębną analizę tylko tych, które są istotne:

def entonnoir_analyse(images, critere):
    """Filtruje, a następnie analizuje dogłębnie."""
    # Krok 1: Szybkie filtrowanie
    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)

    # Krok 2: Dogłębna analiza przefiltrowanych obrazów
    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

Obsługa błędów przy dużych zestawach obrazów

Pracując z dużą liczbą obrazów, błędy są bardziej prawdopodobne. Wdróż solidną obsługę wyjątków:

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

Kluczowe wnioski

  • Interfejs API xAI przyjmuje nieograniczoną liczbę obrazów, ale okno kontekstowe pozostaje skończone
  • Powyżej 10 obrazów użyj detail: "low", aby zachować jakość analizy
  • Powyżej 20 obrazów podziel żądanie na podżądania dla zwiększenia niezawodności
  • Wzorzec „lejka“ (szybkie filtrowanie, a następnie szczegółowa analiza) jest najskuteczniejszy przy dużych wolumenach
  • Wdróż mechanizm ponawiania z wykładniczym opóźnieniem (exponential backoff) dla dużych żądań