Статус: В розробці в рамках lucidRAG. Источник: github.comM SK1scottgal/lucidrag

Де це підходить?: VideoSummarizer - це оркестр lucidRAG сім 'я,, яка об' єднує три труби в єдиний аналіз відеоігрівного двигунаM SK1

• DocSummarizer - Документи
• ImageSummarizer - Фото 22- хвиля візуальна інтелект МSK2 Вмонтування CLIP embeddings
• AudioSummarizer - Аудіо акустичний профиль МSK2 диарізація гучномовця
• Відеозбиральник ( цей artykuł ) МSK2 відео МSK3 організовує всі три композиції МСК4 додає кадру MСК5 сценічний простір М СК6
• DataSummarizer МSK0 Дані ( Сchéма висновків МSK2 Profilування )

Все йде так само Снижена модель RAG: виокремлює сигнали, як тільки МSK1 зберігає дані МSK2 синтезує з обмеженим входом LLM .

Обробка двогодинної кадру фільму з вбудовами CLIP займатиме багато годин і коштуватиме сотні доларів в обчисленнях.

VideoSummarizer вирішує це за допомогою трьох ключових оптимацій:

1. Усвідомлене відхилення хешів - Перемикайте візуально схожі кадри перед дорогою МЛ МSK1 скорочення
2. Введення пакету CLIP - Процес МSK1 зображення на одну пропускну здатність GPU замість одного МSK2x прискорення
3. Состав трубопроводу - Chain ImageSummarizer для клавіатур , AudioSummarzer для мови M SK2 NER для об 'єктів

Результатом є: : час перегляду фільмів в МSK1 годині, а не годині. ImageSummarizer і AudioSummarizer, але з 'єднане в об' єднаний канал відеоаналізуM SK1

Погляньмо на сутність Відео - кадри + аудіо МSK1 текст МSK2 обробка кожного домена за допомогою спеціалізованих інструментів , поєднання результатів у послідовні сцени

• Спочатку - структура процесу (різанняМSK1 ЯM SK2фрази МSK3 аудіо-сегменти )
• Одного разу виділити рухові сигнали МSK0введення, транскрипції

Термінологія:

• Збиття камера відбирає між розрізами (структурнийM SK1 від детекторії сцени FFmpeg)
• Сcèна континуальна група стрічок, що формує однорідний об 'єкт (семантичний МSK1 з кластерування МSK2
• Докази (start_time, end_time) + сигнали

Найкращі моделі ML

• Кліп OpenAI's Contrastive Language-Image PreM SK2trainingMSC3 генерує 512-dimensional embeddings, що кодують візуальну семантику
• Сміх Модель розпізнавання мовлення OpenAI ' МSK1 переписує аудіо на текст за допомогою тайм-тамп
• BERT-NER Назвизнання учасників; виокремлює місця з тексту людей
• Пропускний час на NX Кросс-платформенний ML висновокМSK1 запускає моделі на CPUM SK2ГПЗ без блокування фреймворка

Цей artykuł стосується:

• Як VideoSummarizer організує три канали? (ImageSum marizerM SK1 AudioSommarizer , NER)
• Архітектура хвиль : 16 хвилі від нормалізації до створення доказів
• Система можливостей: Lazy model downloads , Detection GPUM SK2 Reactive routing
• Оптимізація пакету CLIP для вбудованих ключів (3-5x швидшеM SK1
• (40% скорочення кадруM SK1
• Мультихвимірний-кластерування сигналу сцени M SK1введення + транскрипція МSK3 тип відрізання
• Інтеграція NER для видобутку об 'єктів з транскрипцій
• Ефемеральні атоми для обмеження швидкості, очікування часуM SK1 і зворотнього тиску
• Виходи МСК0 сцени МSK1 кадри , транскрипції, текстові стрічки як докази РАG

Подібні статті:

• Reduced RAG - Корінна модель
• Стриманий візерунок невизначеності - Фундаментальна модель
• Reduced RAG Implementations:
  • DocSummarizer - RAG документу з вилученням об 'єктів
  • ImageSummarizer - РАГ зображення з МSK1 хвильною візуальною інтелекцією
  • AudioSummarizer - Озвучна судебна характеристика
  • Відеозберегатель ( цей artykuł ) - Оркестр відеорозвідки

Проблема: Відео дорого коштує

Оцінки: Числа, вимірювані на AMD 9950X МSK2 ядро МSK3 / NVIDIA AM SK5 | | МSK6 ГБ | ) ♪ / |96 ГB оперативної пам 'яті

Типовий фільм містить:

• кадри ~170,000 (2 годин на МSK1fpsM SK2
• ~2 годин звуку (говоритиM SK1 слухати музику
• Багато текстових шарів (заголовкиМSK1 кредитиМСК2 на екраніMСК3текстуМ СК4

( Ніхто не робить цьогоM SK1 але він визначає масштаб):

• Введення кліпу на рамки: M SK1ms × ♫ ♫ 9.4 години
• Базовий LLM за кадр: M SK1s × | | МSK3 | = 94 години (cloud Vision API ballpark

Навіть з вилученням ключів кадру (стверджуємо , МSK2 кадри МSK3 що M' все ще МСК5 секунди послідовного висновку CLIP

Традиційний підхід: МSK1Извадити клавіатуруM SK2 відправити до Vision LLM, сподіватися на найкращуMSC4

Проблема: Це загоряє обчислення над надлишками кадрів (багато клавішних кадрів візуально схожі МSK2 обробляє їх серійно МSK3 ГПЗ позадіяний між кадрами мSK4 і пропустив аудіо M/ текстові сигнали повністю МСК6

Рішення: Мультифріалізація МSK1 етапи очистки МSK2 переробка пакетів , і конструкція трубопроводу

Архітектура VideoSummarizer

Втілення VideoSummarizer Reduced RAG для відео з трьома кадрами

flowchart TB
    subgraph Input["Video File (.mp4, .mkv, etc.)"]
        V[Video Stream]
        A[Audio Stream]
    end

    subgraph Stage1["Stage 1: Structural Analysis"]
        N[NormalizeWave<br/>FFprobe metadata]
        SD[ShotDetectionWave<br/>Scene cuts via FFmpeg]
        KE[KeyframeExtractionWave<br/>I-frame + dedup]
    end

    subgraph Stage2["Stage 2: Content Extraction"]
        IS[ImageSummarizer<br/>CLIP, OCR, Vision]
        AS[AudioSummarizer<br/>Whisper, Diarization]
        NER[NER Service<br/>Entity extraction]
    end

    subgraph Stage3["Stage 3: Scene Assembly"]
        SC[SceneClusteringWave<br/>CLIP similarity]
        EV[EvidenceGenerationWave<br/>RAG chunks]
    end

    V --> N --> SD --> KE
    KE --> IS
    A --> AS
    AS --> NER
    IS --> SC
    NER --> SC
    SC --> EV

    style Stage1 stroke:#22c55e,stroke-width:2px
    style Stage2 stroke:#3b82f6,stroke-width:2px
    style Stage3 stroke:#8b5cf6,stroke-width:2px

Вироблені артефакти доказів

Перед тим, як перейти до втілення, ось що ви отримаєте:

Кожен артефакт містить походження: джерело хвилі МSK1 тайм-показування обробки МSK2 показник довіри . Це \ "\ ledger доказів ", на якому базуються RAG пошуки

Сигнал-Усвідомлена хвиля труба

VideoSummarizer використовує архітектура хвиль на основі сигналу- де кожна хвиля явно заявляє про свої сигнали

public interface ISignalAwareVideoWave
{
    /// <summary>Signals this wave requires before it can run.</summary>

    IReadOnlyList<string> RequiredSignals { get; }

    /// <summary>Signals this wave can optionally use if available.</summary>

    IReadOnlyList<string> OptionalSignals { get; }

    /// <summary>Signals this wave emits on successful completion.</summary>

    IReadOnlyList<string> EmittedSignals { get; }

    /// <summary>Cache keys this wave produces for downstream waves.</summary>

    IReadOnlyList<string> CacheEmits { get; }

    /// <summary>Cache keys this wave consumes from upstream waves.</summary>

    IReadOnlyList<string> CacheUses { get; }
}

Це дозволяє динамічна координація хвиль:

• Води прокидаються автоматично, якщо не вистачає сигналів
• Відлежність вирішується в часі запуску (без кодування
• Частково повторювані запуски є відтворюваними ( таємним ключем сигналуM SK1
• Гранулярність розвитку інтерфейсу: кожна хвиля випромінює прогрес незалежно

Трубопровод 16-

Видобуток ключів застосовується як 7 гранулові хвилі для кращого паралелізму та ефективностіキャッシュуM SK1

Примітки:

• Використовується ImageAnalysisWave keyframes.deduplicated (не повнийM SK1res): ОCR працює на миниатюрах ; візуальне субтитриювання використовує повну МSK4res, коли доступно за допомогою маршрутизування
• Волки 3-7 - це видобуток ключів МSK1, МSK2 під - трубина \ (7 гранулові хвилі для ефективностіキャッシュу \ МSK5

Загалом за 2-години фільмуМSK0 ~10-15 хвилини МSK2 проти . годин без оптимізації

Знайомі ключі сигналу

Сигнали визначаються як константи консистенції:

public static class VideoSignals
{
    // NormalizeWave signals
    public const string VideoDuration = "video.duration";
    public const string VideoFps = "video.fps";
    public const string VideoNormalized = "video.normalized";

    // Shot detection signals
    public const string ShotsDetected = "shots.detected";
    public const string ShotsCount = "shots.count";

    // Keyframe signals
    public const string IframesDetected = "keyframes.iframes_detected";
    public const string KeyframesSelected = "keyframes.selected";
    public const string KeyframesDeduplicated = "keyframes.deduplicated";
    public const string KeyframesExtracted = "keyframes.extracted";

    // CLIP embedding signals
    public const string ClipEmbeddingsReady = "clip.embeddings_ready";

    // Scene clustering signals
    public const string ScenesDetected = "scenes.detected";
    public const string SceneCount = "scene.count";

    // Transcription signals
    public const string TranscriptionComplete = "transcription.complete";
}

Система пропускної спроможності: Лазерні моделі M SK1 Руйтинг

VideoSummarizer використовує здатність-засаджена архітектура: розпізнати GPU один раз на старті , завантажити моделі неохоче МSK2 працювати маршрутом до доступних компонентів .

Модель Маніфест (YAML + Тип МSK2Безопасні константиM SK3

Моделі визначаються в models.yamlніяких магічних стрічок в коді:

# models.yaml (excerpt)
models:
  clip-vit-b32:
    name: "CLIP ViT-B/32"
    download_url: "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/onnx/visual_model.onnx"
    preferred_providers: [CUDAExecutionProvider, DmlExecutionProvider, CPUExecutionProvider]

components:
  ClipEmbeddingWave:
    models: [clip-vit-b32]
    fallback_chain: [ImageAnalysisWave]

// Type-safe constants (no raw strings)
await coordinator.EnsureModelAsync(ModelIds.ClipVitB32);
await coordinator.ActivateWaveAsync(ComponentIds.TranscriptionWave);

// Route with fallback
var route = await coordinator.RouteWorkAsync(new[]
{
    ComponentIds.ClipEmbeddingWave,    // Primary (GPU)
    ComponentIds.ImageAnalysisWave     // Fallback (CPU)
});

Атоми ефективності трубопроводу

Ограничення швидкості, оцінка часуM SK1 та пристосований зворотній тиск дають інтерфейсу змогу реагувати, водночас збільшуючи пропускну спроможність:

// Time estimation from actual data
var estimator = CapabilityAtoms.CreateTimeEstimator();
using (estimator.Time("clip_embedding")) { await ProcessAsync(); }
var eta = estimator.GetEstimate("clip_embedding", remaining: 50);
// eta.Estimated, eta.Optimistic, eta.Pessimistic, eta.Confidence

Доки системи повних можливостей: Подивіться Mostlylucid.Summarizer.Core/Capabilities/ для розпізнавання ҐПУ, сигналова паббаM SK1 суборівникиМSK2 контролери зворотнього тиску МSK3 та дизайн сітки

Оптимізація ключів 1: Perceptual Hash Deduplication

Перед запуском дорогих вбудованих CLIP, VideoSummarizer відфільтрує візуально схожі кадри, використовуючи різниця hash (dHashM SK1.

Як працює dHash

public class KeyframeDeduplicationService
{
    // dHash parameters: 9x8 grayscale = 64 bits
    private const int HashWidth = 9;
    private const int HashHeight = 8;
    private const int DefaultHammingThreshold = 10;

    public async Task<ulong> ComputeDHashAsync(string imagePath, CancellationToken ct)
    {
        using var image = Image.Load<Rgba32>(imagePath);

        // Resize to 9x8 (one extra column for gradient comparison)
        image.Mutate(x => x
            .Resize(HashWidth, HashHeight)
            .Grayscale());

        ulong hash = 0;
        int bit = 0;

        // Compare adjacent pixels horizontally
        for (int y = 0; y < HashHeight; y++)
        {
            for (int x = 0; x < HashWidth - 1; x++)
            {
                var left = image[x, y].R;
                var right = image[x + 1, y].R;

                // Set bit if left pixel is brighter than right
                if (left > right)
                {
                    hash |= (1UL << bit);
                }
                bit++;
            }
        }

        return hash;
    }

    public static int HammingDistance(ulong a, ulong b) =>
        BitOperations.PopCount(a ^ b);
}

Ось вихідний код:

Input: 50 keyframe candidates (from codec I-frames)

Deduplication (Hamming threshold 10):
  Frame 0: hash=0x8f3a2c1d → KEEP (first frame)
  Frame 1: hash=0x8f3a2c1e → SKIP (distance=1 from frame 0)
  Frame 2: hash=0x8f3a2c1f → SKIP (distance=2 from frame 0)
  Frame 3: hash=0xc7e1b4a2 → KEEP (distance=28 from frame 0)
  ...

Result: 50 → 30 frames (40% reduction)
Processing saved: ~8 seconds of CLIP inference

Чому це важливо:

• ~40% скорочення кадру про типовий контент
• <1м за кадр для хешового обчислення (vs. 200ms для CLIPM SK3
• Фильтрує надлишкові кадри до цього дорогих операцій на GPU

Оптимізація ключів 2: Вмонтування пакету CLIP

Замість того, щоб обробляти одне зображення в один раз, VideoSummarizer пакети M SK1 зображення на GPU pass.

Архітектура Batch Processing

public class BatchClipEmbeddingService
{
    private const int ClipImageSize = 224;
    private const int DefaultBatchSize = 8; // 8 images per GPU pass

    public async Task<Dictionary<int, float[]>> GenerateBatchEmbeddingsAsync(
        Dictionary<int, string> framePaths,
        int batchSize = DefaultBatchSize,
        CancellationToken ct = default)
    {
        var session = await GetOrLoadClipModelAsync(ct);
        var results = new Dictionary<int, float[]>();

        // Pre-index batch for O(1) lookup (not batch.IndexOf!)
        var batches = framePaths
            .Select((kvp, idx) => (idx, kvp.Key, kvp.Value))
            .Chunk(batchSize);

        foreach (var batch in batches)
        {
            // Create batch tensor [batchSize, 3, 224, 224]
            var tensor = new DenseTensor<float>(new[] { batch.Length, 3, ClipImageSize, ClipImageSize });

            // Preprocess images in parallel (simplified; production uses vectorised span copy)
            Parallel.ForEach(batch, item =>
            {
                var (batchIdx, frameIndex, path) = item;
                var localIdx = batchIdx % batchSize;
                PreprocessImageToTensor(path, tensor, localIdx); // ImageSharp pixel buffers
            });

            // Single GPU pass for entire batch
            var inputs = new List<NamedOnnxValue>
            {
                NamedOnnxValue.CreateFromTensor("input", tensor)
            };

            using var outputResults = session.Run(inputs);
            // Extract embeddings from batch output...
        }

        return results;
    }
}

Порівняння ефективності:

Input: 30 keyframes (after deduplication)

Serial processing (1 frame at a time):
  30 × 200ms = 6,000ms (6.0 seconds)

Batch processing (8 frames per pass):
  4 batches × 350ms = 1,400ms (1.4 seconds)

Speedup: 4.3x

Чому працевлаштування пакетів працює:

• Паралергізм ҐПУ недооцінюється з одним-виводом зображення
• Командний тензор [8, 3, 224, 224] використовує таку ж пам 'ять, як і один зображень (almostM SK1
• Программа Runtime ONNX оптимізує пакетні операції всередині

Key Optimization 3: Конструкція трубопроводу

VideoSummarizer не перетворює ImageSum marizer чи AudioSommarizerit ланцюги вони.

Ключевой кадр Sub-PipelineM SK1 Інтеграція з ImageSummarizer

Видобуток ключів розділяється на 7 гранулярні хвилі МSK1 бачите таблицю хвиль вище МSK2 Тут ' є модель координації, яка показує, як вони з 'єднуються

// IFrameDetectionWave → KeyframeSelectionWave → ThumbnailExtractionWave
// → KeyframeDeduplicationWave → KeyframeFullResExtractionWave → ClipEmbeddingWave

// ClipEmbeddingWave coordinates with ImageSummarizer
public class ClipEmbeddingWave : IVideoWave, ISignalAwareVideoWave
{
    public IReadOnlyList<string> RequiredSignals => [VideoSignals.KeyframesExtracted];
    public IReadOnlyList<string> EmittedSignals => [VideoSignals.ClipEmbeddingsReady];

    public async Task ProcessAsync(VideoContext context, CancellationToken ct)
    {
        var keyframes = context.GetCached<Dictionary<int, string>>("keyframes.paths");

        // Batch CLIP embedding (3-5x faster than serial)
        var embeddings = await _batchClipService.GenerateBatchEmbeddingsAsync(
            keyframes, batchSize: 8, ct);

        foreach (var (frameIndex, embedding) in embeddings)
            context.KeyframeEmbeddings[frameIndex] = embedding;
    }
}

// ImageAnalysisWave runs ImageSummarizer on deduplicated frames
public class ImageAnalysisWave : IVideoWave, ISignalAwareVideoWave
{
    public IReadOnlyList<string> RequiredSignals => [VideoSignals.KeyframesDeduplicated];

    public async Task ProcessAsync(VideoContext context, CancellationToken ct)
    {
        var keyframePaths = context.GetCached<List<string>>("keyframes.deduplicated_paths");

        foreach (var path in keyframePaths)
        {
            // Run ImageSummarizer for OCR, vision, captions
            var result = await _imageOrchestrator.AnalyzeAsync(path, ct);
            context.SetCached($"image_analysis.{Path.GetFileName(path)}", result);
        }
    }
}

TranscriptionWave: Інтеграція AudioSummarizer

Видобуток аудіо та транскрипція - тепер окремі сигнали

// AudioExtractionWave runs first (extracts audio track from video)
public class AudioExtractionWave : IVideoWave, ISignalAwareVideoWave
{
    public IReadOnlyList<string> RequiredSignals => [VideoSignals.VideoNormalized];
    public IReadOnlyList<string> EmittedSignals => ["audio.extracted", "audio.path"];

    public async Task ProcessAsync(VideoContext context, CancellationToken ct)
    {
        var audioPath = await _ffmpegService.ExtractAudioAsync(
            context.VideoPath, context.WorkingDirectory, ct);
        context.SetCached("audio.path", audioPath);
    }
}

// TranscriptionWave depends on audio.extracted signal
public class TranscriptionWave : IVideoWave, ISignalAwareVideoWave
{
    public IReadOnlyList<string> RequiredSignals => ["audio.extracted"];
    public IReadOnlyList<string> EmittedSignals => [
        VideoSignals.TranscriptionComplete,
        "transcription.utterance_count"
    ];

    public async Task ProcessAsync(VideoContext context, CancellationToken ct)
    {
        var audioPath = context.GetCached<string>("audio.path");

        // Run AudioSummarizer pipeline (Whisper + diarization)
        var audioProfile = await _audioOrchestrator.AnalyzeAsync(audioPath, ct);

        // Extract utterances with speaker info
        var turns = audioProfile.GetValue<List<SpeakerTurn>>("speaker.turns");
        foreach (var turn in turns ?? [])
        {
            context.Utterances.Add(new Utterance
            {
                Id = Guid.NewGuid(),
                Text = turn.Text,
                StartTime = turn.StartSeconds,
                EndTime = turn.EndSeconds,
                SpeakerId = turn.SpeakerId,
                Confidence = turn.Confidence
            });
        }

        // Run NER on full transcript for entity extraction
        var transcript = audioProfile.GetValue<string>("transcription.full_text");
        if (!string.IsNullOrEmpty(transcript))
        {
            var entities = await _nerService.ExtractEntitiesAsync(transcript, ct);
            context.SetCached("transcript_entities", entities);

            // Emit entity signals by type (PER, ORG, LOC, MISC)
            foreach (var group in entities.GroupBy(e => e.Type))
            {
                context.AddSignal($"transcript.entities.{group.Key.ToLowerInvariant()}",
                    group.Select(e => e.Text).Distinct().ToList());
            }
        }
    }
}

Інтеграція NER: Визначання наименованих об 'єктів

VideoSummarizer виділяє названі сутності з транскрипцій, використовуючи BERT-based NER

OnnxNerService

public class OnnxNerService
{
    // Model: dslim/bert-base-NER (ONNX exported)
    // Entities: PER (Person), ORG (Organization), LOC (Location), MISC (Miscellaneous)

    public async Task<List<EntitySpan>> ExtractEntitiesAsync(string text, CancellationToken ct)
    {
        var entities = new List<EntitySpan>();

        // Chunk long text (BERT max 512 tokens)
        foreach (var chunk in ChunkText(text, maxTokens: 400, overlap: 50))
        {
            // Tokenize with WordPiece
            var tokens = _tokenizer.Tokenize(chunk);

            // Run ONNX inference
            var inputs = PrepareInputs(tokens);
            using var results = _session.Run(inputs);

            // Decode BIO tags
            var predictions = DecodePredictions(results);
            var chunkEntities = ExtractEntitySpans(tokens, predictions);

            entities.AddRange(chunkEntities);
        }

        // Deduplicate entities
        return entities
            .GroupBy(e => (e.Text.ToLowerInvariant(), e.Type))
            .Select(g => g.First())
            .ToList();
    }
}

Ось вихідний код:

Transcript: "Today we're speaking with John Smith from Microsoft about
their new AI lab in Seattle. The project, codenamed Phoenix, builds
on research from Stanford University."

Entities extracted:
  PER: John Smith
  ORG: Microsoft, Stanford University
  LOC: Seattle
  MISC: Phoenix

Signals emitted:
  transcript.entities.per = ["John Smith"]
  transcript.entities.org = ["Microsoft", "Stanford University"]
  transcript.entities.loc = ["Seattle"]
  transcript.entities.misc = ["Phoenix"]

Чому NER важливо для відео:

• Включає такі питання, як "Найти відео, яке говорить про MicrosoftM SK1
• Ссылки до графу об 'єктів DocSummarizer
• Додає структурованих метадань без висновків LLM

Multi-Кlustering сигналу на сцені

Використовуючи вбудовані CLIP лише для виявлення сцени, ' не працює добре; кільці кадри є розсіяними по дизайну ( одна зміна на кадрі МSK2 але кадри щільні ♫ . З вбудованими в МSK4 для ♫ МSK5 ♫ кадрів ♫(~2% об 'ємом ♫

VideoSummarizer використовує мульти---сигнальний підхід що об 'єднує 4 вагані сигнали для надійного виявлення кордону сцениM SK1

SceneClusteringWave : Multi-Signal Architecture

public class SceneClusteringWave : IVideoWave, ISignalAwareVideoWave
{
    // Signal weights for boundary scoring
    private const double EmbeddingWeight = 0.4;   // CLIP embedding dissimilarity
    private const double TranscriptWeight = 0.3;  // Semantic shift in transcript
    private const double CutTypeWeight = 0.2;     // Fade/dissolve detection
    private const double TemporalWeight = 0.1;    // Time since last scene

    // Temporal constraints
    private const double MinSceneDuration = 15.0;   // Don't split scenes < 15s
    private const double MaxSceneDuration = 300.0;  // Force split at 5 minutes
    private const double TargetSceneDuration = 90.0; // Prefer ~90s scenes

    public IReadOnlyList<string> RequiredSignals => [VideoSignals.ShotsDetected];
    public IReadOnlyList<string> OptionalSignals => [
        VideoSignals.ClipEmbeddingsReady,
        VideoSignals.TranscriptionComplete,
        VideoSignals.KeyframesDeduplicated
    ];
    public IReadOnlyList<string> EmittedSignals => [
        VideoSignals.ScenesDetected,
        "scene.count",
        "scene.avg_duration",
        "scene.clustering_method"
    ];

    private List<(int shotIndex, double score)> ComputeBoundaryScores(VideoContext context)
    {
        var shots = context.Shots.OrderBy(s => s.StartTime).ToList();
        var scores = new List<(int, double)>();

        // Build embedding map with nearest-neighbor interpolation
        var shotEmbeddings = PropagateEmbeddingsToNearbyShots(context, shots);

        // Build transcript windows for semantic shift detection
        var transcriptWindows = BuildTranscriptWindows(context, shots, windowSeconds: 10);

        for (int i = 0; i < shots.Count - 1; i++)
        {
            double score = 0;
            var currentShot = shots[i];
            var nextShot = shots[i + 1];

            // 1. Embedding dissimilarity (40%)
            if (shotEmbeddings.TryGetValue(i, out var currentEmbed) &&
                shotEmbeddings.TryGetValue(i + 1, out var nextEmbed))
            {
                var similarity = CosineSimilarity(currentEmbed, nextEmbed);
                score += (1.0 - similarity) * EmbeddingWeight;
            }

            // 2. Transcript semantic shift (30%)
            if (transcriptWindows.TryGetValue(i, out var currentWords) &&
                transcriptWindows.TryGetValue(i + 1, out var nextWords))
            {
                var overlap = currentWords.Intersect(nextWords).Count();
                var union = currentWords.Union(nextWords).Count();
                var jaccard = union > 0 ? (double)overlap / union : 0;
                score += (1.0 - jaccard) * TranscriptWeight;
            }

            // 3. Cut type signal (20%) - fades/dissolves suggest scene boundaries
            if (currentShot.CutType is "fade" or "dissolve")
            {
                score += CutTypeWeight;
            }

            // 4. Temporal pressure (10%) - encourage splits near target duration
            var timeSinceLastScene = currentShot.EndTime - GetLastSceneBoundary();
            if (timeSinceLastScene > TargetSceneDuration)
            {
                var pressure = Math.Min(1.0, (timeSinceLastScene - TargetSceneDuration) / 60);
                score += pressure * TemporalWeight;
            }

            scores.Add((i, score));
        }

        return scores;
    }
}

Найголовніші нововведення

1. Найближчий-Поміжній Embedding Propagation: Лише МSK1 кадрів мають прямі вбудовані CLIPM SK2 Цей новий підхід розповсюджує вбудовання на близькі кадри за МSK3 секунд, використовуючи теорію пристосованості до часу .

2. Перепис Semantic Windows: Збудовує МSK1секундні словні вікна навколо кожного кадру і визначає семантичні зміни за допомогою відстані від Джаккарда - дешевий прокси семантичного дрейфу МSK2нижча перехрестя = зміна тем СМСК4 БМ МСК5 перехрестя або вбудований дрейф можна використати, коли це доступно ММСК6

3. Усвідомлення типу розрізу: Згасання МSK1 доM SK2чорні та розчинні переходи сильно показують межі сцени МSK3 підвищує показник граничного результату .

4. Пристосовальне обмеження: Замість фіксованої початкової позначкиM SK1 вибирає межі з верхньої частини МSK2 балів

5. Тиморальні обмеження: Встановлює мінімальну МSK1 сцени і силує кордони на МSK2максимальний час .

Наприклад:

Input: 1881 shots from a 2-hour movie
       39 keyframes with CLIP embeddings
       2302 utterances from transcript

Boundary scoring per shot:
  Shot 45-46: embedding=0.15, transcript=0.32, cut=0.0, temporal=0.0 → score=0.156
  Shot 46-47: embedding=0.08, transcript=0.12, cut=0.0, temporal=0.0 → score=0.068
  Shot 47-48: embedding=0.35, transcript=0.41, cut=0.2, temporal=0.05 → score=0.388 ← BOUNDARY
  ...

Adaptive threshold (top 25%): 0.25
Natural boundaries found: 45

Output: 47 scenes (avg 2.6 minutes per scene)
  - Min scene: 15.2s
  - Max scene: 298.4s
  - Total coverage: 100%

Signals:
  scenes.detected = true
  scene.count = 47
  scene.avg_duration = 156.3
  scene.clustering_method = "multi_signal_weighted"

Контракт на відеосигнał

VideoSummarizer розширює контракт із ImageSum marizer і AudioSumMarizer:

public record VideoSignal
{
    public required string Key { get; init; }      // "scene.count", "transcript.entities.per"
    public object? Value { get; init; }
    public double Confidence { get; init; } = 1.0;
    public required string Source { get; init; }   // "SceneClusteringWave"

    // Video-specific: time range
    public double? StartTime { get; init; }
    public double? EndTime { get; init; }

    public DateTime Timestamp { get; init; }
    public Dictionary<string, object>? Metadata { get; init; }
    public List<string>? Tags { get; init; }       // ["visual", "scene"]
}

public static class VideoSignalTags
{
    public const string Visual = "visual";
    public const string Audio = "audio";
    public const string Speech = "speech";
    public const string Ocr = "ocr";
    public const string Motion = "motion";
    public const string Scene = "scene";
    public const string Shot = "shot";
    public const string Metadata = "metadata";
}

Випущені ключові сигнали:

Виведення RAG

І VideoPipeline конвертує відеосигнал ContentChunk для індексування РАГ:

public class VideoPipeline : PipelineBase
{
    public override string PipelineId => "video";
    public override IReadOnlySet<string> SupportedExtensions => new HashSet<string>
    {
        ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".webm", ".flv", ".m4v", ".mpeg", ".mpg"
    };

    private List<ContentChunk> BuildContentChunks(VideoContext context, string filePath)
    {
        var chunks = new List<ContentChunk>();

        // 1. Scene-based chunks (best for video retrieval)
        foreach (var scene in context.Scenes)
        {
            var sceneText = BuildSceneText(context, scene);
            var embedding = context.GetCached<float[]>($"scene_centroid.{scene.Id}");

            chunks.Add(new ContentChunk
            {
                Text = sceneText,
                ContentType = ContentType.Summary,
                Embedding = embedding,  // Proper vector column, not metadata
                Metadata = new Dictionary<string, object?>
                {
                    ["source"] = "video_scene",
                    ["scene_id"] = scene.Id,
                    ["key_terms"] = scene.KeyTerms,
                    ["speakers"] = scene.SpeakerIds,
                    ["start_time"] = scene.StartTime,
                    ["end_time"] = scene.EndTime
                }
            });
        }

        // 2. Transcript chunks (1-minute windows)
        var transcriptChunks = BuildTranscriptChunks(context, filePath);
        chunks.AddRange(transcriptChunks);

        // 3. Text track chunks (on-screen text/subtitles)
        foreach (var textTrack in context.TextTracks)
        {
            chunks.Add(new ContentChunk
            {
                Text = $"On-screen text: {textTrack.Text}",
                ContentType = ContentType.ImageOcr,
                Metadata = new Dictionary<string, object?>
                {
                    ["source"] = "video_ocr",
                    ["text_type"] = textTrack.TextType.ToString(),
                    ["start_time"] = textTrack.StartTime
                }
            });
        }

        return chunks;
    }

    private string BuildSceneText(VideoContext context, SceneSegment scene)
    {
        var parts = new List<string>();

        if (!string.IsNullOrEmpty(scene.Label))
            parts.Add($"Scene: {scene.Label}");

        parts.Add($"[{FormatTime(scene.StartTime)} - {FormatTime(scene.EndTime)}]");

        if (scene.KeyTerms.Count > 0)
            parts.Add($"Topics: {string.Join(", ", scene.KeyTerms)}");

        // Add utterances in this scene
        var sceneUtterances = context.Utterances
            .Where(u => u.StartTime >= scene.StartTime && u.EndTime <= scene.EndTime)
            .OrderBy(u => u.StartTime);

        if (sceneUtterances.Any())
            parts.Add($"Speech: {string.Join(" ", sceneUtterances.Select(u => u.Text))}");

        return string.Join("\n", parts);
    }
}

Ось приклад виjścia для фільму:

{
  "chunks": [
    {
      "text": "Scene: Opening montage\n[0:00 - 2:34]\nTopics: city, night, traffic\nSpeech: The year is 2049. The world has changed.",
      "contentType": "Summary",
      "metadata": {
        "source": "video_scene",
        "scene_id": "abc123",
        "key_terms": ["city", "night", "traffic"],
        "start_time": 0.0,
        "end_time": 154.0
      }
    },
    {
      "text": "The detective arrived at the crime scene. Forensics had already processed the area.",
      "contentType": "Transcript",
      "metadata": {
        "source": "video_transcript",
        "time_window": "2:34 - 3:34",
        "utterance_count": 4
      }
    },
    {
      "text": "On-screen text: LOS ANGELES 2049",
      "contentType": "ImageOcr",
      "metadata": {
        "source": "video_ocr",
        "text_type": "Title"
      }
    }
  ]
}

Характеристики ефективності

Час обробки (2-години фільму

Без оптимізації

Використовування пам 'яті

Інтеграція з lucidRAG

VideoSummarizer записує як IPipeline для автоматичної маршрутізації:

// In Program.cs
builder.Services.AddDocSummarizer(builder.Configuration.GetSection("DocSummarizer"));
builder.Services.AddDocSummarizerImages(builder.Configuration.GetSection("Images"));
builder.Services.AddVideoSummarizer();  // NEW
builder.Services.AddPipelineRegistry(); // Must be last

// Auto-routing by extension
var registry = services.GetRequiredService<IPipelineRegistry>();
var pipeline = registry.FindForFile("movie.mp4");  // Returns VideoPipeline
var result = await pipeline.ProcessAsync("movie.mp4");

Поддерживані rozszerzenia:

• .mp4, .mkv, .avi, .mov, .wmv, .webm, .flv, .m4v, .mpeg, .mpg

Що ти отримаєш

• Scene-частки RAG рівня: Когерентні сегменти з транскрипціями МSK1 ключові терміни , ID мовця
• Багатоmodальних доказів: візуальний ( вбудова клавіатурного кадру МSK2 аудіо МSK3 диарізація głośnikів MSК4 текст МСК5 ОCR СМСК6 субтилі СМСК7
• Наименовані об 'єктиМСК0 ЛюдиМSK1 організації, Местоположення з транскрипції NER
• Провинція, яку можна перевірити: Кожен сигнал має джерело хвилі , довіра МSK2 timestamps
• Ефективне обробленняМSK0 10-15 хвилин для фільму на час МSK2 годин ( не годин

Скільки це коштує

• ~1.5ГБ оперативної пам 'яті для всіх моделей ONNX
• ~8-10 обробка хвилин за годину фільму
• Дісковий простір для проміжних файлів ( автоматично очищається
• Складність: Оркестрування трьох трубопроводів вимагає розуміння zależności від хвиль

Завершення

VideoSummarizer показує, що з 'єднання трубопроводу шкалки:

1. Повторне використання спеціалізованих труб: Don' не винаходить ImageSummarizer чи AudioSum marizerchain їх
2. Filtrувати перед дорогою операцією: dHash затрати на розмноження <1msM SK2 заощаджує МSK3 висновку CLIP
3. Операції батареї GPUМSK0 8 зображення на ходу МSK2 \ 3-5 x прискорення
4. Витягнути структуру перед змістом: Зйомки МSK1 Сценки ♫ → ♫ Докази ♫ МSK3 ♫ Не сирові кадри ♫
5. Менеджмент ліницьких моделей: завантажити моделі тільки тоді, коли це необхідноM SK1 автоматично виявляти GPU
6. Реактивне маршрутизування: Робот маршруту до доступних компонентів , граційно повертається

Результатом є те, що часовий фільм ":" стає структурованим свідченням сигналу з сценами, транскрипціями, об 'єктами, МSK4 та вбудовами для RAG запитів, таких як МSK5 .

• "Найти сцени, де Джон Сміт обговорює Microsoft
• "Покажіть відеозаписи з текстом на екрані МSK1 про проект Феникс
• "Найти відео, схоже на цю сценуM SK1 (CLIP вбудований пошук)

Снижена модель RAG для відео:

Ingestion:  Video → 16 waves → Signals + Evidence (scenes, transcripts, entities)
Storage:    Signals (indexed) + Embeddings (CLIP, voice) + Evidence (chunks)
Query:      Filter (SQL) → Search (BM25 + vector) → Synthesize (LLM, ~5 results)

Система можливостей:

Startup:    Detect GPU → Load ModelManifest (YAML) → Initialize SignalSink
Activation: Component requests model → Lazy download → Signal "ModelAvailable"
Routing:    Route to best provider → Fallback chain → Backpressure control
Atoms:      Rate limiting + Time estimation + Pipeline balancing

Це Стримана неясність на шкалі:

• Уявні компоненти пропонують сигнали: вбудова (CLIPM SK2 гіпотези OCR, підрахунки диарізації
• Детерміністичне оцінювання об 'єднує структуру: вважені показники граничних балів , відбір порогового показника МSK2 тимчасові обмеження
• LLM (optionalM SK1 синтезує з доказів: обмежений контекст

LLM працює на комп 'ютерних свідченнях, а не на відео.

Ресурс

Документація lucidRAG

• Бібліотека VideoSummarizer - вихідний код
• Документація NER - Архітектура видобутку об 'єктів

Подібні бібліотеки

• ImageSummarizer - Трубопровод візуального інтелекту
• AudioSummarizer - Аудіо-судова трубка
• DocSummarizer - Трубопровод для документування

Моделі ONNX

• СLIP ViT-BM SK1 - візуальні додатки
• ECAPA-TDNN - Вбудова głośnikа
• BERT-NER - Визнання наименованих об 'єктів
• Сміх - Перепис мовлення

Подібні статті

Корейні візерунки:

• Reduced RAG - Корінна модель
• Стриманий візерунок невизначеності - Початкова модель

Reduced RAG Implementations:

• DocSummarizer - RAG документу з вилученням об 'єктів
• ImageSummarizer - РАГ зображення з МSK1 хвильною візуальною інтелекцією
  • Трійковий OCR провід - Зростання OCR
• AudioSummarizer - Озвучна судебна характеристика
• Відеозберегатель ( цей artykuł ) - Оркестр відеорозвідки
• DataSummarizer - Структурування даних та виведення шеми

Серіал

Далі: Мультифікатор МSK1модальний граф RAG з lucidRAG, що об 'єднує всі чотири підсумовники в єдиний граф знань, з' єднаним між собою

Усі частини йдуть за однаковим інваріантом: ймовірнісні компоненти запропонують; детерміністичні системи тривають.