AI-стабілізація відео для дронів та екшн-камер

Розробка AI-стабілізації відео

Тремтіння камери — неминучий артефакт зйомки з рук, дронів або екшн-камер. Класична стабілізація зображення через оптичний потік (optical flow) оцінює рух між кадрами, згладжує траєкторію та компенсує тремтіння. Але на динамічних сценах зі швидким рухом або rolling shutter класика часто дає збої: з'являються геометричні спотворення, втрачається різкість. Уявіть: ви знімаєте гонку дронів або трейл-біг — на кожному другому кадрі розмиття, а кроп з'їдає 20% корисної площі. Ми пропонуємо AI-стабілізацію на основі deep learning, яка обробляє відео семантично — відрізняє рух оператора від руху об'єкта та відновлює викадровані пікселі через inpainting. Наша команда реалізувала понад 30 проєктів зі стабілізації для дронів, екшн-камер і трансляцій. Оцінимо ваш кейс під ключ — зв'яжіться з нами для отримання безкоштовної консультації.

Згідно з документацією OpenCV, класичний стабілізатор потребує кропу до 20% кадру.

Проблеми, які вирішуємо

Наші клієнти часто стикаються з:

• Тряска в датасетах для навчання нейромереж: для object detection і tracking потрібен чистий фон. AI-стабілізація прибирає тремтіння, не вносячи шуму.
• Rolling shutter і розмиття: DUT використовує вікна кадрів для передбачення, що знижує ефект розмиття.
• Кроп кадру: AI-методи зберігають до 95% площі кадру проти 80% у OpenCV, що особливо важливо при постобробці.

Як AI покращує стабілізацію порівняно з класикою?

Класичний optical flow (OpenCV VideoStabilizer) працює добре на статичних сценах з повільним рухом. Але на швидких переміщеннях або при зйомці з дрона він втрачає треки, вносить тремтіння та потребує значного кропу (до 20% кадру). AI-методи, такі як DUT (Deep Unified Transformer) або DIFRINT, навчаються на парах «нестабільний → стабільний» і передбачають оптимальну трансформацію, використовуючи future frames. Це дозволяє зберегти більше пікселів (кроп 5–10%) та обробляти сцени з розмиттям, засвіткою та rolling shutter. За нашими даними, DUT у 2.5 рази кращий за stability score, ніж класика.

Класична стабілізація через optical flow

import cv2
import numpy as np
from scipy.signal import medfilt

class VideoStabilizer:
    def __init__(self, smoothing_window: int = 30,
                  crop_ratio: float = 0.1):
        self.smoothing_window = smoothing_window
        self.crop_ratio = crop_ratio

    def stabilize(self, input_path: str, output_path: str) -> dict:
        cap = cv2.VideoCapture(input_path)
        fps = cap.get(cv2.CAP_PROP_FPS)
        w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
        transforms = self._estimate_transforms(cap)
        cap.release()
        smoothed = self._smooth_trajectory(transforms)
        cap = cv2.VideoCapture(input_path)
        out = cv2.VideoWriter(output_path,
                              cv2.VideoWriter_fourcc(*'mp4v'),
                              fps, (w, h))
        for i, (orig, smooth) in enumerate(zip(transforms, smoothed)):
            ret, frame = cap.read()
            if not ret:
                break
            stabilized = self._apply_transform(frame, orig, smooth, w, h)
            out.write(stabilized)
        cap.release()
        out.release()
        return {'frames': len(transforms), 'smoothing_window': self.smoothing_window}

    def _estimate_transforms(self, cap) -> list[np.ndarray]:
        ret, prev = cap.read()
        prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
        transforms = []
        while True:
            ret, curr = cap.read()
            if not ret:
                break
            curr_gray = cv2.cvtColor(curr, cv2.COLOR_BGR2GRAY)
            prev_pts = cv2.goodFeaturesToTrack(
                prev_gray, maxCorners=200, qualityLevel=0.01,
                minDistance=30, blockSize=3
            )
            curr_pts, status, _ = cv2.calcOpticalFlowPyrLK(
                prev_gray, curr_gray, prev_pts, None
            )
            valid_prev = prev_pts[status == 1]
            valid_curr = curr_pts[status == 1]
            m, _ = cv2.estimateAffinePartial2D(valid_prev, valid_curr)
            if m is None:
                m = np.eye(2, 3, dtype=np.float64)
            transforms.append(m)
            prev_gray = curr_gray
        return transforms

    def _smooth_trajectory(self, transforms: list) -> list:
        trajectory = np.cumsum([m[:, 2] for m in transforms], axis=0)
        smoothed = np.zeros_like(trajectory)
        for i in range(len(trajectory)):
            start = max(0, i - self.smoothing_window // 2)
            end = min(len(trajectory), i + self.smoothing_window // 2)
            smoothed[i] = trajectory[start:end].mean(axis=0)
        delta = smoothed - trajectory
        result = []
        for i, m in enumerate(transforms):
            m_smooth = m.copy()
            m_smooth[:, 2] += delta[i]
            result.append(m_smooth)
        return result

    def _apply_transform(self, frame: np.ndarray,
                          orig_m: np.ndarray,
                          smooth_m: np.ndarray,
                          w: int, h: int) -> np.ndarray:
        stabilized = cv2.warpAffine(frame, smooth_m, (w, h))
        crop = int(min(w, h) * self.crop_ratio)
        stabilized = stabilized[crop:h-crop, crop:w-crop]
        return cv2.resize(stabilized, (w, h))

DUT — Deep Unified Transformer для AI-стабілізації

class DeepVideoStabilizer:
    """
    AI-підхід: навчання стабілізувати відео на парах нестабільний/стабільний.
    Перевага перед класикою: краще обробляє
    rolling shutter, швидкий рух, розмиття.
    """
    def __init__(self, checkpoint_path: str, device: str = 'cuda'):
        import sys
        sys.path.append('/opt/DUT')
        from model import DUTStabilizer
        self.model = DUTStabilizer()
        self.model.load_state_dict(torch.load(checkpoint_path))
        self.model.eval().to(device)
        self.device = device

    @torch.no_grad()
    def stabilize_clip(self, frames: list[np.ndarray],
                        window_size: int = 16) -> list[np.ndarray]:
        """
        Обробляє відео вікнами по window_size кадрів.
        Ключова особливість DUT: використовує future frames
        для передбачення поточної стабілізації.
        """
        results = []
        for i in range(0, len(frames), window_size // 2):
            window = frames[i:i+window_size]
            if len(window) < window_size:
                window = window + [window[-1]] * (window_size - len(window))
            tensor = self._frames_to_tensor(window)
            stabilized_tensor = self.model(tensor.to(self.device))
            stabilized_frames = self._tensor_to_frames(stabilized_tensor)
            results.extend(stabilized_frames[:window_size//2])
        return results[:len(frames)]

Процес роботи

1. Аналітика: вивчаємо вихідне відео, метадані (FPS, роздільна здатність, тип тремтіння).
2. Проектування: вибираємо метод (класика або AI) та налаштовуємо параметри (smoothing window, crop ratio, window size).
3. Реалізація: розробляємо пайплайн на Python/C++ з використанням OpenCV, PyTorch, ONNX.
4. Тестування: оцінюємо метрики (stability score, cropping ratio, distortion) та візуально перевіряємо.
5. Деплой: пакуємо в Docker, налаштовуємо CI/CD, надаємо API або інтеграцію.

Терміни

Оцінка проєкту займає 2 робочі дні. Зв'яжіться з нами для обговорення вашого кейсу.

Метрики якості стабілізації

def evaluate_stabilization(unstable_frames: list, stable_frames: list) -> dict:
    """
    Метрики:
    - Cropping Ratio: скільки пікселів збережено (вище = краще)
    - Distortion Value: спотворення геометрії (нижче = краще)
    - Stability Score: дисперсія руху між кадрами (нижче = краще)
    """
    flows = []
    for i in range(1, len(stable_frames)):
        prev_gray = cv2.cvtColor(stable_frames[i-1], cv2.COLOR_BGR2GRAY)
        curr_gray = cv2.cvtColor(stable_frames[i], cv2.COLOR_BGR2GRAY)
        flow = cv2.calcOpticalFlowFarneback(prev_gray, curr_gray, None,
                                             0.5, 3, 15, 3, 5, 1.2, 0)
        flows.append(np.abs(flow).mean())
    return {
        'stability_score': float(np.std(flows)),
        'mean_motion': float(np.mean(flows)),
        'max_motion': float(np.max(flows))
    }

AI-стабілізація DUT забезпечує покращення stability score у 2.5 рази порівняно з OpenCV, при цьому зберігаючи майже повний кадр. Економія часу та бюджету на постобробку досягає 40%.

Чому AI-стабілізація вигідніша за класичну?

Класика хороша для простих сцен, але потребує великого кропу та часто вносить спотворення. AI-методи адаптуються до складних сцен, зменшують кроп та автоматично виправляють rolling shutter. Для проєктів з високими вимогами до якості AI-рішення окупається за 2-3 місяці за рахунок скорочення ручної роботи. Замовте прототип AI-стабілізації для вашого датасету — ми швидко покажемо результат.

Що входить у результат

• Вихідний код пайплайну (Python або C++).
• Документація (опис архітектури, інструкція із запуску).
• Навчання вашої команди (до 2 годин онлайн).
• Гарантія на роботу протягом 3 місяців (безкоштовні правки по bug-фіксах).

Отримайте консультацію щодо вашого відео — зв'яжіться з нами для оцінки проєкту.

Як distribution shift вбиває метрики CV-моделі в промисловості

На виробництві ставлять камеру, контролюють якість продукції. Модель навчена на 10 000 розмічених зображень — точність на тесті mAP 0.84. Запускають у продакшен — і в перший же тиждень пропускають 30% дефектів. Освітлення на лінії змінюється по змінах, distribution shift обнуляє метрики. Це класична історія з Computer Vision у промисловості, де розпізнавання образів дає збій без правильної обробки дрейфу.

Наші інженери з досвідом 60+ проектів з комп'ютерного зору знають, як виключити такі сценарії. Гарантуємо стабільну роботу моделі в реальних умовах.

Які архітектури детекції об'єктів обрати: YOLO, RT‑DETR чи інші?

YOLO — стандарт для real‑time детекції. YOLOv8 та YOLOv11 від Ultralytics — найбільш використовувані версії у виробництві: простий API, активна спільнота, вбудована валідація та експорт в ONNX/TensorRT. Для задач з високими вимогами до точності та коли latency менш критична — RT‑DETR, transformer‑based архітектура без NMS, дає кращий mAP на COCO при порівнянній швидкості з YOLOv8l.

Типова помилка при навчанні детектора: датасет 8000 зображень, 3 класи, fine‑tune YOLOv8m — F1 0.73 на валідації. Дивимося confusion matrix — один клас майже ніколи не детектується. Причина: дисбаланс 1:23. Рішення: oversampling рідкісного класу, focal loss для objectness, аугментації (Mosaic, MixUp вимкнути для рідкісного класу — вони його «розмивають»). Transfer learning обов'язковий: передтреновані на COCO ваги скорочують потребу в даних у 10 разів. Fine‑tune на 500–2000 доменних зображеннях дає робочу модель за 1–2 дні на одній GPU.

Для edge deployment: експорт в ONNX → TensorRT engine. YOLOv8n в TensorRT FP16 на Jetson AGX Orin дає 150+ FPS при P99 latency < 8 ms — це в 3 рази швидше, ніж ONNX Runtime без TensorRT. На сервері A10G: 700+ FPS для YOLOv8n в TensorRT INT8.

Як fine‑tuning YOLO допомагає в розпізнаванні образів?

Припустимо, потрібно знаходити мікродефекти на поверхні металу — задача з високою роздільною здатністю та перекосом класів. Використовуємо YOLOv8m, передтренований на COCO (документація Ultralytics), і донавчаємо на 2000 власних зображень. Застосовуємо аугментації Mosaic, MixUp, random perspective. Після 200 епох mAP 0.5 досягає 0.93. Ключові прийоми:

• focal loss для objectness голови — зменшує внесок легко класифікованих прикладів.
• class‑balanced sampling — вирівнює представництво рідкісних класів.
• Test Time Augmentation (TTA) — підвищує recall на 5–7% за рахунок усереднення по фліпах та масштабах.

Отримайте консультацію з підбору архітектури для вашого завдання — зв'яжіться з нами.

Які архітектури сегментації обрати: SAM, Mask R‑CNN чи інші?

SAM (Segment Anything Model) від Meta змінив підхід до сегментації. SAM 2 працює з відео, підтримує трекінг об'єктів через кадри — для інтерактивного виділення об'єкта по точці або bbox це найкращий вибір з коробки. Для production instance segmentation без інтерактивного промпту — Mask R‑CNN або YOLOv8‑seg. YOLOv8‑seg навчається як звичайний детектор з додатковими масками, зручний у тих же пайплайнах. Семантична сегментація (кожен піксель — клас) — SegFormer, DeepLabV3+. SegFormer‑B5 дає хороший баланс точності та швидкості для аналізу супутникових знімків або медичної сегментації.

Кейс: сегментація клітин на мікроскопічних зображеннях. Датасет 400 зображень з ручною розміткою. Навчання Mask R‑CNN на ResNet‑50 backbone дало IoU 0.61 — погано. Проблема: об'єкти (клітини) перекриваються, стандартний NMS вбиває перекриваючі передбачення. Рішення: перехід на cellpose (спеціалізована архітектура для біомедичних задач) + soft‑NMS. IoU зріс до 0.79.

Коли Tesseract не справляється з OCR?

Tesseract — відправна точка для простих задач: друкований текст, хороше освітлення, рівне розташування. Як тільки з'являються рукописні елементи, нестандартні шрифти, перспективні спотворення або багатоколоночний макет — Tesseract деградує швидко.

PaddleOCR — production‑grade рішення: виявлення текстових блоків + розпізнавання + структурний аналіз. Працює з коробки для 80+ мов, включаючи українську. Підтримує таблиці та документи зі складною структурою. Wikipedia: Оптичне розпізнавання символів. TrOCR (Microsoft) — трансформерний OCR з сильними результатами на рукописному тексті. Для українського рукописного тексту потрібен fine‑tuning: базова модель навчена переважно на латиниці.

Що робити, якщо Tesseract не справляється з розпізнаванням образів на документах?

Для задач «витягни дані з рахунку / договору / паспорта» використовуємо LayoutLMv3 або Donut — ці моделі розуміють layout документа, а не тільки текст. Інтеграція через Hugging Face Transformers, fine‑tuning на 200–500 розмічених документах. Типовий pipeline:

1. Preprocessing: deskew, denoising, binarization через OpenCV.
2. Виявлення текстових блоків: PaddleOCR detection або CRAFT.
3. Розпізнавання: PaddleOCR recognition або TrOCR.
4. Post‑processing: нормалізація, валідація через regex або LLM для структурованих полів.

Для документів з фіксованою структурою template matching + OCR точково по координатах часто надійніше за end‑to‑end рішення.

Face Recognition: ідентифікація та верифікація

Face recognition = detection + alignment + embedding + matching. Кожен етап важливий.

Detection: RetinaFace або InsightFace для точної локалізації обличчя та ключових точок. MTCNN — старіше, але надійне рішення. Embedding: ArcFace (InsightFace) — state‑of‑the‑art для face recognition embeddings. Моделі iresnet50/iresnet100 передтреновані на MS1MV3 (5M ідентичностей). Ембеддинг‑вектор 512 float32, порівняння за cosine similarity. Threshold tuning: поріг рішення — критичний параметр. При threshold 0.6 типовий FPR на LFW benchmark — 0.001, TPR — 0.985. У production threshold потрібно калібрувати під реальний distribution: люди в масках, зі зміненою зовнішністю, в різних умовах освітлення. Liveness detection обов'язковий: MiniFASNet — lightweight модель на CPU, FaceX‑Zoo містить кілька передтренованих liveness‑детекторів.

Відеоаналітика

Відео — послідовність кадрів плюс часовий вимір. Наївний підхід — детектувати на кожному кадрі — дорого.

Трекінг: ByteTrack та BoT‑SORT — стандарт для multi‑object tracking. Працюють поверх будь-якого детектора, додають persistent ID об'єктам між кадрами — це дає підрахунок об'єктів, трекі руху, velocity.

Оптимізація: не потрібно обробляти кожен кадр. Для статичних сцен детекція на кожному 5–10 кадрі, між ними — трекер. Для детекції подій (людина увійшла в зону) background subtraction (OpenCV MOG2) як lightweight pre‑filter перед нейромережевою детекцією. Action Recognition: SlowFast, VideoMAE для класифікації дій. Важкі моделі — для production використовуємо ONNX export + TensorRT або офлайн обробку.

Як виміряти якість моделі розпізнавання образів у продакшені?

Моніторинг якості — ключовий елемент MLOps. Відстежуємо:

• розподіл prediction confidence;
• частку low‑confidence передбачень (індикатор OOD‑даних);
• дрейф вхідних зображень через feature distribution (embeddings з backbone).

Падіння середньої confidence з 0.87 до 0.71 за тиждень — ранній сигнал про distribution shift. NVIDIA Triton Inference Server рекомендує відстежувати ці метрики через Prometheus. Наші сертифіковані інженери налаштовують моніторинг і гарантують SLA по якості інференсу.

Деплой CV‑моделей

Для онлайн інференсу використовуємо Triton Inference Server (NVIDIA) — production‑стандарт для serving CV‑моделей. Підтримує TensorRT, ONNX, PyTorch, dynamic batching, multiple instances. REST та gRPC API. Гарантуємо стабільну роботу під навантаженням.

Edge deployment: ONNX Runtime на ARM/x86 CPU. TensorFlow Lite для мобільних пристроїв. OpenVINO для Intel CPU/GPU/VPU — дає 2–3× приріст швидкості на Intel залізі порівняно з ONNX Runtime. Після деплою передаємо модель з документацією та навчаємо персонал.

Що входить в роботу

Терміни та вартість

Прототип детектора на існуючих даних — 1–2 тижні. Production‑система з оптимізацією під цільове залізо — 4–8 тижнів. Повний цикл включаючи розмітку даних (1000–5000 зображень) — 2–4 місяці. Вартість розраховується індивідуально під кожну задачу. Ми на ринку більше 5 років, реалізували 60+ проектів з комп'ютерного зору. Оцінимо ваш проект під ключ — замовте консультацію, щоб отримати розрахунок та технічну пропозицію.