Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Begrænsninger: Formater, størrelse og grænser

Lektion 4 af 12 Opdateret 30. juli 2026 Begynder
På denne side
  1. Grundregler
  2. Accepterede billedformater
  3. Maksimal størrelse: 20 MiB
  4. Antal billeder pr. anmodning: Ubegrænset
  5. Kompatible modeller
  6. Fejlhåndtering
  7. Vigtige pointer

Grundregler

Før du integrerer Grok Vision i dine applikationer, skal du kende de tekniske begrænsninger, som xAI-API’en pålægger. Hvis du ignorerer disse grænser, risikerer du stille fejl eller afviste anmodninger, der kan være svære at fejlfinde i produktion.

Accepterede billedformater

xAI-API’en accepterer to billedfilformater (tre filendelser: .jpg, .jpeg, .png):

  • JPG (eller JPEG) – det mest almindelige format til fotografier
  • PNG – velegnet til skærmbilleder, diagrammer og billeder med tekst

Alle andre formater bliver afvist. Hvis du arbejder med WebP, GIF, BMP, TIFF, SVG eller HEIC-billeder, skal du konvertere dem, før du sender dem:

from PIL import Image

def convert_to_jpeg(source_path, output_path):
    img = Image.open(source_path)
    # Convert to RGB (required for JPEG)
    if img.mode in ("RGBA", "P"):
        img = img.convert("RGB")
    img.save(output_path, "JPEG", quality=90)

Almindelig fælde: RGBA-billeder

PNG-filer med gennemsigtighed (alfakanal) accepteres, som de er. Men hvis du konverterer dem til JPEG, skal du først fjerne alfakanalen, da JPEG ikke understøtter gennemsigtighed.

Maksimal størrelse: 20 MiB

Hvert billede må ikke overstige 20 MiB (20.971.520 byte). Hvis denne grænse overskrides, afviser API’en anmodningen.

Denne grænse gælder for:

  • Den downloadede fil, hvis der bruges en URL
  • De afkodede data, hvis der bruges Base64 (ikke selve den kodede streng, som er ca. 33 % længere)

Tjek størrelsen før afsendelse

import os

def check_size(image_path, max_mib=20):
    size = os.path.getsize(image_path)
    size_mib = size / (1024 * 1024)

    if size_mib > max_mib:
        raise ValueError(
            f"Image too large: {size_mib:.1f} MiB "
            f"(max {max_mib} MiB)"
        )
    return size_mib

Komprimer om nødvendigt

For billeder, der ligger tæt på grænsen, kan du reducere JPEG-kvaliteten:

def compress_image(path, quality=80, max_size_mib=20):
    img = Image.open(path)
    buffer = io.BytesIO()
    img.save(buffer, "JPEG", quality=quality)

    while buffer.tell() > max_size_mib * 1024 * 1024 and quality > 20:
        quality -= 10
        buffer = io.BytesIO()
        img.save(buffer, "JPEG", quality=quality)

    buffer.seek(0)
    return buffer

Antal billeder pr. anmodning: Ubegrænset

I modsætning til andre vision-API’er, der begrænser antallet af billeder pr. anmodning, pålægger xAI-API’en ingen grænse. Du kan sende så mange billeder, som du har brug for, i en enkelt anmodning.

Husk dog på, at:

  • Hvert billede forbruger mellem 256 og 1792 tokens
  • Modellens samlede kontekst har en maksimal størrelse
  • Flere billeder = højere ventetid og omkostninger

Praktisk anbefaling

Selvom grænsen teoretisk set er ubegrænset, bør du holde det rimeligt:

# Best practice: process in batches
def analyze_batch(images, batch_size=10):
    results = []
    for i in range(0, len(images), batch_size):
        batch = images[i:i + batch_size]
        input_data = []
        for img in batch:
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })
        input_data.append({
            "type": "input_text",
            "text": "Briefly describe each image."
        })

        response = client.responses.create(
            model="grok-4.5",
            input=input_data
        )
        results.append(response)
    return results

Kompatible modeller

Billedforståelse er tilgængelig på grok-4.5 og nyere. Ældre modeller understøtter ikke denne funktion.

Tjek altid modellen, der bruges i din kode:

VISION_MODELS = ["grok-4.5", "grok-4.20-0309-reasoning"]

def supports_vision(model):
    return any(model.startswith(m) for m in VISION_MODELS)

Fejlhåndtering

Forudsig fejl relateret til begrænsninger ved at validere billeder, før du sender dem:

def validate_image(path):
    errors = []

    # Check format
    extension = path.lower().rsplit(".", 1)[-1]
    if extension not in ("jpg", "jpeg", "png"):
        errors.append(f"Unsupported format: {extension}")

    # Check size
    size_mib = os.path.getsize(path) / (1024 * 1024)
    if size_mib > 20:
        errors.append(f"Too large: {size_mib:.1f} MiB (max 20)")

    # Check that it is a real image
    try:
        img = Image.open(path)
        img.verify()
    except Exception:
        errors.append("Corrupted file or not a valid image")

    return errors

Vigtige pointer

  • Kun formaterne JPG/JPEG og PNG accepteres – konverter andre
  • Maksimal størrelse: 20 MiB pr. billede – komprimer om nødvendigt
  • Antallet af billeder pr. anmodning er ubegrænset, men hvert billede forbruger tokens
  • Kun modellerne grok-4.5 og nyere understøtter vision
  • Valider altid billeder før afsendelse for at undgå stille fejl