הבנת וידאו בינה מלאכותית: זיהוי פעולות וחיפוש סמנטי

מערכת AI להבנה ועיבוד וידאו: מחיפוש ועד סיכום

זרם הווידאו ממצלמות מעקב, הקלטות וובינרים, תוכן שנוצר על ידי משתמשים — שעות של חומר שצריך לנתח. צפייה ידנית בכל פריים היא בלתי אפשרית, ופתרונות אוטומטיים מייצרים לעיתים קרובות תוצאות שגויות. אנחנו צוות של מהנדסי AI/ML עם ניסיון רב בראייה ממוחשבת ולמעלה מ-20 פרויקטים שהושלמו — בנינו מערכת להבנת וידאו שחולצת פעולות, נושאים ואירועים, וחוסכת עד 70% מזמנו של אנליסט. לצוות שלנו יש ניסיון של 7+ שנים ב-AI וראייה ממוחשבת, ואנחנו משרתים את השוק מאז 2018. חיפוש סמנטי המבוסס על CLIP embeddings ו-FAISS עובד פי 100 מהר יותר מגלישה ידנית בארכיוני וידאו. זה לא משנה מה לנתח: הקלטת מעקב של שלוש שעות או אוסף של אלף סרטונים — המערכת מוצאת כל רגע בשניות.

מערכת עיבוד הווידאו שלנו מצטיינת בהבנת וידאו, זיהוי פעולות, חיפוש סמנטי והסקה זמנית (temporal reasoning).

בעיות שאנחנו פותרים

• הסקה זמנית (Temporal reasoning): וידאו אינו אוסף של פריימים סטטיים. עצמים נעים, אירועים מתפתחים לאורך זמן. ללא ניתוח רצף הזמן, המערכת לא תבין ש"אדם עמד תחילה, ואז נפל."
• היקף נתונים: 24 שעות הקלטה ב-30fps = 2.6 מיליון פריימים. עיבוד כל פריים אינו יעיל. אנחנו משתמשים בדגימה מבוססת תנועה ו-FPS אדפטיבי כדי להפחית את העומס פי 10 מבלי לאבד דיוק.
• חיפוש בארכיונים גדולים: תגיות סטנדרטיות לא עובדות. יש צורך בחיפוש סמנטי לפי תוכן: "מצא את הרגע שבו משאית נכנסה לשטח אחרי 22:00."
• סיכום אוטומטי: יש לדחוס סרטונים ארוכים לסצנות מפתח תוך שמירה על המשמעות, למשל ליצירת טיזרים או תקצירים.

מהי הסקה זמנית ולמה היא בעיה מרכזית באנליטיקת וידאו?

כדי להבין וידאו, המודל חייב להתחשב לא רק בתוכן של כל פריים אלא גם ברצף שלהם. גלאי ברמת פריים קלאסי אינו יכול להבחין בין "אדם כורע" לבין "אדם כורע ולא קם" — אלה אירועים שונים. אנחנו פותרים זאת עם VideoMAE ו-TimeSformer, שעובדים עם קונבולוציות תלת-ממדיות לאורך זמן. עם זמן השהיה של 45ms עבור 16 פריימים, אנחנו יכולים לנתח 8 פריימים בשנייה בזמן אמת.

איך אנחנו מאיצים חיפוש בארכיוני וידאו של 1000+ שעות

חיפוש סמנטי בנוי על CLIP embeddings של פריימים שמאונדקסים ב-FAISS. אנחנו דוגמים כל פריים N, ולעתים קרובות יותר בהתבסס על תנועה (חיסור רקע). שאילתה כמו "אדם נופל" מומרת לאותו מרחב וקטורי, וחיפוש על פני 10 מיליון וקטורים אורך <100ms. ניתן לקרוא עוד על CLIP במאמר המקורי.

ארכיטקטורת מערכת להבנת וידאו

import torch
import numpy as np
import cv2
from transformers import AutoProcessor, AutoModelForVideoClassification

class VideoUnderstandingPipeline:
    def __init__(self, config: dict):
        # Video Action Recognition: VideoMAE или TimeSformer
        self.action_model = AutoModelForVideoClassification.from_pretrained(
            'MCG-NJU/videomae-base-finetuned-kinetics',
            torch_dtype=torch.float16
        ).cuda()
        self.action_processor = AutoProcessor.from_pretrained(
            'MCG-NJU/videomae-base-finetuned-kinetics'
        )
        # Для длинных видео: LLaVA-Video или Video-LLaMA
        self.vlm_model = self._load_video_llm(config.get('vlm_model'))
        self.clip_duration = config.get('clip_duration', 16)  # кадров
        self.fps_sample = config.get('fps_sample', 8)  # fps для анализа

    def extract_clips(self, video_path: str) -> list[np.ndarray]:
        """Нарезаем видео на клипы для action recognition"""
        cap = cv2.VideoCapture(video_path)
        original_fps = cap.get(cv2.CAP_PROP_FPS)
        sample_interval = max(1, int(original_fps / self.fps_sample))
        clips = []
        current_clip = []
        frame_idx = 0
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            if frame_idx % sample_interval == 0:
                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                current_clip.append(frame_rgb)
                if len(current_clip) == self.clip_duration:
                    clips.append(np.array(current_clip))
                    current_clip = current_clip[self.clip_duration // 2:]  # overlap 50%
            frame_idx += 1
        cap.release()
        return clips

    @torch.no_grad()
    def classify_actions(self, clips: list[np.ndarray]) -> list[dict]:
        results = []
        for i, clip in enumerate(clips):
            inputs = self.action_processor(
                list(clip),
                return_tensors='pt'
            ).to('cuda')
            outputs = self.action_model(**inputs)
            probs = torch.softmax(outputs.logits, dim=-1)[0]
            top5_probs, top5_ids = probs.topk(5)
            results.append({
                'clip_idx': i,
                'start_frame': i * self.clip_duration // 2,
                'actions': [
                    {
                        'label': self.action_model.config.id2label[idx.item()],
                        'probability': prob.item()
                    } for prob, idx in zip(top5_probs, top5_ids)
                ]
            })
        return results

חיפוש וידאו: חיפוש סמנטי בארכיון וידאו

import faiss
from transformers import CLIPProcessor, CLIPModel

class VideoSemanticSearch:
    """
    CLIP эмбеддинги кадров → FAISS индекс → поиск по тексту.
    Быстрый способ найти «момент, где человек падает» в 1000-часовом архиве.
    """
    def __init__(self):
        self.clip_model = CLIPModel.from_pretrained(
            'openai/clip-vit-large-patch14'
        ).cuda()
        self.clip_processor = CLIPProcessor.from_pretrained(
            'openai/clip-vit-large-patch14'
        )
        self.index = faiss.IndexFlatIP(768)  # CLIP ViT-L/14 dim = 768
        self.frame_metadata = []  # (video_id, timestamp)

    @torch.no_grad()
    def index_video(self, video_path: str, video_id: str, sample_every_n: int = 30):
        cap = cv2.VideoCapture(video_path)
        fps = cap.get(cv2.CAP_PROP_FPS)
        frame_idx = 0
        batch_frames = []
        batch_meta = []
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            if frame_idx % sample_every_n == 0:
                pil_frame = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
                batch_frames.append(pil_frame)
                batch_meta.append((video_id, frame_idx / fps))
                if len(batch_frames) >= 32:
                    self._process_batch(batch_frames, batch_meta)
                    batch_frames, batch_meta = [], []
            frame_idx += 1
        if batch_frames:
            self._process_batch(batch_frames, batch_meta)
        cap.release()

    def _process_batch(self, frames: list, meta: list):
        inputs = self.clip_processor(
            images=frames,
            return_tensors='pt',
            padding=True
        ).to('cuda')
        embs = self.clip_model.get_image_features(**inputs)
        embs = embs / embs.norm(dim=-1, keepdim=True)
        embs_np = embs.cpu().float().numpy()
        faiss.normalize_L2(embs_np)
        self.index.add(embs_np)
        self.frame_metadata.extend(meta)

    @torch.no_grad()
    def search(self, query: str, top_k: int = 10) -> list[dict]:
        inputs = self.clip_processor(
            text=[query],
            return_tensors='pt',
            padding=True
        ).to('cuda')
        text_emb = self.clip_model.get_text_features(**inputs)
        text_emb = text_emb / text_emb.norm(dim=-1, keepdim=True)
        text_np = text_emb.cpu().float().numpy()
        faiss.normalize_L2(text_np)
        scores, indices = self.index.search(text_np, top_k)
        results = []
        for score, idx in zip(scores[0], indices[0]):
            video_id, timestamp = self.frame_metadata[idx]
            results.append({
                'video_id': video_id,
                'timestamp_sec': timestamp,
                'score': float(score)
            })
        return results

הסקה זמנית: Video-LLM לשאילתות מורכבות

class VideoLLMAnalyzer:
    """ Video-LLaVA, LLaVA-Video или Qwen2-VL с видео-входом.
    Для вопросов типа «что происходит в конце видео?»,
    «сколько раз человек посмотрел в камеру?»
    """
    def __init__(self):
        # Qwen2-VL поддерживает видео до 256 кадров
        from transformers import Qwen2VLForConditionalGeneration
        self.model = Qwen2VLForConditionalGeneration.from_pretrained(
            'Qwen/Qwen2-VL-7B-Instruct',
            torch_dtype=torch.bfloat16,
            device_map='auto'
        )

    def query_video(self, video_path: str, question: str) -> str:
        # Семплируем не более 32 кадров равномерно
        frames = self._sample_frames(video_path, n=32)
        # Формируем prompt с видео-токенами
        response = self._generate(frames, question)
        return response

איך לייעל את ביצועי הבנת הווידאו?

וידאו מייצר כמות עצומה של נתונים. 24 שעות הקלטה ב-30fps = 2.6M פריימים. עיבוד כל פריים אינו יעיל:

• דגימה מבוססת תנועה: עיבוד רק פריימים עם תנועה (חיסור רקע כמסנן)
• דגימה אדפטיבית: לזיהוי פעולות, 8fps מספיק; לזיהוי עצמים, 15fps
• אינדוקס היררכי: תחילה ברמת סצנה (מה קורה בסצנה), ולאחר מכן ברמת פריים

תהליך הטמעת מערכת להבנת וידאו

1. ניתוח משימה עסקית: אילו תרחישים (חיפוש, מעקב, זיהוי חריגות), גודל ארכיון, דרישות זמן השהיה, תקציב.
2. איסוף וסימון מערך נתונים: מההקלטות שלך, אנחנו בוחרים קטעים מייצגים, מסמנים פעולות ואירועים (אם יש צורך בזיהוי עצמים ספציפיים, אנחנו מבצעים fine-tuning למודלים).
3. בחירת מודל ו-fine-tuning: השוואת VideoMAE, TimeSformer, CLIP, Video-LLM על דיוק ומהירות. Fine-tuning על הנתונים שלך משפר את ה-recall ב-15–25%.
4. פריסה: (API, Docker, אינטגרציה עם התשתית שלך).
5. בדיקות ואופטימיזציה: מדידת Precision/Recall, זמן השהיה p99, הפחתת עומס inference באמצעות ONNX/INT8 quantization.
6. תמיכה: תיעוד ה-pipeline, הדרכת מפעילים, מתן תמיכה למשך חודש לאחר הפריסה.

מה כלול

• תיעוד: תיאור ארכיטקטורה, כרטיס מודל, מפרט API.
• גישה: אתה מקבל מודלים מאומנים, סקריפטים לאינדוקס, דוגמאות שימוש.
• הדרכה: הצוות שלך יכול להריץ חיפוש באופן עצמאי ולפרש תוצאות.
• תמיכה: תיקוני באגים, ייעוץ בכיול ספים, עזרה בהרחבה לנתונים חדשים.

לוחות זמנים משוערים

העלות מחושבת באופן אישי לאחר ניתוח הנתונים שלך. לקוחות בדרך כלל רואים החזר השקעה תוך 3 חודשים, עם חיסכון שנתי העולה על $50,000 עבור ארכיוני וידאו גדולים. הפתרונות שלנו מספקים חיסכון של 40-70% בעלויות ניתוח וידאו, המסתכם ביותר מ-$10,000 לחודש עבור ארגונים בינוניים. צור איתנו קשר — נעריך את הפרויקט תוך יומיים. קבל ייעוץ על ארכיוני הווידאו שלך. הזמן פרויקט פיילוט כדי להעריך דיוק על הנתונים שלך.

מאמר VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training

טיעונים נוספים: הניסיון שלנו מראה שמערכות להבנת וידאו מאיצות את עבודת האנליסט ב-70%. אנחנו מבטיחים דיוק של לא פחות מ-90% על מערך הנתונים שלך לאחר fine-tuning.