Optymalizacja tokenów obrazowych
Na tej stronie
Kontroluj koszty w środowisku produkcyjnym
W środowisku produkcyjnym tokeny obrazowe mogą stanowić znaczną część Twojego rachunku za API. Pojedynczy obraz w trybie high zużywa do 1792 tokenów – co odpowiada kilku akapitom tekstu. Pomnóż to przez setki lub tysiące codziennych żądań, a optymalizacja staje się koniecznością.
Strategia 1: Wybierz odpowiedni poziom szczegółowości
Parametr detail to Twój główny dźwignia optymalizacji. Najczęstszym błędem jest domyślne używanie high, gdy w większości przypadków wystarczające są low lub auto.
Macierz decyzyjna
| Zadanie | Zalecany poziom szczegółowości | Szacowana liczba tokenów |
|---|---|---|
| Klasyfikacja obrazów | low | ~256 |
| Ogólny opis | auto | ~512-768 |
| Tekst alternatywny / dostępność | low | ~256 |
| Moderacja treści | auto | ~512-768 |
| OCR / ekstrakcja tekstu | high | ~1024-1792 |
| Analiza wykresów | high | ~1024-1792 |
| Wykrywanie дефекtów | high | ~1024-1792 |
Strategia 2: Zmiana rozmiaru przed wysłaniem
Obrazy o wysokiej rozdzielczości (4K, 8K) rzadko są niezbędne do analizy przez AI. Konsekwentna zmiana rozmiaru obrazów przed ich wysłaniem redukuje liczbę tokenów bez zauważalnego wpływu na jakość analizy.
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: Potok dwuetapowy
Przy dużych wolumenach zastosuj potok dwuetapowy – szybkie pierwsze przejście w trybie low do sortowania, a następnie drugie przejście w trybie high tylko dla obrazów, które tego wymagają:
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: Buforowanie (Caching)
Jeśli analizujesz te same obrazy wielokrotnie (testy, rozwój, demonstracje), buforuj wyniki:
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
Monitorowanie i alerty
Skonfiguruj śledzenie kosztów, aby wykrywać przekroczenia:
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
}
Kluczowe wnioski
- Wybierz poziom
detaildostosowany do zadania – używajlow, gdy to wystarczające - Zmień rozmiar obrazów przed wysłaniem, aby zmniejszyć zużycie
- Stosuj potok dwuetapowy przy dużych wolumenach
- Buforuj wyniki, aby uniknąć nadmiarowych wywołań
- Monitoruj tokeny obrazowe w środowisku produkcyjnym, aby przewidzieć koszty