Transformers documentation

Вывод на веб-сервере

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Вывод на веб-сервере

Веб-сервер — это система, которая ожидает запросы и обрабатывает их по мере поступления. Это означает, что Pipeline можно использовать в качестве движка инференса на веб-сервере, поскольку для обработки каждого входящего запроса можно применять итератор (аналогично тому, как вы итерируете по набору данных).

Проектирование веб-сервера с использованием Pipeline имеет свою специфику, поскольку эти системы принципиально различаются. Веб-серверы используют мультиплексирование (многопоточность, асинхронность и т. д.) для одновременной обработки нескольких запросов. Pipeline и лежащая в его основе модель, напротив, не рассчитаны на параллелизм, так как потребляют значительный объём памяти. Лучше всего выделять Pipeline все доступные ресурсы во время его работы или при выполнении вычислительно интенсивных задач.

В этом руководстве показано, как обойти эту разницу, используя веб-сервер для обработки менее ресурсоёмких задач приёма и отправки запросов, а отдельный поток — для выполнения более тяжёлой нагрузки, связанной с запуском Pipeline.

Создание сервера

Starlette — это лёгкий фреймворк для создания веб-серверов. Вы можете использовать любой другой фреймворк, но, возможно, потребуется внести некоторые изменения в приведённый ниже код.

Прежде чем начать, убедитесь, что Starlette и uvicorn установлены.

!pip install starlette uvicorn

Теперь можно создать простой веб-сервер в файле server.py. Главное — загрузить модель один раз, чтобы избежать создания лишних копий, потребляющих память.

Создайте конвейер для заполнения замаскированного токена [MASK].

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from transformers import pipeline
import asyncio

async def homepage(request):
    payload = await request.body()
    string = payload.decode("utf-8")
    response_q = asyncio.Queue()
    await request.app.model_queue.put((string, response_q))
    output = await response_q.get()
    return JSONResponse(output)

async def server_loop(q):
    pipe = pipeline(task="fill-mask",model="google-bert/bert-base-uncased")
    while True:
        (string, response_q) = await q.get()
        out = pipe(string)
        await response_q.put(out)

app = Starlette(
    routes=[
        Route("/", homepage, methods=["POST"]),
    ],
)

@app.on_event("startup")
async def startup_event():
    q = asyncio.Queue()
    app.model_queue = q
    asyncio.create_task(server_loop(q))

Запустите сервер с помощью следующей команды.

uvicorn server:app

Отправьте на сервер запрос POST.

curl -X POST -d "Paris is the [MASK] of France." http://localhost:8000/

Это должно вернуть следующий вывод.

[{'score': 0.9969332218170166,
  'token': 3007,
  'token_str': 'capital',
  'sequence': 'paris is the capital of france.'},
 {'score': 0.0005914849461987615,
  'token': 2540,
  'token_str': 'heart',
  'sequence': 'paris is the heart of france.'},
 {'score': 0.00043787318281829357,
  'token': 2415,
  'token_str': 'center',
  'sequence': 'paris is the center of france.'},
 {'score': 0.0003378340043127537,
  'token': 2803,
  'token_str': 'centre',
  'sequence': 'paris is the centre of france.'},
 {'score': 0.00026995912776328623,
  'token': 2103,
  'token_str': 'city',
  'sequence': 'paris is the city of france.'}]

Очередь запросов

Механизм очереди сервера можно использовать для ряда интересных приложений, например для динамического батчинга. Динамический батчинг сначала накапливает несколько запросов, а затем обрабатывает их с помощью Pipeline.

Приведённый ниже пример написан на псевдокоде с акцентом на читаемость, а не на производительность. В частности, обратите внимание на следующее:

  1. Ограничение размера батча отсутствует.

  2. Тайм-аут сбрасывается при каждом обращении к очереди, поэтому вы можете ждать значительно дольше, чем значение timeout, прежде чем запрос будет обработан. Это также задержит первый запрос на инференс на то же время. Веб-сервер всегда ждёт 1 мс, даже если очередь пуста, что неэффективно, поскольку это время можно использовать для запуска инференса. Однако это может иметь смысл, если батчинг критически важен для вашего сценария использования.

    Лучше использовать единый дедлайн в 1 мс, а не сбрасывать его при каждом запросе, как показано ниже.

async def server_loop(q):
    pipe = pipeline(task="fill-mask", model="google-bert/bert-base-uncased")
    while True:
        (string, rq) = await q.get()
        strings = []
        queues = []
        strings.append(string)
        queues.append(rq)
        while True:
            try:
                (string, rq) = await asyncio.wait_for(q.get(), timeout=1)
            except asyncio.exceptions.TimeoutError:
                break
            strings.append(string)
            queues.append(rq)
        outs = pipe(strings, batch_size=len(strings))
        for rq, out in zip(queues, outs):
            await rq.put(out)

Проверка ошибок

В продакшене может пойти не так многое. Вы можете столкнуться с нехваткой памяти, нехваткой места, ошибкой при загрузке модели, неверной конфигурацией модели, некорректным запросом и многими другими проблемами.

Добавление операторов try...except помогает возвращать эти ошибки пользователю для отладки. Помните, что это может представлять угрозу безопасности, если вы не должны раскрывать определённую информацию.

Отключение цепей

Старайтесь возвращать ошибку 503 или 504, когда сервер перегружен, вместо того чтобы заставлять пользователя ждать бесконечно.

Реализация этих типов ошибок относительно проста, поскольку используется только одна очередь. Оцените размер очереди, чтобы определить, когда следует начать возвращать ошибки, прежде чем сервер не выдержит нагрузку.

Блокировка главного потока

PyTorch не поддерживает асинхронность, поэтому вычисления блокируют выполнение основного потока.

По этой причине лучше запускать PyTorch в отдельном потоке или процессе. Это особенно важно, когда инференс одного запроса занимает длительное время (более 1 с), поскольку в этом случае каждый запрос, поступающий во время инференса, должен ждать 1 с, прежде чем получить ошибку.

Динамическая пакетная обработка

Динамическая пакетная обработка (dynamic batching) может быть очень эффективной при правильном использовании, но она не требуется, если вы отправляете по одному запросу за раз (см. пакетный вывод для подробностей).

Update on GitHub