ЛЕКЦИЯ 10

Лекция 10. Потоковый инференс при жёстком бюджете задержки

Как подать маски на живое лапароскопическое видео с задержкой p95 не больше 50 мс при 30 кадрах в секунду: хвост распределения и очереди, шесть этапов конвейера и их профилирование, передача на GPU без лишних копий и асинхронный сервер osv.serve на FastAPI. Со схемами, формулами, замерами, интерактивными примерами и 3D-анимациями.

Страница ещё проходит проверку научными, клиническими и юридическими экспертами. Здесь описаны планы, а не готовые результаты.

Модель, которая хорошо сегментирует кадр за 200 мс, бесполезна для оверлея во время операции: хирург двигает инструмент, а маска приходит туда, где инструмент был пятую долю секунды назад. Это лекция 10 учебной программы, после лекции 9 о трекинге инструментов. Три темы:

  • Бюджет задержки: что значит «p95 ≤ 50 мс при ≥ 30 кадрах в секунду» и почему важен хвост распределения, а не среднее.
  • Профилирование: шесть этапов от захвата кадра до монитора, где уходит время и как это измерять.
  • Потоковый сервер osv.serve: передача без лишних копий и асинхронный сервер на FastAPI.

osv.serve пока не написан: в osv есть только интерфейс и описание. Поэтому лекция описывает планируемое устройство. Все замеры на странице сделаны на ноутбуке с Intel Core Ultra 7 155H без видеокарты NVIDIA; числа для GPU – расчёт, и это каждый раз оговорено. Модели проекта исследовательские (RESEARCH USE ONLY – NOT FOR CLINICAL USE).

Бюджет: два условия, а не одно

Бюджет записан в osv.deploy:

from osv.deploy import get_latency_budget

get_latency_budget()
# {'target_latency_p95_ms': 50.0, 'target_fps': 30.0,
#  'supported_engines': ['PyTorch', 'ONNXRuntime', 'TensorRT']}

В нём два разных условия.

  • Пропускная способность: ≥ 30 кадров в секунду. Новый кадр приходит каждые 33,3 мс. Если конвейер не успевает его обработать, кадры копятся или теряются. Этапы могут работать параллельно над соседними кадрами, и тогда за камерой должен успевать самый медленный этап, а не их сумма. Это разобрано на странице о бюджете задержки для видео.
  • Задержка: p95 ≤ 50 мс. Задержка кадра – время от его съёмки до появления оверлея на мониторе, «от стекла до стекла». p95 – 95-й процентиль: 95 % кадров должны появляться не позже чем через 50 мс.
p95=min{t:|{k:Lk≤t}|≥0,95·N} N=1800:N−0,95·N=90кадров

Почему процентиль, а не среднее. При 30 кадрах в секунду за минуту проходит 1800 кадров, и 5 % из них – это 90 кадров в минуту, которым разрешено опоздать. Среднее этого не видит: распределение задержки несимметрично, у него длинный правый хвост. Его дают сборка мусора, другой процесс на том же GPU, планировщик ОС, снижение частоты при перегреве. Даже простое уменьшение кадра 1920×1080 до 854×480 в OpenCV на нашем ноутбуке заняло 1,41 мс в медиане и 2,82 мс в p95 – вдвое больше. Если этап вызывается много раз на кадр или кадр проходит через много этапов, редкие задержки отдельных частей складываются в частые задержки целого. Это разобрано в статье Dean и Barroso The Tail at Scale.

Очередь: где задержка растёт сама

Кадры приходят через равные промежутки T = 33,3 мс, а обработка занимает разное время S. Если кадр пришёл, пока модель занята предыдущим, он ждёт. Время ожидания следующего кадра даёт рекуррентное соотношение Линдли:

Wk+1=max(0,Wk+Sk−T) Lk=Wk+Sk+C+Vk

Задержка кадра складывается из ожидания, обработки, захвата и вывода C и ожидания обновления экрана V.

Пока S в среднем меньше T, ожидание после каждого всплеска возвращается к нулю. Но всплеск в 100 мс оставляет за собой три кадра в очереди, и они рассасываются несколько кадров подряд. Если S в среднем больше T, очередь FIFO растёт без предела: каждый следующий кадр ждёт дольше предыдущего.

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

Модель примера: время обработки – логнормальное распределение с заданной медианой и разбросом σ, в редких кадрах к нему прибавляется пауза 100 мс. К задержке прибавляются захват и вывод и ожидание обновления экрана 60 Гц – от 0 до 16,7 мс, потому что часы камеры и монитора не синхронизированы. Это модель, а не замер; она нужна, чтобы увидеть форму распределения.

При настройках по умолчанию (медиана 15 мс, пауза в 0,5 % кадров) p95 равен 44,8 мс – бюджет выполнен. Но p99 равен 94 мс: каждая пауза тянет за собой несколько кадров очереди, и за минуту 39 кадров опаздывают дольше 50 мс. С ячейкой для самого свежего кадра p95 почти тот же, 44,1 мс, p99 падает до 48,5 мс, опаздывают 14 кадров, а 14 кадров выбрасываются.

Без пауз и с медианой 20 мс среднее равно 40,4 мс и выглядит спокойным, а p95 – 49,5 мс, на самой границе. А с медианой 35 мс, тоже без пауз, модель медленнее камеры: в очереди FIFO задержка за минуту вырастает почти до 4 секунд, а с ячейкой p95 держится на 90 мс, но выброшено 110 кадров – условие 30 кадров в секунду уже нарушено.

Шесть этапов конвейера

Чтобы уложиться в бюджет, его нужно разделить между этапами. Задержка «от стекла до стекла» – сумма шести этапов:

захваткарта захватакадр целиком1цветNV12 → RGB,размер, float2на GPUкопия по шинеPCIe3сетьпрямой проходTensorRT, fp164маскаargmax, цвета,кодирование5мониторналожение иобновление экрана6оборудованиеоборудованиенаш кодзадержка «от стекла до стекла» = сумма шести этапов; p95 ≤ 50 мс
Путь кадра от камеры до монитора. Первый и последний этапы задаёт оборудование; средние четыре – наш код.
  1. Захват кадра. Камера отдаёт видео по SDI или HDMI, карта захвата принимает его строка за строкой. Кадр готов к обработке, когда принят целиком, а при 60 Гц на входе передача одного кадра длится до 16,7 мс. Затем драйвер кладёт кадр в буфер в памяти.
  2. Цветовое преобразование. Камеры и карты захвата отдают YUV – например, NV12, где яркость идёт полным разрешением, а цвет – в половину по каждой оси. Сети нужен RGB заданного размера в числах с плавающей точкой, нормированных так же, как при обучении.
  3. Передача на GPU. Кадр копируется по шине PCIe из памяти процессора в память видеокарты.
  4. Прямой проход сети. Обычно самый долгий этап и главный кандидат на ускорение: TensorRT или ONNX Runtime, половинная точность, INT8. osv.deploy перечисляет именно эти движки.
  5. Постобработка маски. Argmax по классам, сглаживание во времени из лекции 9, возврат к размеру экрана, цвета классов, кодирование для отправки.
  6. Вывод на монитор. Оверлей накладывается на видео, кадр ждёт ближайшего обновления экрана – при 60 Гц до 16,7 мс, – и ещё есть собственная задержка монитора.

Замеры на процессоре

Чтобы были настоящие числа, мы замерили средние этапы на синтетических кадрах на ноутбуке с Core Ultra 7 155H: OpenCV 5.0, PyTorch 2.14 на 8 потоках, по 300–600 повторов после прогрева. Сеть – LR-ASPP с MobileNetV3-Large из torchvision на 13 классов CholecSeg8k со случайными весами: для времени веса не важны.

Этап Операция p50, мс p95, мс
Цвет NV12 → RGB, 1920×1080 0,18 0,21
Цвет уменьшение до 854×480, INTER_AREA 1,41 2,82
Цвет в float, CHW, нормировка, 854×480 0,53 0,58
Копия копия кадра RGB 1920×1080, 6,2 МБ 0,23 0,23
Копия torch.from_numpy: тензор поверх тех же байтов 0,001 0,001
Сеть LR-ASPP MobileNetV3, 854×480, на процессоре 60,0 65,0
Маска argmax по 13 каналам, тензор NCHW 43,9 45,6
Маска argmax по 13 каналам, каналы последними 3,0 3,6
Маска цвета классов индексированием NumPy, 1920×1080 19,5 20,1
Маска цвета через cv2.LUT и смешение с кадром, 1920×1080 2,5 3,3
Отправка PNG маски 854×480, 3709 байт 0,64 0,66
Отправка JPEG кадра с оверлеем 1920×1080, качество 80 10,2 10,4

Что из этого следует:

  • Сеть на процессоре одна съедает бюджет. 60 мс на кадр – это меньше 17 кадров в секунду даже без остальных этапов. Нужен GPU, а время на нём проект ещё не измерял: карточки моделей обязаны содержать задержку p95, но обе существующие карточки, M1 и M5, записывают, что p50 и p95 на RTX 4090 или Jetson AGX Orin не измерены.
  • Постобработка может стоить больше сети. Наивный argmax и раскраска маски вместе заняли 63 мс – больше прямого прохода.
  • Раскладка памяти решает. Тот же argmax по тем же числам в 15 раз быстрее, когда каналы идут последними и соседние значения лежат рядом в памяти. Раскраска через cv2.LUT вместе со смешением с кадром в 8 раз быстрее, чем одна раскраска индексированием массива.
  • Хвост есть даже у простых операций. Уменьшение кадра – 1,41 мс в медиане и 2,82 мс в p95.

Как измерять на GPU

Операции CUDA асинхронны: вызов model(x) ставит ядра в очередь и сразу возвращается. Часы процессора вокруг такого вызова измеряют постановку в очередь, а не вычисление. Если после каждого этапа вызывать torch.cuda.synchronize(), время станет верным, но этапы перестанут перекрываться, и конвейер замедлится. Поэтому время на GPU измеряют событиями CUDA, которые записываются в тот же поток команд:

import torch

start = torch.cuda.Event(enable_timing=True)
end = torch.cuda.Event(enable_timing=True)

start.record()
logits = model(x)
end.record()
end.synchronize()                 # дождаться, пока GPU дойдёт до end
forward_ms = start.elapsed_time(end)

Ещё три правила. Первые десятки кадров выбрасывают: в них инициализация, выбор алгоритмов cuDNN и заполнение кэшей. p50 и p95 считают по минутам видео, а не по десятку кадров. Задержку «от стекла до стекла» измеряют снаружи – камерой, которая снимает в одном кадре миллисекундный таймер перед эндоскопом и монитор с оверлеем.

Параллельная работа этапов держится на том, что у GPU свои очереди команд – потоки CUDA, – и копирование может идти одновременно с вычислением. Пока сеть считает кадр n, следующий кадр n + 1 уже копируется на GPU, а маска кадра n − 1 возвращается обратно.

Числа здесь придуманы для иллюстрации, это не замер. В последовательном режиме следующий кадр начинается, только когда предыдущий прошёл все пять этапов: по умолчанию это 35 мс, больше 33,3, и каждый следующий кадр опаздывает сильнее – шестой ждёт уже 8,3 мс сверх своих 35. С перекрытием каждый этап работает над своим кадром, и темп задаёт самый медленный – сеть, 26 мс, то есть 38 кадров в секунду. Но задержка одного кадра остаётся суммой этапов: перекрытие помогает пропускной способности, а не задержке. Модель примера считает, что у подготовки и постобработки свои потоки процессора, а у копирования в каждую сторону – своя очередь.

Без лишних копий

Каждая копия кадра стоит времени процессора и пропускной способности памяти, а копия по PCIe ещё и занимает шину. Время передачи оценивают так:

t≈BR,R≈25ГБ/с 854·480·3=1,23МБ→t≈0,05мс 13·854·480·4=21,3МБ→t≈0,85мс

Здесь B – байты, R – пропускная способность шины. 25 ГБ/с – порядок того, что даёт PCIe 4.0 x16 при копировании из закреплённой памяти; теоретический предел – около 32 ГБ/с в каждую сторону. Сама передача по PCIe мала. Важнее, сколько копий делает код вокруг неё и что именно передаётся. Наивный путь и путь без лишних копий:

наивно: 26,2 МБ по PCIe, 58,7 мс CPU на кадркадр NV12в обычной памятиCPU: подготовкацвет, размер, float2,1 мскопия драйвераво временныйзакреплённыйPCIe: 4,92 МБсеть на GPU21,3 МБ обратноCPU: маскаargmax, оверлей,JPEG: 56,6 мсв сеть176 КБ на кадр42 Мбит/сбез лишних копий: 3,52 МБ по PCIe, 0,6 мс CPU на кадркадр NV12в закреплённомбуфере от картыPCIe: 3,11 МБпрямоиз буфераGPU: подготовкацвет, размер, floatсеть на GPUargmax на GPUPCIe: 0,41 МБмаска uint8PNG маски3,7 КБ, 0,6 мс CPU0,9 Мбит/с
Наивный путь передаёт по шине в 7 раз больше байтов, а по сети – в 48 раз больше, и тратит на процессоре почти 60 мс на кадр.
  • Закреплённая память. Обычная память процессора страничная: ОС может выгрузить страницу. Из такой памяти CUDA не может копировать напрямую и сначала сама копирует данные во временный закреплённый (page-locked) буфер – об этом подробно написано в руководстве PyTorch. Если кадр сразу кладётся в закреплённый буфер, лишней копии нет, а tensor.to("cuda", non_blocking=True) возвращается сразу, и копия идёт параллельно с вычислением.
  • Передавать uint8, а преобразовывать на GPU. Кадр 854×480 в uint8 – 1,23 МБ, в float32 – 4,92 МБ. Можно не трогать кадр на процессоре вовсе и отправить исходный NV12 1920×1080 – это 3,11 МБ, – а цвет, размер и нормировку сделать на GPU.
  • Возвращать маску, а не логиты. Логиты 13 классов в float32 – 21,3 МБ на кадр, маска uint8 – 0,41 МБ. Argmax на GPU, обратно только маска.
  • Не гонять видео через сервер. Оверлей можно наложить там, где видео выводится: в браузере или в приложении у монитора. Тогда по сети идёт только маска: 3,7 КБ в PNG против 176 КБ кадра в JPEG на нашем синтетическом кадре (на реальном размер зависит от содержимого).
  • Не копировать без нужды внутри процесса. torch.from_numpy даёт тензор поверх тех же байтов за микросекунду, а .copy() кадра 1920×1080 – 0,23 мс. Мелочь, пока таких копий не набирается десяток на кадр.

Предел этой идеи – кадр, который вообще не проходит через память процессора: карта захвата пишет его прямо в память GPU. Так устроены конвейеры на NVIDIA Holoscan SDK, которые делают и для эндоскопии.

Время процессора здесь – сумма замеров p50 из таблицы выше, байты точные, время PCIe – оценка по формуле при 25 ГБ/с. По умолчанию выбран наивный путь: 26,2 МБ по шине, 58,7 мс процессора и 42 Мбит/с по сети. Путь без лишних копий – NV12 на GPU, маска обратно, оверлей у клиента – передаёт 3,52 МБ, тратит на процессоре 0,6 мс и шлёт по сети 0,9 Мбит/с. Время шины в обоих случаях около миллисекунды или меньше – выигрыш приходит от того, чего код больше не делает.

Асинхронный сервер osv.serve

Документация osv.serve описывает его как сервер FastAPI с потоковой передачей по WebSocket или WebRTC для оверлеев на хирургическом видео. Кода пока нет, поэтому ниже – планируемое устройство и проверенный набросок.

клиентбраузер илиприложение у мониторацикл событий asyncioreceive()ws.receive_bytes()ячейка на 1 кадрQueue(maxsize=1)новый кадр вытесняет старыйinfer_and_send()свежий кадр → маскапоток: segment()модель на GPUasyncio.to_threadкадрымаска + номер кадрав цикле событий – только приём и отправка; всё долгое – в потоке или процессе
Две задачи в цикле событий и модель в отдельном потоке. Ячейка на один кадр не даёт задержке накапливаться.

Сервер асинхронный: один цикл событий asyncio обслуживает соединения, пока ни одна задача не держит его занятым. Отсюда главное правило: ничего долгого внутри async def. Прямой проход на 20 мс, вызванный прямо в обработчике, на эти 20 мс останавливает приём и отправку во всех соединениях. Модель запускают в отдельном потоке через asyncio.to_thread или в отдельном процессе, а цикл событий только принимает и отправляет.

import asyncio
from fastapi import FastAPI, WebSocket, WebSocketDisconnect

app = FastAPI()

@app.websocket("/stream")
async def stream(ws: WebSocket):
    await ws.accept()
    latest: asyncio.Queue[bytes] = asyncio.Queue(maxsize=1)

    async def receive():
        while True:
            frame = await ws.receive_bytes()
            if latest.full():
                latest.get_nowait()       # кадр, который модель не успела взять, выбрасываем
            latest.put_nowait(frame)

    async def infer_and_send():
        while True:
            frame = await latest.get()
            mask = await asyncio.to_thread(segment, frame)  # не блокирует цикл событий
            await ws.send_bytes(mask)

    try:
        async with asyncio.TaskGroup() as tasks:
            tasks.create_task(receive())
            tasks.create_task(infer_and_send())
    except* WebSocketDisconnect:
        pass

Мы запустили этот набросок с FastAPI 0.146 и uvicorn 0.54, подставив вместо segment заглушку на 40 мс – модель медленнее камеры. Клиент слал 150 кадров по 30 в секунду. Ответ пришёл на 125 кадров, задержка p50 – 58 мс, p95 – 73 мс, и она не росла. С обычной неограниченной очередью ответ пришёл на все 150 кадров, но задержка за 5 секунд выросла до 1,1 с при p50 570 мс.

Что ещё нужно настоящему серверу:

  • Номер и время кадра в ответе. Маска должна нести номер кадра и момент захвата: клиент накладывает её на правильный кадр или хотя бы знает, насколько она устарела.
  • Один владелец GPU. Несколько соединений не должны запускать модель параллельно, перебивая друг друга: одна задача владеет моделью, остальные получают её результаты.
  • Обратное давление на выходе. Медленный клиент не должен копить очередь отправки; на выходе тоже действует правило «только последнее».
  • Захват – на сервере. В операционной кадры идут не по сети из браузера, а с карты захвата на той же машине; задача приёма в наброске заменяется чтением карты, а по сети уходят только маски.

WebSocket, gRPC или WebRTC

Свойство WebSocket gRPC WebRTC
Транспорт одно TCP-соединение после HTTP-рукопожатия (RFC 6455) HTTP/2 поверх TCP в основном UDP
Сообщения произвольные байты или текст Protocol Buffers по схеме медиапотоки и каналы данных
В браузере встроен только через gRPC-Web: без потоков от клиента и двунаправленных встроен
Чем хорош простой двусторонний поток, есть в FastAPI строгая схема и генерация клиентов, связь сервисов между собой видео с низкой задержкой; потерянный пакет не задерживает следующие
Ограничение потерянный TCP-пакет задерживает все следующие то же для TCP сложнее в настройке: сигнализация, NAT

Для маски на монитор в той же сети WebSocket – самый простой выбор, и FastAPI поддерживает его сразу. gRPC удобен, когда клиент – не браузер, а другой сервис, например робототехнический стек. WebRTC нужен, если по сети идёт само видео.

Размер сообщения важнее протокола. Мы замерили время «туда и обратно» через FastAPI, uvicorn и websockets 15 на том же ноутбуке, без настоящей сети, с ответом размером с маску:

Сообщение от клиента p50, мс p95, мс
3,7 КБ (размер PNG маски) 0,12 0,23
176 КБ (JPEG кадра 1920×1080) 16,4 16,8
6,2 МБ (несжатый кадр RGB) 503 512

Это свойство конкретного стека на Python, а не предел WebSocket: другие серверы передадут те же байты быстрее. Вывод от этого не меняется: маски по сети – да, несжатые кадры через сервер на Python – нет, и любой выбор нужно мерить на своём стеке.

Где проект сейчас

osv.serve и osv.deploy пока содержат только интерфейс: get_server_metadata() возвращает описание сервера с обязательной пометкой о неклиническом назначении, а get_latency_budget() – бюджет из этой лекции. Экспорта в ONNX и TensorRT, сервера и замеров задержки на GPU ещё нет. В карточках моделей M1 (сегментация инструментов) и M5 (удаление дыма) прямо записано, что задержка инференса на RTX 4090 или Jetson AGX Orin не измерялась. Первая задача здесь – измерить, а не ускорять: p50 и p95 каждого из шести этапов на целевом GPU.

Чек-лист

  • Отчитывайтесь p50, p95 и p99 за минуты видео, а не средним по нескольким кадрам; первые кадры после запуска выбрасывайте.
  • Время на GPU меряйте событиями CUDA, задержку «от стекла до стекла» – внешней камерой.
  • Проверяйте отдельно пропускную способность (самый медленный этап короче 33,3 мс) и задержку (сумма этапов, p95 ≤ 50 мс).
  • Держите одну ячейку на самый свежий кадр, а не очередь; считайте выброшенные кадры.
  • Ничего долгого в async def: модель – в отдельном потоке или процессе.
  • Кладите кадры в закреплённую память, передавайте uint8, преобразуйте на GPU, возвращайте маску, а не логиты.
  • Смотрите на раскладку памяти: argmax по каналам и раскраска маски могут стоить больше сети.
  • Шлите маску с номером и временем кадра; видео через сервер на Python не гоняйте.

Что почитать