Премини към основното съдържание
Български— Изберете език
Меню

Ограничения и оптимизация на Vision API

Урок 11 от 12 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Познайте ограниченията, за да ги заобиколите
  2. Технически ограничения
  3. Визуални халюцинации
  4. Оптимизиране на разходите
  5. Оптимизиране на латентността
  6. Контролен списък за продукционна среда
  7. Ключови изводи

Познайте ограниченията, за да ги заобиколите

Предишните десет урока обхванаха силните страни на Vision API. Този урок разглежда слабите му места. Това не е упражнение по смирение: разликата между демонстрационен прототип, който впечатлява, и приложение, което издържа в продукционна среда, се свежда точно до това. Тук ще научите за техническите ограничения, често срещаните капани – като визуалните халюцинации на първо място – и стратегиите за оптимизиране на разходите и латентността.

Технически ограничения

Вече засегнахме ограниченията на форматите, но нека ги обединим. Всяко изображение е ограничено до приблизително 20 MB и така или иначе ще бъде преоразмерено вътрешно, обикновено до 768x768 или еквивалент: изображението с разделителна способност 4K няма да подобри резултатите. Приетите формати са JPEG, PNG, GIF (само първият кадър) и WebP. Vision API не поддържа директно PDF – за това трябва да извикате Document AI, както беше обсъдено в Урок 8.

Най-структурното ограничение остава консумацията на токени. Всяко изображение консумира значителен брой токени и тази функция превръща тази оценка в долари, а не в абстрактни единици:

# Estimate the cost of a vision call
def estimate_cost(num_images=1, text_tokens=100, response_tokens=500,
                 tokens_per_image=1000, input_price=0.10, output_price=0.30):
    """Estimates the cost in dollars for a vision call (Small 3.2)."""
    input_tokens = (num_images * tokens_per_image) + text_tokens
    output_tokens = response_tokens

    input_cost = (input_tokens / 1_000_000) * input_price
    output_cost = (output_tokens / 1_000_000) * output_price
    total_cost = input_cost + output_cost

    print(f"Input tokens: {input_tokens} (${input_cost:.4f})")
    print(f"Output tokens: {output_tokens} (${output_cost:.4f})")
    print(f"Total cost: ${total_cost:.4f}")
    return total_cost

# 1 image with Small 3.2
estimate_cost(num_images=1)

# 5 images with Large 3
estimate_cost(num_images=5, input_price=2.00, output_price=6.00)

Сравнете двата извиквания в края на скрипта: второто струва десетки пъти повече от първото. Умножете това по Вашия дневен обем, преди да вземете решение. Отгоре на това има ограничение на прозореца за контекст, което общият сбор от изображения + подкана + отговор не трябва да надвишава – таван, до който множеството изображения достигат много по-бързо от дългия текст.

Визуални халюцинации

Моделът може да „измисли“ детайли, липсващи в изображението. Това е най-критичният проблем в продукционна среда, защото е тих: отговорът е добре оформен, правдоподобен и грешен.

Повтарят се четири модела. Измислен текст, при който моделът прочита дума, която не съществува в изображението. Приблизителни числа, при които стойностите, прочетени от диаграма, могат да се отклоняват с 5–15% от реалността. Добавени детайли, при които моделът попълва това, което не вижда ясно, с правдоподобна информация – размазан номер SIRET се превръща в перфектно форматиран, но фалшив SIRET. Накрая, объркване на елементи, при което два близки обекта се сливат в един.

Съществуват три контрамерки; комбинирайте ги според критичността. Първо, накарайте модела да квалифицира собствената си сигурност. Второ, накарайте го да препрочете изображението след транскрибирането. Трето, изправете два модела срещу един и същи въпрос и запазете само това, с което са съгласни.

# 1. Ask for a confidence level
prompt_confiance = """Analyze this image. For each piece of extracted information, indicate your confidence level:
- [CERTAIN]: clearly visible
- [PROBABLE]: partially visible or inferred
- [INCERTAIN]: barely legible, estimated

If an element is illegible, mark it [ILLISIBLE] rather than guessing."""

# 2. Ask for cross-verification
prompt_verification = """Read the text in this document. After transcribing, reread the image and verify every number and proper noun. Correct any detected errors."""

# 3. Double reading with two models
def double_verification(image_uri, question):
    """Sends the same image to two models and compares results."""
    resultats = {}
    for modele in ["mistral-small-latest", "mistral-large-latest"]:
        response = client.chat.complete(
            model=modele,
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": question},
                    {"type": "image_url", "image_url": image_uri}
                ]
            }]
        )
        resultats[modele] = response.choices[0].message.content

    return resultats

Двойното прочитане удвоява разходите: запазете го за суми, идентификатори и всичко, което задейства необратимо действие.

Оптимизиране на разходите

Най-ефективната оптимизация на разходите беше разгледана в Урок 5 и тя е най-простата: намалете размера на изображението, преди да го изпратите. Снимка от 6 MB, преоразмерена до 1024 пиксела, не губи нищо за целите на анализа и облекчава цялата верига.

from PIL import Image
from io import BytesIO
import base64

def optimiser_image(chemin, taille_max=1024, qualite=80):
    """Resizes and compresses an image for the Vision API."""
    img = Image.open(chemin)
    taille_originale = img.size

    # Resize
    if max(img.size) > taille_max:
        img.thumbnail((taille_max, taille_max))

    # Compress as JPEG
    buffer = BytesIO()
    img.convert("RGB").save(buffer, format="JPEG", quality=qualite)
    taille_fichier = buffer.tell()

    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")

    print(f"Original: {taille_originale} | Optimized: {img.size} | Size: {taille_fichier/1024:.0f} KB")
    return f"data:image/jpeg;base64,{b64}"

Следва насочването според сложността: не всяка задача заслужава най-скъпия модел. Функция от три реда е достатъчна за вземане на решение, стига предварително да сте класифицирали задачите си.

def choose_model(task):
    """Selects the optimal model based on the task."""
    simple_tasks = ["classification", "ocr_simple", "description", "triage"]
    complex_tasks = ["extraction_json", "comparaison", "analyse_graphique", "raisonnement"]

    if task in simple_tasks:
        return "mistral-small-latest"  # ~$0.10/M tokens
    else:
        return "mistral-large-latest"  # ~$2.00/M tokens

Третият лост е най-често забравяният: не плащайте два пъти за един и същи анализ. В продукционна среда едно и също изображение се връща по-често, отколкото бихте си помислили – повторно стартиране на процес, дублирани изпращания или повторен опит след инцидент. Диск кеш, индексиран спрямо хеша на файла и подканата, елиминира тези излишни извиквания.

import hashlib
import json
from pathlib import Path

CACHE_DIR = Path("cache_vision/")
CACHE_DIR.mkdir(exist_ok=True)

def analyser_avec_cache(image_path, prompt, modele="mistral-small-latest"):
    """Analyzes an image with disk caching."""
    # Generate a cache key
    with open(image_path, "rb") as f:
        image_hash = hashlib.md5(f.read()).hexdigest()
    cache_key = hashlib.md5(f"{image_hash}{prompt}{modele}".encode()).hexdigest()
    cache_file = CACHE_DIR / f"{cache_key}.json"

    # Check cache
    if cache_file.exists():
        return json.loads(cache_file.read_text())

    # API call
    response = client.chat.complete(
        model=modele,
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": prompt},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )

    resultat = response.choices[0].message.content

    # Save to cache
    cache_file.write_text(json.dumps(resultat, ensure_ascii=False))
    return resultat

Ключът включва подканата и модела, а не само изображението: промяната на въпроса за една и съща снимка действително трябва да задейства ново извикване.

Оптимизиране на латентността

За интерактивно приложение четири настройки влияят на възприеманото време за отговор. Преоразмерете изображенията от страна на клиента до максимум 1024 пиксела, което съкращава времето за качване. Изберете Small или Ministral, тъй като тяхното генериране е значително по-бързо. Предавайте изображенията чрез URL, когато вече са хоствани, за да избегнете изпращането на голямо тяло на заявката в Base64. Накрая, активирайте стрийминг, който не намалява общото време, но показва отговора, докато се изгражда:

# Streaming for a progressive response
stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image."},
            {"type": "image_url", "image_url": image_url}
        ]
    }]
)

for chunk in stream:
    if chunk.data.choices[0].delta.content:
        print(chunk.data.choices[0].delta.content, end="", flush=True)

Това е chat.stream, което замества chat.complete; останалата част от съобщението е точно същата.

Контролен списък за продукционна среда

Преди да внедрите приложение за Vision в продукционна среда, проверете всяка от следните точки:

  • Автоматично преоразмеряване на изображенията (макс. 1024px)
  • Валидиране на формата и размера преди изпращане
  • Обработка на грешки в API (повторен опит, изчакване, резервен вариант)
  • Кеш на резултатите за идентични изображения
  • Интелигентно насочване (Small за прости, Large за сложни)
  • Мониторинг на разходите и латентността
  • Тестване с изображения с лошо качество (размазани, с ниска разделителна способност, завъртяни)
  • Стратегия срещу халюцинации (нива на сигурност, двойна проверка)

Предпоследната точка е тази, която най-често се пропуска и която причинява най-големи щети: изградете набор от данни с умишлено лоши изображения и го стартирайте преди всяко внедряване.

Ключови изводи

  • Изображенията се преоразмеряват вътрешно – няма нужда да изпращате много висока разделителна способност
  • Визуалните халюцинации са основният риск – поискайте нива на сигурност
  • Преоразмеряването от страна на клиента е най-ефективната оптимизация на разходите
  • Насочването според сложността (Small срещу Large) намалява разходите с 90% при прости задачи
  • Диск кешът избягва излишни извиквания на API за едни и същи изображения