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

Пакетна обработка в паметта: До 10 000 заявки без файл

Урок 4 от 16 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. Лековесната алтернатива на файловата пакетна обработка
  2. Файлова пакетна обработка срещу пакетна обработка в паметта
  3. Създаване на задача в паметта
  4. Практически пример: Класификация на тикети
  5. Кога да изберете всеки подход
  6. Ключови изводи

Обновено на 3 ноември 2026 г.: Актуализация от 3 ноември: files.download връща HTTP отговор (httpx2.Response); прочетете съдържанието му с .read(), преди да извикате .decode().

Лековесната алтернатива на файловата пакетна обработка

Пакетната обработка в паметта (Inline batching) Ви позволява да изпращате пакетни заявки директно чрез API повикването, като прескачате стъпката на качване на файл. Това е идеалният метод, когато разполагате с умерен обем заявки (до 10 000) и искате да опростите своя работен процес.

Файлова пакетна обработка срещу пакетна обработка в паметта

Преди да преминем към кода, нека изясним разликите между двата подхода:

Критерий Файлова пакетна обработка Пакетна обработка в паметта
Максимален обем 1 000 000 заявки 10 000 заявки
Предпоставки Качване на JSONL файл Няма
Стъпки Качване + Създаване на задача Създаване на задача (едно повикване)
Случаи на употреба Продукционна среда, големи обеми Тестване, прототипиране, средни обеми

Създаване на задача в паметта

Вместо да подавате input_files, Вие подавате параметър requests, съдържащ Вашия списък със заявки директно:

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Подготовка на заявки в паметта
inline_requests = [
    {
        "custom_id": f"req-{i:04d}",
        "body": {
            "max_tokens": 150,
            "messages": [
                {
                    "role": "system",
                    "content": "You are a text classification expert."
                },
                {
                    "role": "user",
                    "content": f"Classify this text: {text}"
                }
            ]
        }
    }
    for i, text in enumerate(my_texts)
]

# Създаване на задачата с заявки в паметта
job = client.batch.jobs.create(
    requests=inline_requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

print(f"Inline job created: {job.id}")
print(f"Number of requests: {len(inline_requests)}")

Разликата в кода е минимална: requests= вместо input_files=. Останалата част от работния процес (проследяване на статуса, изтегляне на резултатите) е идентична.

Практически пример: Класификация на тикети

Ето пълен пример за класифициране на тикети за поддръжка на клиенти:

from mistralai.client import Mistral
import json
import time

client = Mistral(api_key="your-api-key")

# Симулация на тикети за поддръжка
tickets = [
    {"id": "TK-001", "message": "I cannot log in to my account"},
    {"id": "TK-002", "message": "How do I cancel my subscription?"},
    {"id": "TK-003", "message": "The app crashes on startup"},
    {"id": "TK-004", "message": "Can you add dark mode?"},
    {"id": "TK-005", "message": "My invoice is incorrect"},
]

# Изграждане на заявки в паметта
requests = [
    {
        "custom_id": ticket["id"],
        "body": {
            "max_tokens": 50,
            "messages": [
                {
                    "role": "system",
                    "content": (
                        "Classify the ticket into one of these categories: "
                        "AUTHENTICATION, BILLING, BUG, "
                        "FEATURE, SUBSCRIPTION. "
                        "Reply with the category only."
                    )
                },
                {"role": "user", "content": ticket["message"]}
            ]
        }
    }
    for ticket in tickets
]

# Стартиране на пакетната обработка в паметта
job = client.batch.jobs.create(
    requests=requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# Изчакване и извличане на резултатите
while True:
    status = client.batch.jobs.get(job_id=job.id)
    if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
        break
    time.sleep(5)

# Обработка на резултатите
if status.status == "SUCCESS":
    data = client.files.download(file_id=status.output_file)
    for line in data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        ticket_id = entry["custom_id"]
        category = entry["response"]["body"]["choices"][0]["message"]["content"]
        print(f"{ticket_id} -> {category.strip()}")

Кога да изберете всеки подход

Решаващият фактор не е само обемът, а мястото, което пакетната обработка заема във Вашия работен процес. По време на прототипиране Вие тествате подсказка (prompt) върху няколкостотин примера, я усъвършенствате и я стартирате отново. Записването на междинен JSONL файл при всяка итерация само забавя цикъла. Пакетната обработка в паметта премахва това затруднение – Вашият скрипт генерира заявки в реално време, ги изпраща в същото повикване и Вие можете да правите итерации за минути. Същата логика важи за лековесни интеграции, еднократни скриптове за анализ или ежедневна обработка, която остава под 10 000 заявки.

Файловата пакетна обработка поема водещата роля, щом пакетната обработка се превърне в звено от продуктовата среда. Първо, механично: над 10 000 заявки това е единствената опция. Но по-важното е структурното предимство: каченият файл е траен артефакт. Можете да го използвате повторно за множество задачи, да го запазите като запис на точно това, което е било изпратено, и да разделите ясно стъпката на подготовка (която изгражда, валидира и версионира файла) от стъпката на изпълнение (която стартира задачата). Когато пакетна задача се изпълнява всяка нощ върху данни на клиенти, тази проследимост не е лукс; тя е това, което Ви позволява да отговорите на въпроса „Какво изпратихме на модела на 12 март?“ шест месеца по-късно.

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

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

  • Пакетната обработка в паметта премахва стъпката на качване, като предава заявките директно чрез параметъра requests
  • Лимит от 10 000 заявки на задача в паметта, спрямо 1 милион за файловата пакетна обработка
  • Проследяването на статуса и изтеглянето на резултатите са идентични и за двата режима
  • Предпочитайте обработка в паметта за прототипиране и умерени обеми; използвайте файлова пакетна обработка за мащабна продукционна среда