# VideoSummarizer: Reduced RAG for Video (Shots > **Tilanne**: Kehitetään osana [lucidRAG](https://www.lucidrag.com). > **Lähde**: [github.com/scottgalM SK2lucidrag](https://github.com/scottgal/lucidrag) **Missä tämä sopii**: VideoSummarizer on **orkesteri** sopimuksen [lucidRAG](https://www.lucidrag.com) perhe, kolmen putken yhdistäminen yhtenäiseen videoanalyysiin - **[DocSummarizer](/blog/building-a-document-summarizer-with-rag)** - Asiakirjat - **[ImageSummarizer](/blog/constrained-fuzzy-image-intelligence)** - Kuvat - **[AudioSummarizer](/blog/audiosummarizer-forensic-audio-characterization)** - Audio akustinen profilointi, puhujan vääristyminenM SK3 käännösMSC4 - **VideoSummarizer** (artikkeliM SK1 - Video SSK3orchestrates all three, adds shotMSC5scene structureMST6 - **[DataSummarizer](/blog/datasummarizer-how-it-works)** - Tietoja Kaikki seuraavat samaa **[RAG-muodon vähentäminen](/blog/reduced-rag)**: ekstrahoidaan signaalit kerranM SK1 tallennetaan todisteita, synteesoidaan rajattuun LLM-tulokseen --- Kahden tunnin elokuvakehyksen käsittely CLIP-embeddingin avulla maksaisi satoja tunteja ja tuhansia dollareita.. Naiivi lähestymistapa lähentää jokaista kehystä Vision LL:lle. **VideoSummarizer ratkaisee tämän kolmella avainkysymyksellä:** 1. **Perseptuaalinen hashin vähentäminen** - Lähtönäköisesti samankaltaisia ohjelmia ennen kalliita ML-ohjelmia 2. **Yhteinen CLIP-järjestelmä** - Prosessi |8 |Images per GPU pass instead of one 3. **Pipeline-kokoonpano** - TaajuuskuvaSummarizer keskeisten osien osaltaM SK1 AudioSummarzer puheen osalta , NER yksiköiden osalta Tuloksena on, että : ja 2- tuntien elokuvaprosessit sujuvat ~10-15 minuuteissaM SK3 ei tuntiina. Samat rakenteelliset periaatteet kuin [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) ja [AudioSummarizer](/blog/audiosummarizer-forensic-audio-characterization), mutta yhdistetty yhtenäiseen videoanalyysiputkeen > **Keskeinen käsitys:** Video on shots + audio + textM SK2 Käsitellä kutakin aluetta erikoistuneilla työkaluilla, yhdistää tulokset johdonmukaisiin seikkoihin > > - **Prosessirakenne ensin** ( > - **Poista cross-modal-signaalit kerran** ( **Terminologia:** - **Shot** kameran ottaminen katkaisujen välillä (rakenteellinenM SK1 FFmpeg-esityksen havaitsemisesta - **Kuva** johdonmukaisen yksikön muodostava rinnakkainen ryhmittymien ryhmä (semanttinenM SK1 klusteroinnista - **Todisteet** `(start_time, end_time)` +-signaalit **Avainkäyttöiset ML-mallit:** - **[KLIP](https://openai.com/research/clip)** OpenAI's Contrastive LanguageMSC1Image Pre-trainingM SK3 tuottaa MST4dimensional embeddings that encode visual semantics - **[Silmä](https://openai.com/research/whisper)** OpenAI:n '-puheentunnistusmalli ; transcribes audio to text with timestamps - **[BERT-NER](https://huggingface.co/dslim/bert-base-NER)** Named Entity Recognition (nimitysyksikköjen tunnustaminen) - **[ONNX:n käyttöaika](https://onnxruntime.ai/)** Cross-platform ML inference Tämä artikla kattaa: - Miten VideoSummarizer hallinnoi kolmea putkea (ImageSummarzerM SK1 AudioSumMarizer , NER) - Aaltorakenne: M SK1 aaltot normalisaatiosta todisteiden luomiseen - **Toimivuusjärjestelmä**: Lazy model downloads , GPU detectionM SK2 reactive routing - Tappi CLIP-optimointi avainmuodon sisällyttämistä varten (3-5x nopeampiM SK1 - Percepuaalinen hashin vähentäminen (40% kehyksen vähentäminenM SK1 - Multi-signal scene clustering M SK1embedding + transcript | + | Cut type |+ | Temporal - NER:n integrointi entisistä jäljityksistä saataville - **Lyhyt atomit** tason rajoittamiseen,aikaarvioonM SK1 ja takapaineeseen - Päätöstulos: näytteetM SK1 kuvat, käännöksetMSC3 tekstijäljet RAG:n todisteina **Yhteenkuuluvat artiklat**: - **[Vähennetty RAG](https://www.mostlylucid.net/blog/reduced-rag)** - Ydinmuodon - **[Rajoitettu epäselvyysmalli](/blog/constrained-fuzziness-pattern)** - Perusmalli - **RAG:n vähennetyt täytäntöönpanot** - [DocSummarizer](/blog/building-a-document-summarizer-with-rag) - Dokumentti RAG entiteetin poistamiseksi - [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) - Kuva RAG-järjestelmä, jossa on 22-valonäkötieto - [AudioSummarizer](/blog/audiosummarizer-forensic-audio-characterization) - Audion oikeudellinen tunnustus - **VideoSummarizer (artikkeliM SK1** - Videotietojärjestäjä [TOC] --- ## Ongelma: Video on kallis > **Määrämerkit**: jäljempänä mitattuja lukuja AMD:ssa 9950X SSK2coreM SK3 CSK4 NVIDIA A4000 \(16GBMSC7 | | / ♫ 96GB RAM | Tavallinen elokuva sisältää: - **~170,000 puitteet** (2 tuntia 24fpsM SK2 - **~2 audiotunnit** ( - **Useat tekstilajit** ( Kummeliturska-lähestymistapa ( kukaan ei tee tätä , mutta se asettaa mittakaavanM SK2 - CLIP:n sisällyttäminen jokaiseen kehykseen: M SK1ms × ♫ **9.4 tuntia** - Vision LLM kutakin mallia kohti: M SK1s × | 170,000 | | **94 tuntia** (cloud Vision API ballpark Jopa avainpuitteet ottamalla pois (toteaaM SK1 500-1000puitteita),, että' on edelleen 100-200 sekuntia serieistä CLIP-päätelmää **Perinteinen lähestymistapa**: **Ongelma**: Tämä polttaa tietojenkäsittelyä ylimääräisissä muodoissaan. **Ratkaisu**: MonitasoinenM SK1vaiheellinen filtrointi ,kuormituskäsittely, , ja putkien koostumus,. --- ## VideoSummarizer-arkkitehtuuri VideoSummarizer -välineet **[Vähennetty RAG](/blog/reduced-rag)** kolmevaiheisen videon vähentämiseen ```mermaid flowchart TB subgraph Input["Video File (.mp4, .mkv, etc.)"] V[Video Stream] A[Audio Stream] end subgraph Stage1["Stage 1: Structural Analysis"] N[NormalizeWave
FFprobe metadata] SD[ShotDetectionWave
Scene cuts via FFmpeg] KE[KeyframeExtractionWave
I-frame + dedup] end subgraph Stage2["Stage 2: Content Extraction"] IS[ImageSummarizer
CLIP, OCR, Vision] AS[AudioSummarizer
Whisper, Diarization] NER[NER Service
Entity extraction] end subgraph Stage3["Stage 3: Scene Assembly"] SC[SceneClusteringWave
CLIP similarity] EV[EvidenceGenerationWave
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 ``` ### Tuotettuja todisteita Ennen kuin paneudumme täytäntöönpanoon, otetaan huomioon seuraavat seikat: | Artefaktti | Tärkeimmät kentät |----------|------------|--------| | **Kuva** | `id`, `start_time`, `end_time`, `key_terms[]`, `speaker_ids[]`, `embedding[512]` | SceneClusteringWave | **Shot** | `id`, `start_time`, `end_time`, `cut_type`, `keyframe_path` ShotDetectionWave | | **Sanonta** | `id`, `text`, `start_time`, `end_time`, `speaker_id`, `confidence` | TransscriptionWave | | **Tekstirack** | `id`, `text`, `start_time`, `text_type` (otsakeM SK1luotto/lisäotsake/ocr) |LisäotsekeExtractionWave SSK6 | **Avauspuitteet** | `id`, `timestamp`, `frame_path`, `dhash`, `clip_embedding[512]` | KeyframeExtractionWave Jokainen artifactti sisältää **alkuperä**:lähteenlaajuus,,käsittelyaikataulu,MSC2luottamuksen tulos,M SK3 Tämä on "todisteiden luettelo,", jonka kautta RAG-kyselyt toimivat ### Signal-Aware Wave Pipeline VideoSummarizer käyttää **signaali-pohjainen aaltoarkkitehtuuri** kun kukin aalto ilmoittaa selvästi signaalinsa sopimukset: ```csharp public interface ISignalAwareVideoWave { /// Signals this wave requires before it can run. IReadOnlyList RequiredSignals { get; } /// Signals this wave can optionally use if available. IReadOnlyList OptionalSignals { get; } /// Signals this wave emits on successful completion. IReadOnlyList EmittedSignals { get; } /// Cache keys this wave produces for downstream waves. IReadOnlyList CacheEmits { get; } /// Cache keys this wave consumes from upstream waves. IReadOnlyList CacheUses { get; } } ``` Tämä mahdollistaa **dynaamisen aaltotason koordinointi**: - Vaivat lentävät automaattisesti, jos vaaditut signaalit puuttuvat - Riippuvuus ratkaistaan runtimessa (ei hardcoded orderM SK1 - Osittainen uudelleenlaskeminen on toistettava ( talletuspisto signaalimuodon avullaM SK1 - UI:n edistyminen granulaarisuus: kukin aalto antaa edistyksen itsenäisesti ### 16-Wave Pipeline Keyframe-extracointi toteutetaan 7 granulaaristen aaltojen muodossa paremman rinnakkaiselon ja cache-tehokkuuden aikaansaamiseksi : | Aalto | ensisijainen SSK2 Vaatimukset | Saavutukset S| Aika M| |------|----------|----------|-------|------| | **Normalisoida aalto** | 1000 | - | `video.duration`, `video.fps`, `video.normalized` | | **FFmpegShotDetectionWave** | 900 | `video.normalized` | `shots.detected`, `shots.count` | | **IFrameDetectionWave** | 850 | `video.normalized` | `keyframes.iframes_detected`, `keyframes.iframes_count` | | **Avainmuurin valinnainen aalto** | 840 | `shots.detected`, `keyframes.iframes_detected` | `keyframes.selected`, `keyframes.selected_count` | | **Kolmikuonnostusaalko** | 830 | `keyframes.selected` | `keyframes.thumbnails_extracted` | | **KeyframeDeduplicationWave** | 820 | `keyframes.thumbnails_extracted` | `keyframes.deduplicated`, `keyframes.duplicates_skipped` | | **KeyframeFullResExtractionWave** | 810 | `keyframes.deduplicated` | `keyframes.extracted`, `keyframes.count` | | **ClipEmbeddingWave** | 800 | `keyframes.extracted` | `clip.embeddings_ready`, `clip.embeddings_count` | | **ImageAnalysisWave** | 790 | `keyframes.deduplicated` | `keyframes.analyzed`, `ocr.extracted` | | **TitleCreditsDetectionWave** | 750 | `shots.detected` | `title.detected`, `credits.detected` | | **AudioExtractionWave** | 650 | `video.normalized` | `audio.extracted`, `audio.path` | | **TranscriptionWave** | 600 | `audio.extracted` | `transcription.complete`, `transcription.utterance_count` | | **AlaotsakeExtractionWave** | 550 | `video.normalized` | `subtitles.extracted` | | **PääluokkaExtractionWave** | 500 | `video.normalized` | `chapters.extracted` | | **SceneClusteringWave** | 400 | `shots.detected` | `scenes.detected`, `scene.count` | | **EvidenceGenerationWave** | 100 | `scenes.detected` | `evidence.generated` | **Huomautukset:** - ImageAnalysisWave -käyttö `keyframes.deduplicated` (ei täytäntöä - Vaivat 3-7 ovat "keyframe extraction" subM SK3pipeline (7 granulaariset aaltot cache-tehokkuuden varmistamiseksi **Kokonainen 2-tuntisen elokuvan**: ### Well-Known Signal Keys Signalit määritellään johdonmukaisuuden konstanteiksi: ```csharp 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"; } ``` --- ## Capability System: Lazy Models M SK1 Routing VideoSummarizer käyttää **mahdollisuus-pohjainen rakenne**: havaitsee GPU:n kerran aloitusvaiheessa , lataa mallit hitaasti M SK2 etenee käytettävissä oleviin osteisiin . ### Malli Manifestti (YAML + Typo-Safe ConstantsM SK3 Mallit määritellään `models.yaml`ei magisia stringeja kodessa: ```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] ``` ```csharp // 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) }); ``` ### Pipeline Efficiency Atoms Nopeuden rajoittaminen, ajanarviointiM SK1 ja mukautuva takapaine pitävät UI:tä responsivenä maksimoimalla läpikulun ```csharp // 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 ``` > **Täydelliset valmiusjärjestelmät**: Katso `Mostlylucid.Summarizer.Core/Capabilities/` GPU:n havaitsemista varten, signaali pub/subM SK2 takapaine-johtoimet , ja verkkotopologian suunnittelu --- ## Tärkein optimointi 1: Perceptual Hash Deduplication Ennen kalliiden CLIP-embeddingien käyttöönottoa, VideoSummarizer siirtää ulkopuolelle näennäisesti samankaltaisia ryhmiä käyttämällä **ero hash (dHashM SK1**. ### Miten dHash toimii ```csharp 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 ComputeDHashAsync(string imagePath, CancellationToken ct) { using var image = Image.Load(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); } ``` **Esimerkkitulos:** ``` 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 ``` **Miksi tämä on tärkeää:** - **~40% kehyksen vähentäminen** tyypillisestä sisällöstä - **<1ms fps** hash-laskennukseen (vs. 200ms CLIPin osalta - Filtroi ylimääräisiä kehyksiä **ennen** kalliit GPU-operaatiot --- ## Tärkein optimointi 2: Laaja CLIP-järjestelmä Sen sijaan, että prosessoidaan yksi kuva kerrallaan, VideoSummarizerin sarjat M SK1 kuvia GPU:n kautta ### Tappikäsittelyarkkitehtuuri ```csharp public class BatchClipEmbeddingService { private const int ClipImageSize = 224; private const int DefaultBatchSize = 8; // 8 images per GPU pass public async Task> GenerateBatchEmbeddingsAsync( Dictionary framePaths, int batchSize = DefaultBatchSize, CancellationToken ct = default) { var session = await GetOrLoadClipModelAsync(ct); var results = new Dictionary(); // 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(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.CreateFromTensor("input", tensor) }; using var outputResults = session.Run(inputs); // Extract embeddings from batch output... } return results; } } ``` **suorituskyvyn vertailu:** ``` 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 ``` **Miksi ryhmäkäsittely toimii:** - GPU:n rinnakkaiskäyttöä käytetään liian vähän yhtenäisen -imagein johtopäätöksellä - Tappitensorit `[8, 3, 224, 224]` käyttää samaa GPU-kumppanuutta kuin yksi ainoa kuva (vähintäänM SK1 - ONNX Runtime optimoi sisäisiä jakelutoimia --- ## Tärkein optimointi 3: Pipeline Composition VideoSummarizer ei ' keksi ImageSummarizeria tai AudioSommarizerit uudelleen **ketjut** ne. ### Keyframe Sub-Pipeline: ImageSummarizer Integration Avainpuitteet jaetaan seuraavasti: 7 granulaariset aaltot (katso aaltotaulukkoa jäljempänäM SK2Tämän kohdan koordinointimalli osoittaa, miten ne sidotaan yhteen ```csharp // IFrameDetectionWave → KeyframeSelectionWave → ThumbnailExtractionWave // → KeyframeDeduplicationWave → KeyframeFullResExtractionWave → ClipEmbeddingWave // ClipEmbeddingWave coordinates with ImageSummarizer public class ClipEmbeddingWave : IVideoWave, ISignalAwareVideoWave { public IReadOnlyList RequiredSignals => [VideoSignals.KeyframesExtracted]; public IReadOnlyList EmittedSignals => [VideoSignals.ClipEmbeddingsReady]; public async Task ProcessAsync(VideoContext context, CancellationToken ct) { var keyframes = context.GetCached>("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 RequiredSignals => [VideoSignals.KeyframesDeduplicated]; public async Task ProcessAsync(VideoContext context, CancellationToken ct) { var keyframePaths = context.GetCached>("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: AudioSummarizerin integrointi Audio-extraktointi ja transcription ovat nyt erillisiä signaaleja-aware wavesM SK1 ```csharp // AudioExtractionWave runs first (extracts audio track from video) public class AudioExtractionWave : IVideoWave, ISignalAwareVideoWave { public IReadOnlyList RequiredSignals => [VideoSignals.VideoNormalized]; public IReadOnlyList 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 RequiredSignals => ["audio.extracted"]; public IReadOnlyList EmittedSignals => [ VideoSignals.TranscriptionComplete, "transcription.utterance_count" ]; public async Task ProcessAsync(VideoContext context, CancellationToken ct) { var audioPath = context.GetCached("audio.path"); // Run AudioSummarizer pipeline (Whisper + diarization) var audioProfile = await _audioOrchestrator.AnalyzeAsync(audioPath, ct); // Extract utterances with speaker info var turns = audioProfile.GetValue>("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("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-integraatio: Named Entity Recognition VideoSummarizer vie nimetyt entiteet transcripteista käyttäen BERT-pohjaista NER-järjestelmää M SK1ONNX). ### OnnxNerService ```csharp public class OnnxNerService { // Model: dslim/bert-base-NER (ONNX exported) // Entities: PER (Person), ORG (Organization), LOC (Location), MISC (Miscellaneous) public async Task> ExtractEntitiesAsync(string text, CancellationToken ct) { var entities = new List(); // 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(); } } ``` **Esimerkkitulos:** ``` 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"] ``` **Miksi NER on tärkeää videolle:** - Sellaiset kysymykset kuin "Hätä videot, joissa mainitaan Microsoft - Linkki DocSummarizerin entiteettitaulukkoon - Tarjoa strukturoituja metatietoja ilman LLM:n johtopäätöksiä --- ## Multi-Signal Scene Clusteri Pelkästään CLIP-embeddingin käyttäminen näyttämön havaitsemiseen ei toimi kovin hyvinkeyframet ovat suppeita suunnitteluun nähden. (, yksi shot change, ),, mutta shots are dense. VideoSummarizer käyttää **multi-signaali lähestymistapa** , jossa yhdistetään 4 painotettuja signaaleja vahvan näyttämörajan havaitsemiseen ### SceneClusteringWave: Multi-Signal Architecture ```csharp 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 RequiredSignals => [VideoSignals.ShotsDetected]; public IReadOnlyList OptionalSignals => [ VideoSignals.ClipEmbeddingsReady, VideoSignals.TranscriptionComplete, VideoSignals.KeyframesDeduplicated ]; public IReadOnlyList 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; } } ``` ### Tärkeimmät innovaatiot 1. **lähimmäisläheisyys-Naapurin sisällyttämisen edistäminen**: Vain ~2% ammuksilla on suorat CLIP-säännöksetM SK2 Uudessa lähestymistavassa siirretään sisällytyksiä läheisyydessä oleviin ammuksiin 30 sekuntien kuluessa väliaikaisen läheisyyspainotuksen avulla 2. **Luettelo semanttisista ohjelmista**: Rakennetaan 10-second word windows ympäri kutakin shotia ja havaitaan semanttiset siirtymät Jaccardin välitykselläa halvan semanttisen drift-proxiivin avulla. 3. **Cut-tyypin tietoisuus**: FadeM SK1to -black and dissolve transitions strongly indicate scene boundaries 4. **Adaptiivinen raja-arvo**: kiinteän kynnysarvon sijasta , valitsee rajat yhdeltä ylhäältä 5. **Väliaikaiset rajoitukset**: Säännöttelee vähimmäis- ja raja-arvoja 15 hetken enimmäismääriin **Esimerkki:** ``` 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" ``` --- ## Videosignaalisopimus VideoSummarizer laajentaa ImageSommarizerin ja AudioSumMarizerin signaalisopimusta: ```csharp 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? Metadata { get; init; } public List? 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"; } ``` **Esitetyt keskeiset signaalit:** | signaali | lähde SSK2 kuvaus | |--------|--------|-------------| | `video.duration` | NormalizeWave | `video.resolution` | Normalisoida-aalto | Laajuus | `video.fps` | NormalizeWave | `shots.count` | ShotDetectionWave | `keyframes.count` | KeyframeExtractionWave | `keyframes.duplicates_skipped` | KeyframeExtractionWave | `scene.count` | SceneClusteringWave | `transcript.entities.per` | TranscriptionWave | NER:stä peräisin olevat henkilöt | `transcript.entities.org` | TranscriptionWave | Viraston nimet | | `transcript.word_count` | TranscriptionWave | Tekstissä olevat sanat yhteensä | --- ## VideoPipeline: RAG-putti Euroopan unionin `VideoPipeline` muuntaa videosignaalit `ContentChunk` RAG-indeksointia varten: ```csharp public class VideoPipeline : PipelineBase { public override string PipelineId => "video"; public override IReadOnlySet SupportedExtensions => new HashSet { ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".webm", ".flv", ".m4v", ".mpeg", ".mpg" }; private List BuildContentChunks(VideoContext context, string filePath) { var chunks = new List(); // 1. Scene-based chunks (best for video retrieval) foreach (var scene in context.Scenes) { var sceneText = BuildSceneText(context, scene); var embedding = context.GetCached($"scene_centroid.{scene.Id}"); chunks.Add(new ContentChunk { Text = sceneText, ContentType = ContentType.Summary, Embedding = embedding, // Proper vector column, not metadata Metadata = new Dictionary { ["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 { ["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(); 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); } } ``` **Esimerkkitulos elokuvalle:** ```json { "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" } } ] } ``` --- ## suorituskyvyn erityispiirteet ### Jalostusaika (2-tuntinen elokuva, 1080pM SK3 | Edistymisvaihe | Aika | Asiakirjat M| |-------|------|-------| | FFprobe-metadatat | Ampuma-iskujen havaitseminen | avainpuitteet otetaan pois | ~30s SSK3 \500 IM SK5puitteet | | dHash-yhdenmukaistaminen | Laivasto CLIP sisällyttäminen | CSK2s | \300 puitteetM SK5 laivasto SSK6 || | ImageSummarizer OCR | Äänestyslähetys | Sanonnollinen käännös | | Puhemiehen vääristymisaste | NER:n ekstraktointi | ~10s M| BERTM SK4NER:stä jäljitettävässä tekstissä | | Kuvausryhmittymien luominen | Todisteiden tuottaminen | CSK2s SSK3 | **Kokonaisuus** | **~8-10 minuuttia** | | ### Ilman parannuksia | Optimointi | Säästöt | |--------------|---------| | dHash-yhdenmukaistaminen | ~40% järjestelmät, jotka on siirretty filtrointiin | Tavaroiden lippu | 3-5x nopeutettua | putken koostumus | **Koko säästöt** | **~3-4 minuuttia** | ### Tietojen käyttö | Komponenti | muisti | |-----------|--------| | CLIP ViTM SK1B/32 ONNX | ~350MB SSK5 | Sanontapohja | ~500MB S| | ECAPA | BERTM SK1NER | **Huippu** | **~1.5GB** | --- ## Integraatio lucidRAGin kanssa VideoSummarizer rekisteröi `IPipeline` automaattiselle etenemiselle: ```csharp // 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(); var pipeline = registry.FindForFile("movie.mp4"); // Returns VideoPipeline var result = await pipeline.ProcessAsync("movie.mp4"); ``` **Tuetut laajennukset:** - `.mp4`, `.mkv`, `.avi`, `.mov`, `.wmv`, `.webm`, `.flv`, `.m4v`, `.mpeg`, `.mpg` --- ## Se, mitä saat - **Scene-tasoisen RAG-kierroksen**: Johdonmukaiset jaksot ja käännökset - **Monimuotoiset todisteet**: Visuaalinen ( avainpuitteet, oikaisut, ), äänioikeudet, M SK3 puhujaarisointi, ), teksti, MST5 OCR, MSV6 alaotsaukset, MSS7 - **Nimetyt yksiköt**: KansalaisetM SK1 organisaatiot , sijaintipaikat NER:n käännöksestä - **Tarkasteltavana oleva alkuperä**: Kaikilla signaaleilla on alkulähteenlaajuus - **Tehokas käsittely**: ## Mihin se maksaa - **~1.5GB GPU:n muisti** kaikille ONNX-malleille - **~8-10 minuutin käsittely** kohti 2-tuntista elokuvaa - **Diskin avaruus** väliaikaisten tietojen osalta (valvotaan automaattisesti - **Monimutkaisuus**: Kolmen putken järjestäminen edellyttää, että ymmärretään aaltoriippuvuus --- ## Päätelmät VideoSummarizer osoittaa, että **kaasuputken koostumus** mittakaavat: 1. **Spetsialisoitujen putkien uudelleenkäyttö**: DonM SK1 ei keksi ImageSummarizeriä tai AudioSummarzeria uudelleen 2. **Filtroiminen ennen kalliita operaatioita**: dHash-yhdenmukaistamiseen liittyvät kustannuskustannukset 3. **Batch GPU-operaatiot**: 4. **Poistaa rakennetta ennen sisältöä**: Otsot → Kuvat → Todisteet \(ei raaka-rahoja \→ LLM \ ) 5. **Lazy-mallinhallinta**: Laaditaan mallit vain tarpeen vaatiessa , havaitsee GPU:n automaattisesti 6. **Reaktiivinen eteneminen**: Route work to available componentsM SK1 fallback gracefully Tuloksena on, että : tunnin elokuvasta tulee rakenteellinen signaalisalkku, johon sisältyy näytteitä, transkryptioita, entiteettejä, , ja varauksia RAG-kyselyihin, kuten :. - "Katso, missä John Smith keskustelee Microsoftista - "Show clips with on-screen text about Phoenix project - "Hätä tähän sceneen samankaltaisia videoitaM SK1 (CLIPin sisällyttäminen hakuun) **Reduced RAG -malli videolle:** ``` 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) ``` **Toimivuusjärjestelmä:** ``` 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 ``` Tämä on **Rajoitettu epämääräisyys** mittakaavassa: - **Probabilistiset osatekijät ehdottavat signaaleja**: sisällytykset (CLIPM SK2 OCR-hypoteetit - **Deterministinen tulosjärjestelmä yhdistää rakenteen**: painotetut raja-arvot , kynnysarvon valintaM SK2 asteelliset rajoitukset - **LLM (vaihtoehtoinenM SK1 synteesii todisteiden perusteella**: rajallinen konteksti , tarkastettava alkuperä LLM toimii ennakolta-komputoituja todisteita eikä raaka-videoita. --- ## Resurssit ### lucidRAG-asiakirja - **[VideoSummarizerin kirjasto](https://github.com/scottgal/lucidrag/tree/main/src/VideoSummarizer.Core)** - Lähdekoodi - **[NER-asiakirja](https://github.com/scottgal/lucidrag/blob/main/docs/NER_EXTRACTION_DEDUPLICATION.md)** -yksiköiden ekstrahointiarkkitehtuuri ### Yhtenevät kirjastot - **[ImageSummarizer](https://github.com/scottgal/lucidrag/tree/main/src/ImageSummarizer.Core)** - Visuaalinen tiedusteluputki - **[AudioSummarizer](https://github.com/scottgal/lucidrag/tree/main/src/AudioSummarizer.Core)** - Audion oikeudellinen putki - **[DocSummarizer](https://github.com/scottgal/lucidrag/tree/main/src/Mostlylucid.DocSummarizer.Core)** - Dokumenttiputki ### ONNX-mallit - **[lippu ViT-BM SK1](https://huggingface.co/openai/clip-vit-base-patch32)** - Visuaaliset sisällytykset - **[ECAPA-TDNN](https://huggingface.co/Wespeaker/wespeaker-ecapa-tdnn512-LM)** - Puhemiehen sisällytykset - **[BERT-NER](https://huggingface.co/dslim/bert-base-NER)** - Named entity recognition - **[Silmä](https://github.com/openai/whisper)** - Puheäänestys ### Related Articles **Keskeiset mallit:** - **[Vähennetty RAG](https://www.mostlylucid.net/blog/reduced-rag)** - Ydinmuodon - **[Rajoitettu epäselvyysmalli](/blog/constrained-fuzziness-pattern)** - Perusmalli **RAG:n vähennetyt täytäntöönpanot** - **[DocSummarizer](/blog/building-a-document-summarizer-with-rag)** - Dokumentti RAG entiteetin poistamiseksi - **[ImageSummarizer](/blog/constrained-fuzzy-image-intelligence)** - Kuva RAG-järjestelmä, jossa on 22-valonäkötieto - **[Kolmas -Tier OCR-putki](/blog/constrained-fuzzy-image-ocr-pipeline)** - OCR:n nousu - **[AudioSummarizer](/blog/audiosummarizer-forensic-audio-characterization)** - Audion oikeudellinen tunnustus - **VideoSummarizer (artikkeliM SK1** - Videotietojärjestäjä - **[DataSummarizer](/blog/datasummarizer-how-it-works)** - Tietoprofiilien luominen ja skeemiin perustuva johtopäätös --- ## Luettelo | Osuus | Muodot | Keskittyminen SSK3 |------|---------|-------| | 1 | [Rajoitettu epämääräisyys](/blog/constrained-fuzziness-pattern) | Yksittäinen osake | | 2 | [Rajoitettu hämärä MoM](/blog/constrained-mom-mixture-of-models) | Useat osat | | 3 | [Kontextin nostaminen](/blog/constrained-fuzzy-context-dragging) | Aika / muisti | | 4 | [Kuvatieto](/blog/constrained-fuzzy-image-intelligence) | AaltoarkkitehtuuriM SK1 22 aallot | | 4.1 | [Kolmas -Tier OCR-putki](/blog/constrained-fuzzy-image-ocr-pipeline) | OCR, ONNX-mallit, filmtrips | | 4.2 | [AudioSummarizer](/blog/audiosummarizer-forensic-audio-characterization) | Oikeudellinen audioM SK1 puhujan vääristyminen | | **4.3** | **VideoSummarizer (artikkeliM SK1** | **Videoorkesteri, paketti CLIPM SK1 NER** | **Seuraava**: monimuotoinen graphi, -modal RAG ja lucidRAG, jossa kaikki neljä yhteenvetotekijää yhdistetään yhtenäiseen tietämyksen grafiin, johon liitetään cross- Kaikki osat seuraavat samaa invarianttia: **todennäköiset osatekijät ehdottavat; määritelmäjärjestelmät pysyvät**.