Модель, которая хорошо сегментирует кадр за 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 мс.
Почему процентиль, а не среднее. При 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. Если кадр пришёл, пока модель занята предыдущим, он ждёт. Время ожидания следующего кадра даёт рекуррентное соотношение Линдли:
Задержка кадра складывается из ожидания, обработки, захвата и вывода C и ожидания обновления экрана V.
Пока S в среднем меньше T, ожидание после каждого всплеска возвращается к нулю. Но всплеск в 100 мс оставляет за собой три кадра в очереди, и они рассасываются несколько кадров подряд. Если S в среднем больше T, очередь FIFO растёт без предела: каждый следующий кадр ждёт дольше предыдущего.
Потоковому оверлею не нужен каждый кадр – нужен самый свежий. Поэтому вместо очереди держат одну ячейку: новый кадр вытесняет тот, который модель ещё не взяла. Задержка перестаёт накапливаться, а платой становятся выброшенные кадры.
- p50 · p95 · p99, мс
- –
- среднее, мс
- –
- кадров дольше 50 мс
- –
- выброшено кадров
- –
Модель примера: время обработки – логнормальное распределение с заданной медианой и разбросом σ, в редких кадрах к нему прибавляется пауза 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 кадров в секунду уже нарушено.
Шесть этапов конвейера
Чтобы уложиться в бюджет, его нужно разделить между этапами. Задержка «от стекла до стекла» – сумма шести этапов:
- Захват кадра. Камера отдаёт видео по SDI или HDMI, карта захвата принимает его строка за строкой. Кадр готов к обработке, когда принят целиком, а при 60 Гц на входе передача одного кадра длится до 16,7 мс. Затем драйвер кладёт кадр в буфер в памяти.
- Цветовое преобразование. Камеры и карты захвата отдают YUV – например, NV12, где яркость идёт полным разрешением, а цвет – в половину по каждой оси. Сети нужен RGB заданного размера в числах с плавающей точкой, нормированных так же, как при обучении.
- Передача на GPU. Кадр копируется по шине PCIe из памяти процессора в память видеокарты.
- Прямой проход сети. Обычно самый долгий этап и главный кандидат на ускорение: TensorRT или ONNX Runtime, половинная точность, INT8.
osv.deployперечисляет именно эти движки. - Постобработка маски. Argmax по классам, сглаживание во времени из лекции 9, возврат к размеру экрана, цвета классов, кодирование для отправки.
- Вывод на монитор. Оверлей накладывается на видео, кадр ждёт ближайшего обновления экрана – при 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 возвращается обратно.
- предел конвейера, кадров в секунду
- –
- задержка 1-го · 6-го кадра, мс
- –
- узкое место
- –
Числа здесь придуманы для иллюстрации, это не замер. В последовательном режиме следующий кадр начинается, только когда предыдущий прошёл все пять этапов: по умолчанию это 35 мс, больше 33,3, и каждый следующий кадр опаздывает сильнее – шестой ждёт уже 8,3 мс сверх своих 35. С перекрытием каждый этап работает над своим кадром, и темп задаёт самый медленный – сеть, 26 мс, то есть 38 кадров в секунду. Но задержка одного кадра остаётся суммой этапов: перекрытие помогает пропускной способности, а не задержке. Модель примера считает, что у подготовки и постобработки свои потоки процессора, а у копирования в каждую сторону – своя очередь.
Без лишних копий
Каждая копия кадра стоит времени процессора и пропускной способности памяти, а копия по PCIe ещё и занимает шину. Время передачи оценивают так:
Здесь B – байты, R – пропускная способность шины. 25 ГБ/с – порядок того, что даёт PCIe 4.0 x16 при копировании из закреплённой памяти; теоретический предел – около 32 ГБ/с в каждую сторону. Сама передача по PCIe мала. Важнее, сколько копий делает код вокруг неё и что именно передаётся. Наивный путь и путь без лишних копий:
- Закреплённая память. Обычная память процессора страничная: ОС может выгрузить страницу. Из такой памяти 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, которые делают и для эндоскопии.
- по PCIe за кадр: туда · обратно
- –
- время PCIe при 25 ГБ/с (оценка)
- –
- CPU на кадр (замер p50)
- –
- по сети: за кадр · при 30 кадрах/с
- –
Время процессора здесь – сумма замеров p50 из таблицы выше, байты точные, время PCIe – оценка по формуле при 25 ГБ/с. По умолчанию выбран наивный путь: 26,2 МБ по шине, 58,7 мс процессора и 42 Мбит/с по сети. Путь без лишних копий – NV12 на GPU, маска обратно, оверлей у клиента – передаёт 3,52 МБ, тратит на процессоре 0,6 мс и шлёт по сети 0,9 Мбит/с. Время шины в обоих случаях около миллисекунды или меньше – выигрыш приходит от того, чего код больше не делает.
Асинхронный сервер osv.serve
Документация osv.serve описывает его как сервер FastAPI с потоковой передачей по WebSocket или WebRTC для оверлеев на хирургическом видео. Кода пока нет, поэтому ниже – планируемое устройство и проверенный набросок.
Сервер асинхронный: один цикл событий 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 не гоняйте.
Что почитать
- Dean, Barroso. The Tail at Scale. Communications of the ACM, 2013.
- PyTorch. A guide on good usage of non_blocking and pin_memory().
- PyTorch. CUDA semantics: асинхронное выполнение, потоки CUDA, закреплённая память.
- PyTorch. torch.cuda.Event.
- FastAPI. WebSockets.
- Python. Coroutines and Tasks:
asyncio.to_thread,TaskGroup. - IETF. RFC 6455: The WebSocket Protocol.
- gRPC. Core concepts и gRPC-Web.
- NVIDIA. Holoscan SDK.