# AudioSummarizer-:-Beschränkte Fuzzy Forensische Audio Charakterisierung > **Status**AudioSummarizer, .,Core ist derzeit in der Entwicklung als Teil von **[LucidRAG](https://www.lucidrag.com)**Die Implementierung ist abgeschlossen und funktioniert. Dieser Artikel dokumentiert die Architektur und das Design. Die CLI-Integration wird in einem kommenden lucidRAG Release verfügbar sein. > > **Quelle**: [github-.-com./-scottgal./-lucidrag](https://github.com/scottgal/lucidrag) ,(-Zweig , :- `v2`) **Wo das passt**AudioSummarizer ist Teil der **[LucidRAG](https://www.lucidrag.com)** Familie der Reduzierten RAG-Implementierungen-.- jede behandelt eine andere Modalität-:- - **[DocSummarizer](/blog/building-a-document-summarizer-with-rag)** Dokumente - Extraktion der ( - Wissensgraphen - ) - - **[ImageSummarizer](/blog/constrained-fuzzy-image-intelligence)** Bildmaterial zur visuellen Intelligenz der (22- - **[DatenZusammenfassung](/blog/datasummarizer-how-it-works)** Daten zur Schlussfolgerung des (-Schemas - **AudioSummarizer** Dieser Artikel ist erhältlich bei: http:www.cordis.lu/ Alle folgen dem gleichen **[Reduziertes RAG-Muster](/blog/reduced-rag)**:-Extraktsignale einmalig ,-Speichernachweis ,-Synthetisieren mit gebundenem LLM-Eingang .- --- Viele der ersten Audio-Analyse Pipelines machen den gleichen Fehler... sie behandeln LLMs, als wären sie akustische Ingenieure... Sie speisten Wellenformen in Modelle ein und fragen sie, ob das Modell strukturelle Eigenschaften aus dem ableiten kann, was im Grunde ein Muster ist.-Matching System. Es funktioniert einfach gut genug, um — zu demoieren und dann halluziniert Lautsprechernamen... **AudioSummarizer kombiniert zwei komplementäre Muster** 1. **[Reduzierte RAG](https://www.mostlylucid.net/blog/reduced-rag)** für Retrieval-Signale extrahieren, sobald , store evidence®, question gegen Fakten 2. **[Beschränkte Fuzziness](/blog/constrained-fuzziness-pattern)** für die Orchestrierung --Welle--basierte Pipeline – deterministisches Substrat begrenzt probabilistische Modelle Statt rohes Audio an einen LLM zur Abfragezeit zu füttern, es **reduziert** jede Audiodatei zu einer **Signalbuchstabe** Bestimmende Signale wie z.B. RMS-Lautstärke, spektrale Eigenschaften, ,, Lautsprechereinbettungen, ), mit **extrahierte Beweise** (-Transkripte,-Lautsprecherbeispielclips,-Diarisierungsdrehungen).-Dieses Buch wird einmalig für das Retrieval indexiert. fortgesetzt Bei **Abfragezeit**Eine LLM synthetisiert Antworten durch Abrufen und Überlegung über die wichtigsten Signale.—nicht durch Re--Analysieren von Audio, .Das schwere Heben der Signalverarbeitung, MSC5, Transkription, MCSK6, Diarisierung, ), geschieht während der Aufnahme, MKS8, Die LLM läuft nur zur Abfragezeit, um pre-MSC9 zu interpretieren und humane, -, lesbare Antworten zu generieren.MSC11 > **Musterzusammensetzung**Reduzierte RAG-Griffe *Was ist* um zu speichern und wiederzubekommen ,.-Beschränkte Fuzziness Griffe *Wie* um Signale zuverlässig zu extrahieren – .-Zusammen ermöglichen sie eine forensische Audiocharakterisierung mit begrenzter LLM cost- - .- > **Erfahren Sie mehr über das reduzierte RAG-Muster**: [Reduziertes RAG-:-Signal-gestütztes Verständnis von Dokumenten](https://www.mostlylucid.net/blog/reduced-rag) ### Schlüsselterminologie - **Signale**Getippte Fakten mit Konfidenzwert `audio.content_type = "speech"`Konfidenzielles Vertrauen - **Nachweise**Prüfbare Artefakte (, Transkripte ,, Lautsprecherbeispiel-Clips ,, Diarisierungsdrehungen), - **Signalleiter**Das persistente Bündel aller Signale, die aus einer Audiodatei extrahiert werden - **SprecherId**Lokaler Identifikator innerhalb einer einzigen Datei, die mit der /-Diarisierung durchgeführt wird `SPEAKER_00`) - **VoiceprintId**:-Cross---Datei stabile Hash aus der Stimme Einbettung abgeleitet `vprint:a3f9c2e1`) - **Person**Wir behaupten nie, dass das John Smith ist. **Identitätsmodell**: `SPEAKER_00` ist lokal zu einer Audiodatei. `VoiceprintId` ist stabil über Dateien, aber anonym. Wir kartieren niemals menschliche Namen. **forensische Anforderungen**Jedes Signal enthält **Herkunft** Die Welle produzierte sie. **Vertrauen** (, Grad der Sicherheit, ), und **Versionierung** Dies ermöglicht die Reproduzierbarkeit des gleichen Eingangs.Gleiche Konfiguration.Gleiches Signalbuch. Das Ergebnis ist: * Schnelle datenschutzrechtliche Charakterisierung von forensischem Audio * Lautsprecherdiarisierung ohne Python-Abhängigkeiten * Anonyme Speaker-Ähnlichkeitserkennung * Spracheinbettungen für ähnliche Lautsprecher finden * Alle ohne Audio an Cloud-APIs während der Aufnahme zu senden Dies baut direkt auf der **[Eingeschränktes Fuzziness-Muster](/blog/constrained-fuzziness-pattern)** und die wellenbasierte Architektur aus **[ImageSummarizer](/blog/constrained-fuzzy-image-intelligence)**. > **Kerninsight«:-** LLMs sollten über akustische Fakten nachdenken... Dieser Artikel umfasst: - Wie AudioSummarizer das reduzierte RAG-Muster implementiert - Signalextraktion:-deterministische akustische Fakten - nicht LLM Zusammenfassungen - Evidenzspeicher-Lautsprecherproben-," Transkripte, Diarisierungsdrehungen" - Reine Lautsprecher-Diarisierung von .-NET ohne Python, ohne Pyannote - Abfrage---Zeit-Synthese-MSC1-Filtersignale Evidenz abfragen →-LLM synthetisiert **Verwandte Artikel**: - **[Reduzierte RAG](https://www.mostlylucid.net/blog/reduced-rag)** Das Kernmuster, das dieses implementiert - [Eingeschränktes Fuzziness-Muster](/blog/constrained-fuzziness-pattern) Das Grundmuster - **Reduzierte RAG-Implementierungen** - [DocSummarizer](/blog/building-a-document-summarizer-with-rag) Dokument RAG mit Entity-Extraktion und Wissensgraphen - [DatenZusammenfassung](/blog/datasummarizer-how-it-works) Datenprofilierung und Schemainferenz RAG - [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) Bild RAG mit visueller Intelligenz Pipeline - **AudioSummarizer Dieser Artikel** Audio forensische Charakterisierung mit Lautsprecher-Diarisation [TOC] --- ## Das Problem: Die Audioanalyse ist hart und kulturell geladen Audio-Analyse fehlschlägt in vorhersehbaren Weisen - **Kulturelle Behauptungen**Dies ist jazz, ", (, sagt wer, MSC4, basierend auf welchen Trainingsdaten, ?), - **Name des Sprechers**Der Sprecher ist John Smith, ", Datenschutzverletzung, Halluzination, MSC5 - **Musikkennung**"Song: Sandsturm von Darude:Songstorm von Darude"Songsong: Fragen des Urheberrechts - **Zukünftiges Raten**Der Sprecher hat britischen Akzent, ", oft falsch, möglicherweise anstößig - **Pythonabhängigkeiten**Die meisten Diarization-Tools erfordern Pyannote (Python-Ökosystemschloss -in-) Traditioneller Ansatz: :"Run Whisper für Transkriptionen ,Pyannote für Diarisierungen , senden Sie an LLM zur Zusammenfassung **Problemstellung**Dieses entweder undicht PII (.Lautsprecher-Namen.),. kostet zu viel ,(.cloud APIs oder erfordert Python Laufzeit , (.pyannote , ,. DIART-).. **Lösung**Erstellen Sie eine reine, auf - basierende Pipeline, die Audio strukturell und akustisch charakterisiert, ohne kulturelle Behauptungen zu machen. --- ## Das reduzierte RAG Audio Framework AudioSummarizer implementiert die [Reduziertes RAG-Muster](https://www.mostlylucid.net/blog/reduced-rag) für Audiodateien, die ihren drei Grundprinzipien folgen, ### Signalextraktion - Phase der Aufnahme **Deterministische Signale, die einmal extrahiert werden** - **Zeitlich**Dauer,, Zeitstempel, Segmentgrenzen - **Akustisch**RMS-Lautheit – Spektralzentroid – Dynamischer Bereich – Clipping-Verhältnis von , - **Identität**SHA--256-Hash,-Dateiformat ,-Probenrate Kanäle - **Qualität**Das Vertrauen in die Transkriptions-Diarisierung - **Sprecher**Anzahl der Sprachabdruck-IDs - **kategorisch**Inhalt Typ: (Speech/Music/Silenz),Speaker-Klassifizierung (Single/Two/Multi) **Beispiel Signalsatz für einen Podcast** ```json { "audio.hash.sha256": "3f2a9c8b1e4d...", "audio.duration_seconds": 912.0, "audio.rms_db": -18.2, "audio.spectral_centroid_hz": 2418.3, "audio.content_type": "speech", "speaker.count": 2, "speaker.classification": "two_speakers", "transcription.confidence": 0.87, "voice.voiceprint_id.speaker_00": "vprint:a3f9c2e1d4b8" } ``` Diese Signale sind **Deterministisch** Gleiche Audio-Werte **indexierbar** (-Can-Filter/-sort in der Datenbank),- und **ohne LLM berechenbar** ,(-reine Signalverarbeitung , +-ONNX Modelle , ).- ### Evidenz-Speicherung - Strukturierte Einheiten - ) Statt nur zu speichern "-Cunks-,"-AudioSummarizer Stores-:- - **Signale**Strukturierte Felder für deterministische Filterung - **Einbettungen**Sprach-Embeddings für Lautsprechersimilarität - **Datenschutzhinweis**Einbettungen sind in diesem System nicht realisierbar, sondern behandeln sie als sensible Daten - **Nachweise**: - Vollständiger Transkripttext - Lautsprecherbeispiel-Clips für die Verifikation - Diarisierungsdrehungen (-JSON mit Lautsprecher _-id,-Start/-Endzeitstempeln)- - **Zeiger**Evidenz-IDs für prüfbare Provenienz **Nachweise sind prüfbar**Benutzer können Lautsprecher-Samples abspielen, die Transkripte lesen, die Diarization Turns inspizieren, und nicht nur einer LLM Zusammenfassung vertrauen. ### Frage nach der Zeit-Synthese des LLM-Eingangs des ) Zur Abfragezeit: ,, die LLM **niemals** sieht rohes Audio ,. , stattdessen ,: , 1. **Deterministisch filtern** Datenbasis, in der die Klausel): ```sql WHERE audio.content_type = 'speech' AND speaker.count >= 2 AND audio.rms_db > -25.0 AND transcription.confidence > 0.8 ``` 2. **Hybride Suche** (B25C+C-Vektor,CMSC4C Ergebnisse):C - BM.25 , auf Transkript Text , MS.S.K1 , Schlüsselwort passend - Vektor-Ähnlichkeit auf Spracheinbettungen - Zurück nach oben Audiodateien 3. **Synthesize aus Signalen** (-LLM sieht strukturierte Evidenzpakete ``` Audio 1: podcast_ep42.mp3 - Duration: 15m 12s - Speakers: 2 (SPEAKER_00: 52%, SPEAKER_01: 48%) - Quality: RMS -18.2dB, no clipping - Transcript: "Welcome to Tech Insights. Today we're discussing..." - Entities: ["quantum computing", "Google", "IBM"] ``` Die LLM erhält **Strukturierte Evidenzpakete** statt **Krümel von rohen Audio-Metadaten**Kontext-Fensterverkleinerung (MSK) **Kosteneffekt** (, wenn Sie bezahlte LLM-APIs verwenden ):, um Audiodateien zu verarbeiten 100, geht von ~$5, um -, um jede Abfrage zu analysieren ) und ~$0.10, um vor -, berechnete Signale *Anmerkung: : lucidRAG ist lokal , MS K1 first , ( , Ollama per Default ,, , Nullkosten , ). , bezahlte APIs ,( Claude , GPT-, , sind optional ,. , Kostenschätzungen gehen von bezahlter API-Nutzung aus.: , messK11 , Zeichen des Anbieters, ), , MessK13 , Marken des Herstellers , und / , Quelle der Daten aus.* Dies ist der Kern Reduzierte RAG-Insight **entscheiden, was im Vorfeld zählt** (-Signale **deterministisch speichern** (-Beweis **LLM nur für die Synthese einbeziehen** (-Query--Zeit-).- --- ## Die eingeschränkte Fuzziness Audio-Pipeline Das System läuft Wellen in Prioritätsreihenfolge ``` Wave Priority Order: 100: IdentityWave → SHA-256, file metadata, duration 90: FingerprintWave → Chromaprint perceptual hash (optional) 80: AcousticProfileWave → RMS, spectral features, SNR 70: ContentClassifierWave → Speech vs music heuristics (routing) 65: TranscriptionWave → Whisper.NET (optional) 60: SpeakerDiarizationWave→ Pure .NET speaker separation 30: VoiceEmbeddingWave → ECAPA-TDNN speaker similarity ``` > **Anmerkung**Sentiment-Erkennung bewusst ausgeschlossen — kulturell geladen und nicht Teil der forensischen Charakterisierung ### Architektur ```mermaid flowchart LR A[Audio file] --> B[IdentityWave] B --> C[AcousticProfileWave] C --> D[ContentClassifierWave] D --> E[TranscriptionWave] E --> F[SpeakerDiarizationWave] F --> G[VoiceEmbeddingWave] G --> H[Signal Ledger] H --> I[Optional LLM Synthesis] style B stroke:#333,stroke-width:4px style D stroke:#333,stroke-width:4px style F stroke:#333,stroke-width:4px style H stroke:#333,stroke-width:4px ``` Das bewahrt das Vertraute **Welle Signal Signal Optionales LLM** loop.,, aber verankert es in deterministischen Fakten. * Akustische Profilierung ist deterministisch ,( , gleicher Eingang , = , gleicher Ausgang , ) , * Die LLM arbeitet auf evidence-Beweis, nicht rohe Audio ### Beispiel für die Verarbeitung einer Podcast-Episode Lassen Sie uns eine Minute Podcast-Episode durch die Pipeline verfolgen ``` Input: podcast_ep42.mp3 - File size: 14.2 MB - Format: MP3, 44.1kHz stereo, 192 kbps - Duration: 15m 12s (912 seconds) - Content: 2-person interview Wave Execution (priority order 100 → 30): 1. IdentityWave (Priority 100, 87ms): ✓ SHA-256: 3f2a9c8b1e4d... ✓ Duration: 912.0s ✓ Channels: 2 (stereo) ✓ Sample rate: 44100 Hz ✓ File size: 14,897,234 bytes 2. AcousticProfileWave (Priority 80, 142ms): ✓ RMS loudness: -18.2 dB (good mastering) ✓ Peak amplitude: 0.94 (no clipping) ✓ Dynamic range: 22.1 dB ✓ Spectral centroid: 2418 Hz (speech-like) ✓ Spectral rolloff: 7892 Hz 3. ContentClassifierWave (Priority 70, 89ms): ✓ Zero-crossing rate: 0.17 (high → speech) ✓ Spectral flux: 0.28 (low → not music) → Classification: "speech" (confidence: 0.85) 4. TranscriptionWave (Priority 65, 12.3s): ✓ Whisper.NET base model ✓ Segments: 142 ✓ Total words: 2,341 ✓ Confidence: 0.87 (high) ✓ Text: "Welcome to Tech Insights. Today we're discussing..." 5. SpeakerDiarizationWave (Priority 60, 3.8s): ✓ VAD detected: 47 speech segments ✓ Embeddings extracted: 47 × 512-dim vectors ✓ Clustering (threshold 0.75): 2 speakers ✓ Turns before merge: 47 ✓ Turns after merge: 23 ✓ SPEAKER_00 participation: 52% (474s) ✓ SPEAKER_01 participation: 48% (438s) ✓ Sample clips extracted: 2 (Base64 WAV, ~30KB each) 6. VoiceEmbeddingWave (Priority 30, 178ms): ✓ ECAPA-TDNN inference ✓ Embedding dimension: 512 ✓ Voiceprint ID (SPEAKER_00): "vprint:a3f9c2e1d4b8" ✓ Voiceprint ID (SPEAKER_01): "vprint:7e2d8f1a9c3b" Total processing time: 16.6s Signals emitted: 47 LLM calls: 0 (fully offline) Cost: $0 (local processing only) ``` Das **Signalleiter** ist, was zu der Datenbank fortbestehend erhält... das komplette Bündel von Signalen... ,... Beweiszeiger... und Einbettungen... MKK3... hier... '... wie es für diesen Podcast aussieht. **Signal-Ledger-Auszug):** ```json { "identity.filename": "podcast_ep42.mp3", "audio.hash.sha256": "3f2a9c8b1e4d...", "audio.duration_seconds": 912.0, "audio.format": "mp3", "audio.sample_rate": 44100, "audio.channels": 2, "audio.channel_layout": "stereo", "audio.rms_db": -18.2, "audio.dynamic_range_db": 22.1, "audio.spectral_centroid_hz": 2418.3, "audio.spectral_rolloff_hz": 7892.1, "audio.content_type": "speech", "content.confidence": 0.85, "speaker.count": 2, "speaker.classification": "two_speakers", "speaker.turn_count": 23, "speaker.avg_turn_duration": 39.7, "speaker.diarization_method": "agglomerative_clustering", "speaker.participation": { "SPEAKER_00": 52.0, "SPEAKER_01": 48.0 }, "transcription.full_text": "Welcome to Tech Insights...", "transcription.word_count": 2341, "transcription.confidence": 0.87, "voice.embedding.speaker_00": [0.023, -0.511, 0.882, ...], "voice.voiceprint_id.speaker_00": "vprint:a3f9c2e1d4b8", "speaker.sample.speaker_00": "UklGRiQAAABXQVZF...", "speaker.sample.speaker_01": "UklGRiQBBBXQVZF..." } ``` **Was dies ermöglicht** - Suche nach "Tech Insights diskutiert Cloud-Infrastruktur" findet diese Episode via Transkript - Abfrage Suche nach Audio mit Voiceprint vprint , : , 3 , 9 , C2 , E1" , S→ , findet alle Episoden mit demselben Lautsprecher - Fragen Sie nach dem dynamischen Bereich unserer Podcast-Episoden?" - Filtern Suchen Sie nach niedrigen --Qualitätsaufzeichnungen"B oder Clipping-Aufnahmen>B - Verifizieren Sie die Funktion des Lautsprecher-Identifizierungsvorgangs. `speaker.sample.speaker_00` Clip im Inneren von -, Datei --- ## Warum Signale eine Rolle spielen, auch ohne LLM-Signale Ein Signalbuch beantwortet die langweiligen, aber dringenden Fragen sofort * Ist dieses Audio-Gespräch ,, , Musik oder Stille ?? * Wie viele Lautsprecher werden erkannt? * Was ist das Signal ,- , um ,- , Rauschverhältnis , ? ? * Gibt es Clipping-Artefakte oder Verzerrungen? * Was ist das spektrale Zentrioid? * Was ist der dynamische Bereich? Dies sind die Fragen, die Sie normalerweise entdecken, wenn Sie Minuten in Audacity-Archäologie gehen. Das Signalbuch gibt Ihnen sie in Sekunden --- ## Die Wellenpipeline von der Identität zur Intelligenz ### Wellen-Identität - Deterministisches Substrat - ) Die cryptografische Identität und die Datei-Metadaten ```csharp public class IdentityWave : IAudioWave { public string Name => "IdentityWave"; public int Priority => 100; // Runs first public async Task> AnalyzeAsync( string audioPath, AnalysisContext context, CancellationToken ct) { var signals = new List(); // Cryptographic hash (deterministic identity) var fileHash = await ComputeSha256Async(audioPath, ct); signals.Add(new Signal { Name = "audio.hash.sha256", Value = fileHash, Type = SignalType.Identity, Confidence = 1.0, Source = Name }); // File-level metadata var fileInfo = new FileInfo(audioPath); signals.Add(new Signal { Name = "audio.file_size_bytes", Value = fileInfo.Length, Type = SignalType.Metadata, Source = Name }); // Audio format metadata using var reader = new AudioFileReader(audioPath); signals.Add(new Signal { Name = "audio.duration_seconds", Value = reader.TotalTime.TotalSeconds, Type = SignalType.Metadata, Source = Name }); signals.Add(new Signal { Name = "audio.sample_rate", Value = reader.WaveFormat.SampleRate, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.channels", Value = reader.WaveFormat.Channels, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.format", Value = Path.GetExtension(audioPath).TrimStart('.'), Type = SignalType.Metadata, Source = Name }); return signals; } } ``` **Schlüsselsignale emittiert** - `audio.hash.sha256` Cryptografische Identität - `audio.duration_seconds` Länge der (, deterministisch - `audio.sample_rate` -, 44100,, MSC2 usw. . - `audio.channels` --1-M(-Mono-),-MNSK4-MSSK5-Stereo-),-6-MUSK8- - `audio.format` -, mp-3,, wav-,, flac-, usw. ., **Warum deterministisch?** - Gleiche Datei Gleiche Hash-Datei Gleiche Identität - Kein Zufallsstichproben-Parameter - Vertrauen - nicht probabilistisch --- ### Wellensignal-Verarbeitung (MSK) Extrahieren Sie strukturelle akustische Eigenschaften mit NAudio und FftSharp-. ```csharp public class AcousticProfileWave : IAudioWave { private readonly ILogger _logger; public string Name => "AcousticProfileWave"; public int Priority => 80; public async Task> AnalyzeAsync( string audioPath, AnalysisContext context, CancellationToken ct) { var signals = new List(); using var reader = new AudioFileReader(audioPath); // Convert to mono for analysis ISampleProvider sampleProvider = reader.WaveFormat.Channels == 1 ? reader : new StereoToMonoSampleProvider(reader) { LeftVolume = 0.5f, RightVolume = 0.5f }; // Read all samples var samples = ReadAllSamples(sampleProvider); // Time-domain analysis var rms = CalculateRms(samples); var peakAmplitude = samples.Max(Math.Abs); var dynamicRange = CalculateDynamicRange(samples); var clippingRatio = CalculateClippingRatio(samples, threshold: 0.99); signals.Add(new Signal { Name = "audio.rms_db", Value = 20 * Math.Log10(rms), // Convert to decibels Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.peak_amplitude", Value = peakAmplitude, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.dynamic_range_db", Value = dynamicRange, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.clipping_ratio", Value = clippingRatio, Type = SignalType.Acoustic, Confidence = clippingRatio > 0.01 ? 0.9 : 1.0, // Low confidence if clipping detected Source = Name }); // Frequency-domain analysis (FFT) var spectralFeatures = CalculateSpectralFeatures(samples, reader.WaveFormat.SampleRate); signals.Add(new Signal { Name = "audio.spectral_centroid_hz", Value = spectralFeatures.Centroid, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.spectral_rolloff_hz", Value = spectralFeatures.Rolloff, Type = SignalType.Acoustic, Source = Name }); signals.Add(new Signal { Name = "audio.spectral_bandwidth_hz", Value = spectralFeatures.Bandwidth, Type = SignalType.Acoustic, Source = Name }); return signals; } private SpectralFeatures CalculateSpectralFeatures(float[] samples, int sampleRate) { // Use FftSharp for frequency analysis int fftSize = 2048; var fftInput = new double[fftSize]; // Take middle section of audio int offset = Math.Max(0, (samples.Length - fftSize) / 2); for (int i = 0; i < fftSize; i++) { fftInput[i] = samples[offset + i]; } // Apply Hamming window var window = FftSharp.Window.Hamming(fftSize); for (int i = 0; i < fftSize; i++) { fftInput[i] *= window[i]; } // Compute FFT var fft = FftSharp.Transform.FFT(fftInput); var magnitudes = fft.Select(c => Math.Sqrt(c.Real * c.Real + c.Imaginary * c.Imaginary)).ToArray(); // Calculate spectral centroid (brightness) double sumWeightedFreq = 0; double sumMagnitude = 0; for (int i = 0; i < magnitudes.Length / 2; i++) { double freq = i * sampleRate / (double)fftSize; sumWeightedFreq += freq * magnitudes[i]; sumMagnitude += magnitudes[i]; } double centroid = sumMagnitude > 0 ? sumWeightedFreq / sumMagnitude : 0; // Calculate spectral rolloff (85% energy threshold) double totalEnergy = magnitudes.Take(magnitudes.Length / 2).Sum(m => m * m); double cumulativeEnergy = 0; double rolloff = 0; for (int i = 0; i < magnitudes.Length / 2; i++) { cumulativeEnergy += magnitudes[i] * magnitudes[i]; if (cumulativeEnergy >= 0.85 * totalEnergy) { rolloff = i * sampleRate / (double)fftSize; break; } } return new SpectralFeatures { Centroid = centroid, Rolloff = rolloff, Bandwidth = CalculateBandwidth(magnitudes, centroid, sampleRate, fftSize) }; } } ``` **Beispielausgabe** ``` Input: podcast.mp3 (15 minutes, 44.1kHz stereo) Signals emitted: audio.rms_db = -18.2 dB (good loudness) audio.peak_amplitude = 0.94 (no clipping) audio.dynamic_range_db = 22 dB (moderate dynamics) audio.clipping_ratio = 0.003 (0.3% clipping, minimal) audio.spectral_centroid_hz = 2400 Hz (mid-brightness, speech-like) audio.spectral_rolloff_hz = 8000 Hz (most energy below 8kHz) audio.spectral_bandwidth_hz = 4200 Hz (moderate spread) ``` **Warum das so wichtig ist** - RMS-Lautheit zeigt Meisterqualität - Clipping-Verhältnis erkennt Aufzeichnen von Artefakten - Spektrale Zentrioid unterscheidet Sprache (2-4, kHz, ), von Musik - Alle deterministischen ,— , gleiche Audio erzeugt dieselben Werte --- ### Welle -3:-Inhaltsklassifikation - (-Sprach vs. Musik-)- **Grobe heuristische Klassifizierung** Verwendung von Null---Übergangsgeschwindigkeit und spektralem Fluss für Routing-Zwecke > **Anmerkung**Diese Heuristiken sind Genres von /Kontext abhängig —'nicht zuverlässig präzise über alle Inhaltstypen..' Wird nur für Wave-Routing-Entscheidungen verwendet.MSC5'g.,« Überspringen Sie die Diarisierung für Musik, nicht als Grundwahrheit. ```csharp public class ContentClassifierWave : IAudioWave { public string Name => "ContentClassifierWave"; public int Priority => 70; public async Task> AnalyzeAsync( string audioPath, AnalysisContext context, CancellationToken ct) { var signals = new List(); using var reader = new AudioFileReader(audioPath); var samples = ReadAllSamples(reader); // Zero-crossing rate (heuristic: speech tends higher ZCR - not universal) var zcr = CalculateZeroCrossingRate(samples); // Spectral flux (heuristic: music tends more consistent - varies by genre) var spectralFlux = CalculateSpectralFlux(samples, reader.WaveFormat.SampleRate); // Simple heuristic classifier (for routing, not identity) // Thresholds calibrated for typical podcast/interview content // Production: calibrate on your corpus for best routing accuracy string contentType; double confidence; if (zcr > 0.15 && spectralFlux < 0.3) // Speech heuristic { contentType = "speech"; confidence = 0.85; } else if (zcr < 0.10 && spectralFlux > 0.5) { contentType = "music"; confidence = 0.80; } else { contentType = "mixed"; confidence = 0.70; } // Check for silence var rmsDb = context.GetValue("audio.rms_db"); if (rmsDb < -50) { contentType = "silence"; confidence = 0.95; } signals.Add(new Signal { Name = "audio.content_type", Value = contentType, Type = SignalType.Classification, Confidence = confidence, Source = Name, Metadata = new Dictionary { ["zero_crossing_rate"] = zcr, ["spectral_flux"] = spectralFlux, ["rms_db"] = rmsDb } }); return signals; } } ``` **Beispiel-Routing** ``` Speech (ZCR=0.18, flux=0.25): → audio.content_type = "speech" → Enables: TranscriptionWave, SpeakerDiarizationWave Music (ZCR=0.08, flux=0.65): → audio.content_type = "music" → Disables: SpeakerDiarizationWave (no speakers to detect) Silence (RMS=-52dB): → audio.content_type = "silence" → Disables: All downstream waves (early exit) ``` --- ## Reine Lautsprecher-Diarisierung von .-NET Keine Python-Diarisierung **Für lucidRAG-''s Bereitstellungsbeschränkungen**Lautsprecher-Diarisation ohne Pyannote, oder irgendwelche Python-Abhängigkeiten ### Das Problem mit der Python---basierten Diarisierung Traditioneller Ansatz ``` pyannote.audio (Python) → ONNX export (experimental) → C# wrapper (fragile) ``` **Probleme** - pyannote entfernte ONNX-Unterstützung wurde zu reinem PyTorch entfernt - Python-Laufzeit erforderlich - HTTP Wrapper fügt Latenz und Komplexität hinzu - Keine Offline-Unterstützung **Lösung** Diarisierung mit vorhandenen Sprach-Einbettungsmodellen in reines .-NET umsetzen ### Der reine Algorithmus des .-NET ``` 1. Voice Activity Detection (VAD) → Detect speech segments (energy-based RMS) 2. Segment Embedding → Extract ECAPA-TDNN embeddings for each segment 3. Agglomerative Clustering → Group segments by speaker (cosine similarity) 4. Speaker Turns → Merge consecutive turns from same speaker ``` ### Durchführung ```csharp public class SpeakerDiarizationService { private readonly ILogger _logger; private readonly VoiceEmbeddingService _embeddingService; private readonly AudioConfig _config; public virtual async Task DiarizeAsync( string audioPath, CancellationToken ct = default) { _logger.LogInformation("Starting speaker diarization for {AudioPath}", audioPath); // Step 1: Detect speech segments using VAD var segments = DetectSpeechSegments(audioPath); _logger.LogDebug("Detected {Count} speech segments", segments.Count); if (segments.Count == 0) { return new DiarizationResult { Turns = new List(), SpeakerCount = 0 }; } // Step 2: Extract embeddings for each segment var embeddings = new List<(SpeechSegment Segment, float[] Embedding)>(); foreach (var segment in segments) { try { var embedding = await ExtractSegmentEmbeddingAsync(audioPath, segment, ct); embeddings.Add((segment, embedding)); } catch (Exception ex) { _logger.LogWarning(ex, "Failed to extract embedding for segment {Start}-{End}", segment.StartSeconds, segment.EndSeconds); } } // Step 3: Cluster embeddings to identify speakers var speakerClusters = ClusterSpeakers(embeddings); _logger.LogInformation("Identified {Count} speakers", speakerClusters.Keys.Count); // Step 4: Create speaker turns var turns = new List(); foreach (var (segment, embedding) in embeddings) { var speakerId = FindSpeakerForEmbedding(embedding, speakerClusters); turns.Add(new SpeakerTurn { SpeakerId = speakerId, StartSeconds = segment.StartSeconds, EndSeconds = segment.EndSeconds, Confidence = 1.0 // TODO: Calculate based on cluster distance }); } // Step 5: Merge consecutive turns from same speaker var mergedTurns = MergeConsecutiveTurns(turns); return new DiarizationResult { Turns = mergedTurns, SpeakerCount = speakerClusters.Keys.Count }; } // Simple VAD using energy-based speech detection private List DetectSpeechSegments(string audioPath) { using var reader = new AudioFileReader(audioPath); ISampleProvider sampleProvider = reader.WaveFormat.Channels == 1 ? reader : new StereoToMonoSampleProvider(reader) { LeftVolume = 0.5f, RightVolume = 0.5f }; var sampleRate = sampleProvider.WaveFormat.SampleRate; var windowSize = sampleRate / 10; // 100ms windows var buffer = new float[windowSize]; var segments = new List(); SpeechSegment? currentSegment = null; double timeSeconds = 0; int samplesRead; while ((samplesRead = sampleProvider.Read(buffer, 0, buffer.Length)) > 0) { // Calculate RMS energy for this window double rms = Math.Sqrt(buffer.Take(samplesRead).Sum(s => s * s) / samplesRead); // Speech detection threshold (simple baseline - fragile across gain levels) // Production: use relative threshold (noise floor / percentile) or per-file calibration bool isSpeech = rms > 0.02; // Fixed threshold for demonstration if (isSpeech) { if (currentSegment == null) { // Start new segment currentSegment = new SpeechSegment { StartSeconds = timeSeconds }; } } else { if (currentSegment != null) { // End current segment currentSegment.EndSeconds = timeSeconds; // Only keep segments longer than minimum duration if (currentSegment.Duration >= _config.VoiceEmbedding.MinDurationSeconds) { segments.Add(currentSegment); } currentSegment = null; } } timeSeconds += (double)samplesRead / sampleRate; } // Close final segment if still open if (currentSegment != null) { currentSegment.EndSeconds = timeSeconds; if (currentSegment.Duration >= _config.VoiceEmbedding.MinDurationSeconds) { segments.Add(currentSegment); } } return segments; } // Agglomerative clustering of speaker embeddings private Dictionary> ClusterSpeakers( List<(SpeechSegment Segment, float[] Embedding)> embeddings) { const double SimilarityThreshold = 0.75; // Cosine similarity threshold var clusters = new Dictionary>(); int nextSpeakerId = 0; foreach (var (segment, embedding) in embeddings) { string? assignedCluster = null; double maxSimilarity = 0; // Find best matching cluster foreach (var (clusterId, clusterEmbeddings) in clusters) { // Calculate average similarity to cluster var avgSimilarity = clusterEmbeddings .Select(e => _embeddingService.CalculateSimilarity(embedding, e)) .Average(); if (avgSimilarity > maxSimilarity) { maxSimilarity = avgSimilarity; assignedCluster = clusterId; } } // Assign to cluster or create new one if (maxSimilarity >= SimilarityThreshold && assignedCluster != null) { clusters[assignedCluster].Add(embedding); } else { var newClusterId = $"SPEAKER_{nextSpeakerId:D2}"; clusters[newClusterId] = new List { embedding }; nextSpeakerId++; } } return clusters; } } ``` **Beispielausgabe** ``` Input: podcast.mp3 (15 minutes, 2 speakers) Processing: Step 1 (VAD): Detected 47 speech segments (0.5s to 45s each) Step 2 (Embeddings): Extracted 47 × 512-dim ECAPA-TDNN embeddings Step 3 (Clustering): 47 embeddings → 2 clusters (similarity threshold 0.75) Step 4 (Turns): Created 47 speaker turns Step 5 (Merge): 47 turns → 23 merged turns (consecutive same-speaker segments) Output: SpeakerCount: 2 Turns: 23 - SPEAKER_00: 0.0s - 5.2s (confidence: 1.0) - SPEAKER_01: 5.2s - 12.8s (confidence: 1.0) - SPEAKER_00: 12.8s - 18.3s (confidence: 1.0) - ... Signals emitted: speaker.count = 2 speaker.classification = "two_speakers" speaker.turn_count = 23 speaker.diarization_method = "agglomerative_clustering" speaker.avg_turn_duration = 39.1 seconds speaker.diarization_confidence = 1.0 ``` **Warum das funktioniert** - VAD ist deterministisch - ECAPA---TDNN-Embeddings sind deterministisch. - Clustering-Schwellenwert ist konfigurierbar - Keine Python-Laufzeit erforderlich - Führt Offline-API-Aufrufe aus. --- ## Sprach-Embeddings - Anonyme Speaker Ähnlichkeit ECAPA---TDNN ONNX-Modellextrakte Dimensionale Lautsprechereinbettungen für die Ähnlichkeitserkennung ### Das Datenschutzmodell **Was wir tun** - Beziehen Sie Lautsprechernamen - Erraten demographische Werte Alter , Geschlecht ,akzent - Machen Sie kulturelle Behauptungen - Speichern von Roh-Audio **Was wir tun** - Generieren Sie anonyme Sprachabdruck-IDs`vprint:abc123...`) - Berechnen Sie die Ähnlichkeit des Lautsprechers mit der Entfernung des Kosinus. - Ähnliche Lautsprecher suchen - Nicht umkehrbar, sondern als sensible Daten behandeln ### Durchführung ```csharp public class VoiceEmbeddingService { private readonly ILogger _logger; private readonly VoiceEmbeddingModelDownloader _modelDownloader; private readonly string _modelPath; private InferenceSession? _session; public async Task ExtractEmbeddingAsync( string audioPath, CancellationToken ct = default) { await EnsureModelLoadedAsync(ct); // Extract Mel spectrogram features (80 Mel bands) var features = await Task.Run(() => ExtractMelSpectrogram(audioPath), ct); // Flatten 2D array to 1D for DenseTensor int numMelBands = features.GetLength(0); int numFrames = features.GetLength(1); var flatFeatures = new float[numMelBands * numFrames]; for (int i = 0; i < numMelBands; i++) { for (int j = 0; j < numFrames; j++) { flatFeatures[i * numFrames + j] = features[i, j]; } } // Run ONNX inference (ECAPA-TDNN model) var inputTensor = new DenseTensor(flatFeatures, new[] { 1, numMelBands, numFrames }); var inputs = new List { NamedOnnxValue.CreateFromTensor("input", inputTensor) }; using var results = _session!.Run(inputs); var embeddingTensor = results.First().AsEnumerable().ToArray(); // Normalize embedding (L2 normalization) var embedding = NormalizeEmbedding(embeddingTensor); // Generate anonymous voiceprint ID (SHA-256 hash of embedding) var voiceprintId = GenerateVoiceprintId(embedding); return new VoiceEmbedding { Vector = embedding, VoiceprintId = voiceprintId, Dimension = embedding.Length, Model = "ecapa-tdnn" }; } // Calculate cosine similarity between two voice embeddings public virtual double CalculateSimilarity(float[] embedding1, float[] embedding2) { if (embedding1.Length != embedding2.Length) throw new ArgumentException("Embeddings must have same dimension"); double dotProduct = 0; double norm1 = 0; double norm2 = 0; for (int i = 0; i < embedding1.Length; i++) { dotProduct += embedding1[i] * embedding2[i]; norm1 += embedding1[i] * embedding1[i]; norm2 += embedding2[i] * embedding2[i]; } if (norm1 == 0 || norm2 == 0) return 0; return dotProduct / (Math.Sqrt(norm1) * Math.Sqrt(norm2)); } private string GenerateVoiceprintId(float[] embedding) { // Generate anonymous ID from embedding hash // This ensures same voice → same ID, but no PII // // Stability notes: // - Deterministic on same runtime/endianness/float serialization // - Voiceprint IDs are stable for a given model + preprocessing version // - Treat as versioned identifiers - regenerate if model changes // - Cross-platform determinism depends on float serialization consistency using var sha256 = System.Security.Cryptography.SHA256.Create(); var bytes = new byte[embedding.Length * sizeof(float)]; Buffer.BlockCopy(embedding, 0, bytes, 0, bytes.Length); var hash = sha256.ComputeHash(bytes); return "vprint:" + Convert.ToHexString(hash).Substring(0, 16).ToLower(); } } ``` **Anwendungsbeispiele** ```csharp // Extract embedding from two audio files var embedding1 = await voiceEmbeddingService.ExtractEmbeddingAsync("speaker1.wav"); var embedding2 = await voiceEmbeddingService.ExtractEmbeddingAsync("speaker2.wav"); // Calculate similarity var similarity = voiceEmbeddingService.CalculateSimilarity( embedding1.Vector, embedding2.Vector ); // Output: // embedding1.VoiceprintId = "vprint:a3f9c2e1d4b8" // embedding2.VoiceprintId = "vprint:7e2d8f1a9c3b" // similarity = 0.91 (high similarity, likely same speaker) ``` **Anonyme Lautsprechersuche** ```csharp // Find audio files with similar speakers var queryEmbedding = await voiceEmbeddingService.ExtractEmbeddingAsync("query.wav"); var similarSpeakers = audioDatabase .Where(audio => audio.VoiceEmbedding != null) .Select(audio => new { Audio = audio, Similarity = voiceEmbeddingService.CalculateSimilarity( queryEmbedding.Vector, audio.VoiceEmbedding ) }) .Where(x => x.Similarity > 0.75) // Threshold for "similar" .OrderByDescending(x => x.Similarity) .Take(10) .ToList(); // Results: // 1. podcast_ep12.mp3 (similarity: 0.94) - likely same speaker // 2. podcast_ep15.mp3 (similarity: 0.89) - likely same speaker // 3. interview_2024.wav (similarity: 0.76) - possibly same speaker ``` **Warum anonym?** - Voiceprint ID ist ein Hash der Einbettungsfunktion -. - Embedding ist die Abmessungen von 512 und kann nicht den Namen des Lautsprechers bezeichnen. - Ähnlichkeitspunktzahl ist relativ, aber nicht absolut. - Datenschutz - Erhaltung der gespeicherten PII-Daten --- ## Audio-Segment-Extraktion, :, Evidence Playback Extrahieren von Zeit---Bereich Audioclips für Lautsprecherdiarisierung Evidenz-MSC1 ### Das Problem Die Diarisierung sagt Ihnen, dass Sie "-SPEAKER-_00-Sprache von 5.2-S zu 12.8-S", aber keine Möglichkeit bietet, diese Behauptung zu überprüfen **Lösung** Extrahieren Sie Audioclips aus der ersten Runde eines jeden Lautsprechers als Basecodierung und speichern Sie als Signale. ### Durchführung ```csharp public class AudioSegmentExtractor { private readonly ILogger _logger; // Extract speaker sample clips from diarization result public virtual async Task> ExtractSpeakerSamplesAsync( string audioPath, IEnumerable turns, double sampleDurationSeconds = 2.0, CancellationToken ct = default) { var samples = new Dictionary(); // Group turns by speaker and take first turn for each var speakerFirstTurns = turns .GroupBy(t => t.SpeakerId) .Select(g => g.OrderBy(t => t.StartSeconds).First()) .ToList(); foreach (var turn in speakerFirstTurns) { try { // Extract sample from start of first turn var sampleEnd = Math.Min(turn.EndSeconds, turn.StartSeconds + sampleDurationSeconds); var base64 = await ExtractSegmentAsBase64Async( audioPath, turn.StartSeconds, sampleEnd, sampleDurationSeconds, ct); samples[turn.SpeakerId] = base64; _logger.LogDebug("Extracted {Duration:F2}s sample for {SpeakerId}", sampleEnd - turn.StartSeconds, turn.SpeakerId); } catch (Exception ex) { _logger.LogWarning(ex, "Failed to extract sample for {SpeakerId}", turn.SpeakerId); } } return samples; } // Extract segment and return as Base64-encoded WAV public async Task ExtractSegmentAsBase64Async( string audioPath, double startSeconds, double endSeconds, double maxDurationSeconds = 3.0, CancellationToken ct = default) { var wavBytes = await ExtractSegmentAsWavBytesAsync( audioPath, startSeconds, endSeconds, maxDurationSeconds, ct); return Convert.ToBase64String(wavBytes); } // Core extraction logic private async Task ExtractSegmentToStreamAsync( string audioPath, double startSeconds, double endSeconds, Stream outputStream, CancellationToken ct) { using var reader = new AudioFileReader(audioPath); // Calculate byte positions var startPosition = (long)(startSeconds * reader.WaveFormat.AverageBytesPerSecond); var endPosition = (long)(endSeconds * reader.WaveFormat.AverageBytesPerSecond); // Align to block boundaries startPosition -= startPosition % reader.WaveFormat.BlockAlign; endPosition -= endPosition % reader.WaveFormat.BlockAlign; // Clamp to file boundaries startPosition = Math.Max(0, startPosition); endPosition = Math.Min(reader.Length, endPosition); var segmentLength = endPosition - startPosition; // Seek to start position reader.Position = startPosition; // Create trimmed reader // AudioFileReader outputs decoded PCM samples; TrimmedStream creates a windowed view // WaveFileReader wraps it for format conversion pipeline (works for MP3/FLAC/WAV) using var trimmedReader = new WaveFileReader(new TrimmedStream(reader, segmentLength)); // Convert to 16-bit PCM WAV for maximum compatibility using var pcmStream = WaveFormatConversionStream.CreatePcmStream(trimmedReader); using var resampler = new MediaFoundationResampler(pcmStream, new WaveFormat(16000, 16, 1)) { ResamplerQuality = 60 // High quality }; // Write to output as WAV await Task.Run(() => WaveFileWriter.WriteWavFileToStream(outputStream, resampler), ct); } } ``` **Beispiel Integration in SpeakerDiarizationWave-:** ```csharp // Extract speaker sample audio clips (2 second clips from first turn of each speaker) try { _logger.LogDebug("Extracting speaker samples from {AudioPath}", audioPath); var speakerSamples = await _segmentExtractor.ExtractSpeakerSamplesAsync( audioPath, result.Turns, sampleDurationSeconds: 2.0, cancellationToken); // Emit speaker samples as signals (Base64-encoded WAV) foreach (var (speakerId, base64Wav) in speakerSamples) { signals.Add(new Signal { Name = $"speaker.sample.{speakerId.ToLowerInvariant()}", Value = base64Wav, Type = SignalType.Embedding, // Using Embedding type for binary data Source = Name }); _logger.LogDebug("Added audio sample for {SpeakerId} ({SizeKB} KB)", speakerId, Math.Round(base64Wav.Length / 1024.0, 1)); } } catch (Exception ex) { _logger.LogWarning(ex, "Failed to extract speaker samples: {Message}", ex.Message); } ``` **Beispielausgabe** ``` Input: podcast.mp3 (2 speakers detected) Extraction: SPEAKER_00: 0.0s - 2.0s (first turn 0.0s - 5.2s) SPEAKER_01: 5.2s - 7.2s (first turn 5.2s - 12.8s) Signals emitted: speaker.sample.speaker_00 = "UklGRiQAAABXQVZFZm10..." (Base64 WAV, 31.2 KB) speaker.sample.speaker_01 = "UklGRiQAAABXQVZFZm10..." (Base64 WAV, 29.8 KB) UI integration: ``` **Warum das so wichtig ist** - Evidence playback-:-User können jedes Lautsprecherbeispiel hören - Verifizierung::-Bestätigt die Diarisierungsgenauigkeit - Debugging-: Identifiziert falsch klassifizierte Segmente - Datenschutz – :-Nur , 2--Sekundenproben , (-nicht voll audio-)- --- ## Integration mit lucidRAG AudioSummarizer integriert nahtlos mit lucidRAG-' s Dokumentenverarbeitung Pipeline über eine **Zweistufige Reduktion des -**: 1. **Stage-Empfänger-Emblem**Verringern Sie Audiodatei auf akustische Signatur - Signale ,: , spektrale Eigenschaften , , , Lautsprechereinbettungen , , , Diarisationsdrehungen - Evidenz-:-Lautsprecher Beispielclips - Voller Transkripttext - Ausgabe: :-Markdown-Zusammenfassung: Signal JSON 2. **Stufe: 2, DocSummarizer, ),**Verringern Sie Transkript auf semantische Signatur - Prozess-Transkript über DocSummarizer Pipeline - Entitäten extrahieren Themen - Embeddings für semantische Suche generieren - Aufbau von Wissensgraphen-Links - Ausgabe des Diagramms der Entitätsstruktur +, gelochte Einbetten Diese **Verringerung der Kaskadierung** Ermöglicht Abfragen wie - Finden Sie Audio-Erwähnen Quanten-Computing-" DocSummarizer Entitäten aus Transkript - Finden Sie Podcasts mit ähnlichen Lautsprechern - Messwerte zeigen niedrig- qualitative Aufnahmen über AI-" .→ .Kombinieren Sie akustische Signale, um semantische Einheiten ### Registrierung von Dokumentenhandlern ```csharp // In LucidRAG.Core, register audio handler services.AddSingleton(); // AudioDocumentHandler.cs public class AudioDocumentHandler : IDocumentHandler { private readonly AudioWaveOrchestrator _orchestrator; private readonly IDocumentProcessingService _docProcessingService; public bool CanHandle(string filePath, string mimeType) { var supportedExtensions = new[] { ".mp3", ".wav", ".m4a", ".flac", ".ogg" }; var extension = Path.GetExtension(filePath).ToLowerInvariant(); return supportedExtensions.Contains(extension); } public async Task ProcessAsync( string filePath, ProcessingOptions options, CancellationToken ct) { // STAGE 1: Run audio wave pipeline (acoustic + transcript extraction) var profile = await _orchestrator.AnalyzeAsync(filePath, ct); // Extract transcript text var transcriptText = profile.GetValue("transcription.full_text"); // STAGE 2: Pass transcript through DocSummarizer pipeline (entity extraction) DocumentContent? transcriptContent = null; if (!string.IsNullOrEmpty(transcriptText) && options.ExtractEntities) { // Create temporary markdown file from transcript // NOTE: Temp file approach is demo code for CLI integration example. // Production should use in-memory pipeline API to avoid privacy leaks from temp files. var tempTranscript = Path.GetTempFileName() + ".md"; await File.WriteAllTextAsync(tempTranscript, transcriptText, ct); try { // Process transcript through DocSummarizer transcriptContent = await _docProcessingService.ProcessDocumentAsync( tempTranscript, new ProcessingOptions { ExtractEntities = true, GenerateEmbeddings = true }, ct); } finally { File.Delete(tempTranscript); } } // Convert audio signals to markdown var audioMarkdown = ConvertToMarkdown(profile); // Merge audio signals + transcript entities var finalMarkdown = audioMarkdown; if (transcriptContent != null) { finalMarkdown += "\n\n---\n\n"; finalMarkdown += "## Transcript Analysis (DocSummarizer)\n\n"; finalMarkdown += transcriptContent.MainContent; } return new DocumentContent { MainContent = finalMarkdown, Title = Path.GetFileNameWithoutExtension(filePath), ContentType = "audio/summary", Entities = transcriptContent?.Entities ?? new List(), Embeddings = transcriptContent?.Embeddings ?? Array.Empty() }; } private string ConvertToMarkdown(DynamicAudioProfile profile) { var sb = new StringBuilder(); sb.AppendLine($"# Audio Analysis: {profile.GetValue("identity.filename")}"); sb.AppendLine(); // Acoustic properties sb.AppendLine("## Acoustic Profile"); sb.AppendLine($"- Duration: {profile.GetValue("audio.duration_seconds"):F1} seconds"); sb.AppendLine($"- Format: {profile.GetValue("audio.format")}"); sb.AppendLine($"- Sample Rate: {profile.GetValue("audio.sample_rate")} Hz"); sb.AppendLine($"- Channels: {profile.GetValue("audio.channel_layout")}"); sb.AppendLine($"- RMS Loudness: {profile.GetValue("audio.rms_db"):F1} dB"); sb.AppendLine($"- Dynamic Range: {profile.GetValue("audio.dynamic_range_db"):F1} dB"); sb.AppendLine(); // Content classification sb.AppendLine("## Content Classification"); sb.AppendLine($"- Type: {profile.GetValue("audio.content_type")}"); sb.AppendLine(); // Transcription (if available) var transcriptText = profile.GetValue("transcription.full_text"); if (!string.IsNullOrEmpty(transcriptText)) { sb.AppendLine("## Transcript"); sb.AppendLine(transcriptText); sb.AppendLine(); } // Speaker diarization (if available) var speakerCount = profile.GetValue("speaker.count"); if (speakerCount.HasValue && speakerCount > 0) { sb.AppendLine("## Speaker Diarization"); sb.AppendLine($"- Speakers Detected: {speakerCount}"); sb.AppendLine($"- Classification: {profile.GetValue("speaker.classification")}"); sb.AppendLine($"- Turn Count: {profile.GetValue("speaker.turn_count")}"); var turnsJson = profile.GetValue("speaker.turns"); if (!string.IsNullOrEmpty(turnsJson)) { sb.AppendLine(); sb.AppendLine("### Speaker Turns"); sb.AppendLine("```json"); sb.AppendLine(turnsJson); sb.AppendLine("```"); } } return sb.ToString(); } } ``` ### CLI-Integration – bald kommen – ) Wenn AudioSummarizer in lucidRAG CLI integriert ist, können Audiodateien wie diese verarbeitet werden. ```bash # Process audio file (auto-detects audio type) dotnet run --project src/LucidRAG.Cli -- process podcast.mp3 # Expected output: # Processing: podcast.mp3 # ├─ IdentityWave (100ms): SHA-256, duration, format # ├─ AcousticProfileWave (142ms): RMS, spectral features # ├─ ContentClassifierWave (89ms): Detected speech content # ├─ TranscriptionWave (12.3s): Whisper.NET transcription # ├─ SpeakerDiarizationWave (3.8s): 2 speakers, 23 turns # └─ VoiceEmbeddingWave (178ms): ECAPA-TDNN embeddings # # Signals emitted: 47 # Processing time: 16.6s # Saved to database: doc_abc123 # # Acoustic Profile: # Duration: 900.0s (15m 0s) # Format: mp3, 44100 Hz, stereo # RMS: -18.2 dB, Dynamic Range: 22.1 dB # Content: speech (confidence: 0.85) # # Speaker Diarization: # Speakers: 2 (two_speakers) # Turns: 23 # SPEAKER_00: 52% participation (468s) # SPEAKER_01: 48% participation (432s) # # Transcription: Available (12,847 characters) # Batch process audio directory dotnet run --project src/LucidRAG.Cli -- process ./audio/*.mp3 --verbose # Extract entities from audio (via transcript) dotnet run --project src/LucidRAG.Cli -- process interview.wav --extract-entities # Export signals as JSON for inspection dotnet run --project src/LucidRAG.Cli -- process podcast.mp3 --export-signals signals.json ``` **Beispielsignale . json-Ausgang** ```json { "audio.hash.sha256": "a3f9c2e1d4b8...", "audio.duration_seconds": 900.0, "audio.format": "mp3", "audio.sample_rate": 44100, "audio.channels": 2, "audio.channel_layout": "stereo", "audio.rms_db": -18.2, "audio.dynamic_range_db": 22.1, "audio.spectral_centroid_hz": 2418.3, "audio.content_type": "speech", "speaker.count": 2, "speaker.classification": "two_speakers", "speaker.turn_count": 23, "speaker.diarization_confidence": 1.0, "speaker.participation": { "SPEAKER_00": 52.0, "SPEAKER_01": 48.0 }, "transcription.full_text": "...", "transcription.confidence": 0.87, "speaker.sample.speaker_00": "UklGRiQAAABXQVZF..." } ``` ### Evidenzspeicherung ```csharp // Store speaker samples as evidence artifacts foreach (var (speakerId, base64Wav) in speakerSamples) { var evidence = new EvidenceArtifact { Id = Guid.NewGuid(), DocumentId = documentEntity.Id, Type = EvidenceTypes.SpeakerSample, Content = base64Wav, // Base64-encoded WAV Metadata = new SpeakerSampleMetadata { SpeakerId = speakerId, StartSeconds = turn.StartSeconds, EndSeconds = turn.EndSeconds, SampleRate = 16000, Channels = 1, Format = "wav" } }; await evidenceRepository.SaveAsync(evidence); } // Store full signal dump as evidence var signalDump = JsonSerializer.Serialize(profile.GetAllSignals(), new JsonSerializerOptions { WriteIndented = true }); await evidenceRepository.SaveAsync(new EvidenceArtifact { Id = Guid.NewGuid(), DocumentId = documentEntity.Id, Type = EvidenceTypes.AudioSignals, Content = signalDump, Metadata = new AudioSignalsMetadata { SignalCount = profile.GetAllSignals().Count(), WavesExecuted = profile.GetExecutedWaves().ToList(), ProcessingSeconds = profile.GetValue("processing_time_seconds"), HasFingerprint = profile.HasSignal("audio.fingerprint.hash"), HasTranscription = profile.HasSignal("transcription.full_text"), HasDiarization = profile.HasSignal("speaker.count"), ContentType = profile.GetValue("audio.content_type") } }); ``` --- ## Einrichtung Vollständige Konfigurationsbeispiele ```json { "AudioSummarizer": { "EnableSpeakerDiarization": true, "EnableTranscription": true, "EnableVoiceEmbeddings": true, "SupportedFormats": [".mp3", ".wav", ".m4a", ".flac", ".ogg", ".wma", ".aac"], "MaxFileSizeMB": 500, "VoiceEmbedding": { "ModelPath": "./models/voxceleb_ECAPA512_LM.onnx", "MinDurationSeconds": 1.0, "AutoDownload": true }, "Transcription": { "Backend": "Whisper", "Whisper": { "ModelPath": "./models/whisper-base.en.bin", "ModelSize": "base", "Language": "en", "UseGpu": false }, "Ollama": { "BaseUrl": "http://localhost:11434", "Model": "whisper" } }, "AcousticProfiling": { "EnableSpectralAnalysis": true, "FftSize": 2048, "VadThreshold": 0.02 }, "Fingerprinting": { "Provider": "PureNet", "EnableDeduplication": true } } } ``` --- ## Leistungsmerkmale |-Welle Priorität Geschwindigkeit |-Deterministisch |-Requires |------|----------|-------|---------------|----------| ,| , IdentityWave , | , 100 , -| ,-~50 , ja ,| , NAudio , –| , FingerabdruckWave |Auszug aus 90Ausgang aus|Ausgangs-~200Auszugs-|Ausführungs- und -Verarbeitungsvorgängen Ja Ausprägungen aus |Ausgriffs-FftSharp Ausprägen AkustischeProfileWave - > | - >80 - > | - < ~150 - > , | - > Ja ,| - > NAudio- > , - > FftSharp - <| - > InhaltKlassifikatorWave , | , 70 ,| , ~100 , | , heuristische ,|, - ,-| ,| , TranskriptionWave , | , 65 , | , ~5-15 , nicht | , Whisper , oder Ollama , LautsprecherDiarizationWave - Spektrum | - Format 60 - Format | - Format~2-8 - Clustering-Format | - Format ECAPA - Format TDNN ONNX - Format Sprach-Embedding-Wave ,| , 30 , | , ~200 , | , ja ,| , ECAPA, -, TDNN ONNX , | **Beispiel Timing-Termine (15--Minute-Podcast,-Lautsprecher 2-Läser** ``` IdentityWave: 45ms (SHA-256 + metadata) AcousticProfileWave: 132ms (FFT + spectral analysis) ContentClassifierWave: 87ms (ZCR + spectral flux) TranscriptionWave: 12.3s (Whisper.NET base model) SpeakerDiarizationWave: 3.8s (VAD + embeddings + clustering) VoiceEmbeddingWave: 178ms (ECAPA-TDNN inference) Total: ~16.6 seconds ``` **Offline-Modus keine Transkription** ``` IdentityWave → VoiceEmbeddingWave: ~600ms ``` --- ## Schlußfolgerung AudioSummarizer beweist, dass die **[Reduziertes RAG-Muster](https://www.mostlylucid.net/blog/reduced-rag)** arbeitet für audio: reduziere einmal auf Signale- -+ evidence -M,Abfrage gegen strukturierte Fakten-MSC3Synthetisieren mit gebundenem LLM-Eingang **Wichtigste Erkenntnisse** 1. **Signalextraktion über Zusammenfassungen**Spektrale Eigenschaften des Lautsprechers (MSK) 2. **Nachweise sind prüfbar**Lautsprecherproben (Basic-64Basik-MAV®),A-Transkripte ,A-Diarisationsdrehungen—keine undurchsichtigen Brocken 3. **Abfrage---Zeitfilter**Datenbank, in der Klauseln eliminiert werden, bevor die LLM etwas sieht 4. **Kontextfenster-Verkleinerung**Audio-Zusammenfassungen anstelle von rohen Stücken 5. **Reine Diarisierung des .-NET**Agglomeratives Clustering (ECAPA) -TDNN Keine Python-,Keine Pyannote 6. **Datenschutz durch Design**Anonyme Sprachabdrücke (hash--hbased IDs ),hke no speaer nameing ,hash keine kulturellen Behauptungen **Das Reduzierte RAG-Muster für audio** ``` Ingestion: Audio file → Wave pipeline → Signals (JSON) + Evidence (transcript, samples) Storage: Signals (indexed) + Embeddings (speaker similarity) + Evidence (artifacts) Query: Filter (SQL) → Search (BM25 + vector) → Synthesize (LLM, ~5 results) ``` Das ist **Beschränkte Fuzziness** zusammengesetzt mit **Reduzierte RAG**Deterministische Signale schränken die probabilistische Synthese ein und das LLM arbeitet auf vor--®computierten Evidences. Das Muster skaliert über alle lucidRAG-Modalitäten. - **[DocSummarizer](/blog/building-a-document-summarizer-with-rag)** Dokumente - Extraktion der ( - Wissensgraphen - semantisches Lochen von ) - - **[ImageSummarizer](/blog/constrained-fuzzy-image-intelligence)** Bildmaterial zur visuellen Intelligenz der (22-Wave-Bilder zur Erkennung von Objekten der ,Wave - **[DatenZusammenfassung](/blog/datasummarizer-how-it-works)** Daten zur Schlussfolgerung des (-Schemas zur Qualitätsprofilierung der ,-Typen - **AudioSummarizer** Diesen Artikel schreiben Sie bitte an: Alle Umsetzung des gleichen Kerns **[Reduziertes RAG-Muster](/blog/reduced-rag)**:-Signale Evidenz Evidence MS K2-Abfrage --Zeit-Synthese --- ## Aufkommen ### lucidRAG-Dokumentation - **[AudioSummarizer Bibliothek](https://github.com/scottgal/lucidrag/tree/main/src/AudioSummarizer.Core)** Code der Quelle - **[Leitfaden für die Architektur](https://github.com/scottgal/lucidrag/blob/main/src/AudioSummarizer.Core/docs/architecture.md)** Signalsignale der MSK-Pipeline - **[Referenzsignale](https://github.com/scottgal/lucidrag/blob/main/src/AudioSummarizer.Core/docs/signals.md)** Vollständiger Signalkatalog ### ONNX-Modelle - **[ECAPA---TDNN auf HuggingFace](https://huggingface.co/Wespeaker/wespeaker-ecapa-tdnn512-LM)** Sprach-Einbettungsmodell - **[Whisper-.-NET](https://github.com/sandrohanea/whisper.net)** Wrapper für Whisper, .cpp - **[ONNX Laufzeitdokumentation](https://onnxruntime.ai/docs/get-started/with-csharp.html)** ### Forschungspapiere - **[ECAPA---TDNN Papier](https://arxiv.org/abs/2005.07143)** Lautsprecher-Verifikationsarchitektur - **[Flüsterpapier](https://arxiv.org/abs/2212.04356)** Spracherkennung von OpenAI-' - **[PyAnnote](https://huggingface.co/pyannote/speaker-diarization-3.1)** Reference Implementation - Referenzimplementierung ### Verwandte Artikel **Kernmuster** - **[Reduzierte RAG](https://www.mostlylucid.net/blog/reduced-rag)** Das Kernmuster der (Signale Evidenz Evidence + Abfrage -Zeitsynthese ) - **[Eingeschränktes Fuzziness-Muster](/blog/constrained-fuzziness-pattern)** Grundmuster **Reduzierte RAG-Implementierungen** - **[DocSummarizer](/blog/building-a-document-summarizer-with-rag)** Dokument RAG mit Entity-Extraktion und Wissensgraphen - **[DatenZusammenfassung](/blog/datasummarizer-how-it-works)** Datenprofilierung und Schemainferenz RAG - **[Bild-Summarizer-:-Bildintelligenz](/blog/constrained-fuzzy-image-intelligence)** Bild RAG mit visueller Intelligenz Pipeline - **[Eingeschränkte Fuzzy OCR](/blog/constrained-fuzzy-image-ocr-pipeline)** ,- , 3 , - tier OCR , ( local , ONNX , LLM, ) - **AudioSummarizer Dieser Artikel** Audio forensische Charakterisierung mit Lautsprecher-Diarisation --- ## Die Reihe Teil |, Muster |, Fokus |------|---------|-------| | 1 | [Beschränkte Fuzziness](/blog/constrained-fuzziness-pattern) Einteilige Komponente | 2 | [Beschränkte Fuzzy MoM](/blog/constrained-mom-mixture-of-models) Mehrere Komponenten | 3 | [Kontext schleppen](/blog/constrained-fuzzy-context-dragging) Zeit-Speicher (MSK) | 4 | [Bildintelligenz](/blog/constrained-fuzzy-image-intelligence) Wellenarchitektur,, Wellen 22, Wellen | 4.1 | [Drei---Tier OCR Pipeline](/blog/constrained-fuzzy-image-ocr-pipeline) Filmreisen mit ONNX-Modellen | **4.2** | **AudioSummarizer Dieser Artikel** | **Forensische Audio-Diarisierung des Lautsprechers** | **Nächster**Mehrstufige Grafik RAG mit lucidRAG-—, die DocSummarizer, ,, ImageSummaraizer, ,, AudioSummarinizer,, und DataSumMARizer zu einem einheitlichen Wissensgraphen zusammenfasst Alle Teile folgen dem gleichen Invariant. **probabilistische Komponenten schlagen vor deterministische Systeme bestehen fort.**.