Реализация AI-сегментации видеопотока в реальном времени в мобильном приложении

Реализация AI-сегментации видеопотока в реальном времени в мобильном приложении

Real-time видеосегментация на мобильном — это когда приложение понимает, что в кадре: человек, фон, машина, дорога, и делает это на каждом кадре с частотой 15–30 FPS. Сделать «работает на демо» несложно. Сделать «не греется, не лагает, работает на iPhone XR» — требует серьёзной работы с оптимизацией.

Типы сегментации и их применение

Семантическая сегментация — каждый пиксель относится к классу (фон, человек, автомобиль). Применение: замена фона на видеозвонках, AR-эффекты, анализ дорожной обстановки.

Instance сегментация — отдельная маска на каждый объект одного класса (три машины — три маски). Применение: подсчёт объектов, трекинг.

Panoptic — комбинация. Тяжелее, на мобильных используется редко.

Выбор модели для реального времени

Скорость критична. Вот реальные цифры на iPhone 14 Pro (Neural Engine):

SAM — для интерактивной сегментации (тапнул на объект → маска). Для реального времени без пользовательского ввода — YOLOv8n-seg или DeepLabV3+.

iOS: CoreML пайплайн для реального времени

class RealtimeSegmentationProcessor {

    private let model: VNCoreMLModel
    private let processQueue = DispatchQueue(label: "segmentation.process", qos: .userInteractive)

    // Frame skipping: обрабатываем каждый N-й кадр
    private var frameCounter = 0
    private let processEveryNFrames = 2  // 30fps камера → 15fps обработка

    func captureOutput(_ output: AVCaptureOutput,
                       didOutput sampleBuffer: CMSampleBuffer,
                       from connection: AVCaptureConnection) {
        frameCounter += 1
        guard frameCounter % processEveryNFrames == 0 else { return }
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }

        processQueue.async { [weak self] in
            self?.runSegmentation(on: pixelBuffer)
        }
    }

    private func runSegmentation(on pixelBuffer: CVPixelBuffer) {
        let request = VNCoreMLRequest(model: model) { [weak self] req, _ in
            guard let observation = req.results?.first as? VNCoreMLFeatureValueObservation,
                  let maskArray = observation.featureValue.multiArrayValue else { return }

            let mask = self?.processMask(maskArray)
            DispatchQueue.main.async {
                self?.delegate?.didUpdateSegmentationMask(mask)
            }
        }

        // Важно: pixelBuffer должен быть в правильном формате
        request.imageCropAndScaleOption = .scaleFill
        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer,
                                           orientation: .right)  // landscape orientation
        try? handler.perform([request])
    }

    private func processMask(_ array: MLMultiArray) -> SegmentationMask {
        // Конвертация MLMultiArray → CVPixelBuffer для рендера
        // Shape: [numClasses, height, width]
        let numClasses = array.shape[0].intValue
        let height = array.shape[1].intValue
        let width = array.shape[2].intValue

        // Argmax по классам для каждого пикселя → label map
        var labelMap = [UInt8](repeating: 0, count: height * width)
        for y in 0..<height {
            for x in 0..<width {
                var maxClass = 0
                var maxVal: Float = -Float.infinity
                for c in 0..<numClasses {
                    let val = array[[c, y, x] as [NSNumber]].floatValue
                    if val > maxVal { maxVal = val; maxClass = c }
                }
                labelMap[y * width + x] = UInt8(maxClass)
            }
        }
        return SegmentationMask(labels: labelMap, width: width, height: height,
                                classColors: Self.classColorMap)
    }
}

Рендер маски поверх видеопотока

Наивный подход — рисовать маску в CPU loop — даёт 3–5 FPS на рендере. Правильно — Metal / OpenGL ES:

// Metal шейдер для наложения маски на видео
// Входы: videoTexture (YCbCr), maskTexture (label map), colorLUT (класс→цвет)
fragment float4 segmentationOverlay(
    VertexOut in [[stage_in]],
    texture2d<float> videoTexture [[texture(0)]],
    texture2d<uint> maskTexture [[texture(1)]],
    texture1d<float> colorLUT [[texture(2)]],
    constant OverlayParams& params [[buffer(0)]]
) {
    float2 uv = in.texCoords;
    float4 videoColor = videoTexture.sample(sampler, uv);
    uint classLabel = maskTexture.sample(nearestSampler, uv).r;

    if (classLabel == 0) { return videoColor; }  // фон — без изменений

    float4 maskColor = colorLUT.sample(sampler, float(classLabel) / float(params.numClasses));
    return mix(videoColor, maskColor, params.overlayAlpha);  // blending
}

Такой Metal пайплайн рендерит маску на GPU без участия CPU — стабильные 30 FPS даже на iPhone 11.

Замена фона — частный случай

Для видеозвонков популярна бинарная сегментация (человек / фон). MediaPipe Selfie Segmentation — готовое решение, оптимизированное именно для этого:

// Android: MediaPipe Selfie Segmentation
val options = ImageSegmenterOptions.builder()
    .setBaseOptions(BaseOptions.builder()
        .setModelAssetPath("selfie_segmentation.tflite")
        .setDelegate(Delegate.GPU)
        .build())
    .setRunningMode(RunningMode.LIVE_STREAM)
    .setResultListener { result, _ ->
        val confidenceMask = result.confidenceMasks?.get(0)
        updateBackground(confidenceMask)
    }
    .build()

val segmenter = ImageSegmenter.createFromOptions(context, options)

Delegate.GPU принципиально: на CPU тот же MediaPipe даёт 8–12 FPS, на GPU — 25–30 FPS.

Ориентиры по срокам

Базовая сегментация одного класса (например, человек) с готовой моделью и простым рендером — 1 неделя. Мультиклассовая сегментация с Metal/GPU рендером, кастомной моделью под специфическую задачу, оптимизацией производительности и поддержкой iOS + Android — 2–4 недели.