This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
AudioSummarizer: Конstrained Fuzzy Forensic Audio Characterization
Monday, 12 January 2026
Статус: AudioSummarizerM SK1 Кора зараз в розробці як частина lucidRAG, майбутній, більш-менш зрозумілій продукт для мультиплексу - модальний RAG МSK2 Implementation is complete and working МSK3this article documents the architecture and design
Источник: github.comM SK1scottgal/lucidrag (branchM SK1
v2)
Де це підходить?: AudioSummarizer є частиною lucidRAG сім 'я Reduced RAG implementations. Кожна з них працює по-різному
- DocSummarizer - Документи
- ImageSummarizer - Фото МSK1 хвиля зорової інтелекту
- DataSummarizer МSK0 Дані ( Сchéма висновків МSK2 Profilування )
- AudioSummarizer ( цей artykułM SK1 - аудіо МSK3 акустичний профиль МSK4 диарізація głośnikів)
Все йде так само Снижена модель RAG: виокремлює сигнали, як тільки МSK1 зберігає дані МSK2 синтезує з обмеженим входом LLM .
Багато демонстрацій – МСК0, перші ланцюги з аналізом звуку роблять те ж саме. МСК1, вони ставляться до LLM так, наче вони були інженерами акустики
Вони переносять хвилі в моделі. МСК0. Вони просять їх: МСК1, пізнати якість мовлення, ", " МСК3, визначити співпромовців, ,", і сподіваються, що модель зможе вивести структурні властивості з того, що є фундаментальним шаблоном. \ "" МSK5, система комбінацій, МSK6 "". Вона працює достатньо добре для демонстрації. МSK7, а потім галюциналізує ім 'я співперемовників. МСК8, вигадує музичні жанри. М СК9, або напевно неправильно визначає акценти.
AudioSummarizer об 'єднує дві комплементарні моделі:
- Reduced RAG для отримання - виділення сигналів один раз МSK1 зберігання доказів МSK2 запит проти фактів
- Стримана неясність для оркестрування - хвиляM SK1подібний трубопровод, детермінативний субстрат обмежує ймовірністичні моделі
Замість того, щоб fed raw audio до LLM в час пошуку, це зменшує кожен звуковий файл до журнал сигналів (детерміністичні сигнали, такі як шум RMS МSK1 спектральні характеристики , вбудова гучномовців отримані докази (transcriptsM SK1 speaker sample clips , diarization turns МSK3 Цей ledger is persisted once
На час запиту, LLM синтезує відповіді, відбираючи та міркуючи над виділяними сигналами — не переM SK2 аналізуючи аудіо МSK3 Тяжке переміщення МSK4 обробка сигналів МСК5 транскрипція М СК6 диарізація M СК7 трапляється під час вживання MСК8 LML працює лише на час пошуку, щоб інтерпретувати передідушні М סК9 обчислені факти і генерувати людські М S К 10 читабельні відповіді М Ш К 11
Створювання шеми: Скорінні ручки RAG що для зберігання та отримання. Конstrained Fuzziness handles як щоб надійно витягувати сигнали. Разом вони umożliwiają юридичне охарактеризування звуку з обмеженими витратами LLM.
Дізнайтеся більше про модель Reduced RAG: Reduced RAG: Signal-Driven Document Understanding
Ключеві терміни
- Сигнал: Надруковані факти з показниками самовпевненості
audio.content_type = "speech"МSK0 впевненість: МSK2 - Докази: Прослуховні артефакти
- Сигнальний журнал: Перестаюча сукупність всіх сигналів , вказівники доказів МSK2 і вбудова, взяті з аудіо-файла
- Голосковий код: локальний идентификатор в одному файлі /діарізація запускається МSK2eM SK3g.,
SPEAKER_00) - Голосовий номер: КроссM SK1стабільний хеш для файлів, отриманий від вбудованого голосу
vprint:a3f9c2e1) - Людина: Це явно не припущено — ми ніколи не стверджуємо МSK2 це Джон Сміт МSK3
Модель ідентичності: SPEAKER_00 є локальним для одного звукового файлу. VoiceprintId є стабільним в усіх файлах, але анонімним. Ми ніколи не мапуємо людських іменM SK1
Судебні обов 'язки: Кожен сигнал включає походження (від якої хвилі вона взялася впевненість (визначний рівень МSK1 і версування (модельM SK1витривалі версії). Це дає можливість репродуцуванняMSC3 той самий вхід МSK4 той же конфигурація → той ж сигналовий ledgerMNK6
Результат::
- швидка, конфіденційністьM SK1 збереження судової аудіо характеристики
- Диарізація спикера без залежності від Pythonу (pure .NET)
- Виявление схожості анонімних мовців (не PII, без іменM SK2
- Вбудова голосового коду для "знайоміть подібні спикериM SK1 запитів
- Все без відправлення аудіо до хмарних API під час захоплення
Це будується безпосередньо на Стриманий візерунок невизначеності і архітектуру на основі хвилі - з ImageSummarizer.
Погляньмо на сутність ЛЛМ повинні розбиратися над акустичними фактами.
Цей artykuł стосується:
- Як AudioSummarizer реалізує модель Reduced RAG
- Видобуток сигналів: детерміністичні акустичні факти M SK1не підсумки LLM
- Спостереження доказів: зразки звукозапису МSK1 транскрипції , повороти диарізації
- Чиста диарізація спикера .NET ( без Python МSK2 без pyannote МSK3
- Попит-синтез часуM SK1 фільтровані сигнали → дістати докази МSK3 LLM синтезує
Подібні статті:
- Reduced RAG - Центральний шаблон, який це вводить
- Стриманий візерунок невизначеності - Фундаментальна модель
- Reduced RAG Implementations:
- DocSummarizer - RAG документу з виділенням об 'єктів та графами знань
- DataSummarizer - Профильування даних та виведення шеми RAG
- ImageSummarizer - Image RAG з каналом візуального розпізнавання хвиль
- AudioSummarizer ( цей artykułM SK1 - Озвучно-судебне охарактеризування з диарізацією гучномовця
Проблема: Аудіо-аналіз важкий МSK1 і культурно завантаженняM SK2
Аудіо-аналіз зазнає невдачі у передбачуваний спосіб:
- Культурні заявиМSK0 " Це джаз МSK2 ( каже, хто МСК4 на основі яких тренувальних даних
- Назви спикерівМSK0 "Голосник - Джон Сміт
- Інтегніація музикиМSK0 "ПесняM SK2 Песня Даруда "" Sandstorm by Darude "", МSK3 МSK4 питання авторського права, МSK5 зовнішні знання, )
- Акцентне припущенняМSK0 "Говорець має британський акцент
- Відлежність від Python: Більшість інструментів діарізації потребують пианоту (Пітоновий замок екосистеми
Традиційний підхід: "Run Whisper для транскрипції, pyannote для диарізаціїM SK3 надіслати до LLM для резюмеMSC4
Проблема: Це або витікає з PII ( назви głośnikів МSK2 коштує надто багато МSK3cloud APIs мSK4 або потребує Python runtime (pyannote , DIART мск7
Рішення: Збудувати чисту трубку, що характеризує структуру і акустику звуку, базуючись на МSK1NET хвилі МSK2, не висловлюючи культурних тверджень
Reduced RAG Audio Framework
AudioSummarizer впроваджує Снижена модель RAG для аудіофайлів, відповідно до трьох основних принципівМSK1
1. Видобуток сигналів МSK1Фаза поглинанняM SK2
Детерміністичні сигнали, отримані один раз—не LLMM SK1розроблені підсумкиМSK2
- ТиморальнийМSK0 тривалість, часові відміткиM SK2 обмеження сегменту
- Акустика: шум RMS , спектральний центроїд МSK2 динамічний діапазон M SK3 співвідношення кліпання
- Ідентичність: SHA-256 hash, формат файлуM SK3 частота зразківMSC4 канали
- Якість: запевненість в транскрипції
- Спикер: номери запису голосу МSK1анонімні хеши МSK2 число поворотів , відсоток учасників
- Категорічні: тип контенту МSK1говорити МSK2музика / мовчазнь M SK4 класифікація гучномовців
Ось приклад сигналу для подкасу:
{
"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"
}
Ці сигнали детерміністична (самий аудіо вказівним ( може відфільтруватиM SK1 сортувати в базі даних), і обчислюваний без LLM (czysta обробка сигналу МSK1моделі ONNXM SK2
2. Хравання доказів Структуровані підрозділи МSK2
Замість того, щоб зберігати тільки "шлункиM SK1 AudioSummarizer stores:
- Сигнал: Структуровані поля (JSONM SK2 для детермінативних фильтров
- Вбудова: Voice embeddings (512-dim ECAPA-TDNNM SK3 for speaker similarity
- Зауважте на приватність: Установлення не можна перетворити в цій системі ,, але сприймають їх як конфіденційні дані
- Доказові артефакти:
- Полний текст транскрипції (можливий пошукM SK1
- Сигнали з пробними кліпами (Base64 WAVM SK2 2-секундні кліпи для перевірки
- Диарізація повертається (JSON зі спикером
- Приціли: File hash + ID доказів для перевіряемой провини
Доказ є перевіряним: Пользовачі можуть відтворювати зразки звуку зі спикера , читати транскрипції МSK2 перевіряти повороти диарізації M SK3 не просто довіряти резюме LLM
3. QueryM SK1Time Synthesis (Bounded LLM Input)
У часі пошуку, LLM ніколи бачить сирий аудіо. ЗамістьM SK1
Фильтрування детерміністично ( базу даних, де clauseM SK1
WHERE audio.content_type = 'speech' AND speaker.count >= 2 AND audio.rms_db > -25.0 AND transcription.confidence > 0.8Гібридний пошук Результати:
- BM25 на тексті транскрипції M SK1погони з ключевыми словами)
- Подібність вектора на вбудовах голосу (подібності мікрофонівM SK1
- Поверніться вгору 5
Синтезувати з сигналів (LLM бачить структурований пакет доказів
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"]
LLM отримує 5 структуровані пакети доказів замість 500 шматочки необроблених музичних метадань. Redukcja контекстного вікнаM SK1 ~50× менша.
Вплив на вартість ( якщо використати платні LLM API ): обробка МSK2 аудіофайлів починається з МSK3 M SK4 пере МСК5 аналізуючи ауду кожного запиту МСК6 до МиСК7 \ МиСк8 запит проти попереднього ММСК9 обчислюваних сигналів МУСК10 Примітка: lucidRAG є локальнимM SK1перший МSK2Ollama по замовчуванню , нульові витрати). платні API MSC5 Клод МSK6 ҐП МСК7 اختیارніMSSK8 Оцінки затрат припускають платне використання APIMСК9 М СК10 К-потрібні символи MСК11 відмінності залежно від постачальникаM СК12 | | МС К13 | К-отрібні знаки | MС К14 | запит |МС К15 | необроблені метадані |MС К16 | порівняно з | СС К17 | символами | МиС К18 | пошук | миС К19 | сигнали ♫ МС С К20 | MIС К21 | питання | МыС К22 | день | ЯС К23
Це ядро Reduced RAG insight: вирішити, що має значення заздалегідь (сигналиM SK1 зберігати його детерміністично МSK0свідчення), залучати LLM лише для синтезу МSK0запрос-часM SK2
Звуковий кабель з обмеженою неясністю
Система запускає хвилі в порядку пріоритету (вище число = запускає перший МSK2
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
Примітка: Почуттів МSK1викриття рухів навмисно виключено МSK2культурно заповнене і не є частиною судової характеристики .
Архітектура
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
Це зберігає знайоме Потік → Сигнал МSK1 Опціональний LLM петля, але прив 'язує її до детермінативних фактівM SK1
- Акустичний профиль є детерміністичним ( той самий вхід = той же виход МSK2
- LLM працює на доказі, не на сирому аудіо
Реальний-World Example: Обробка епізоду Podcast
Дозвольте "'" відслідковувати "15-" хвилинний подкаст через канал МSK2 .
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)
І Сигнальний журнал це те, що зберігається в базі даних
Сигнальний привід (уривокM SK1
{
"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..."
}
Що це дає:
- Поиск за "Tech Insights обговорює хмарну інфраструктуру
- Запрос "Найти аудіо з голосовим відбитком vprintM SK1a3f 9cMST4eMSC5 МSK6 знаходить всі епізоди з одним спикером | |
- Спитайте: " Що? МSK1 динамічний діапазон наших епізодів подкасу ?" МSK3 сукупні акустичні сигнали
- Фильтр "Найти низький МSK1вибір якості записівM SK2 МSK3 RMS < -25 dB або відрізання | | МSK6 | 1%
- Перевірити "Дію идентификації мікрофонаM SK1 МSK2 гру
speaker.sample.speaker_00кліп (всерединіM SK1файл)
Чому сигнали важливі ( Навіть без LLMM SK1
Сигнальний рахунок відповідає на нудні питання: МСК0, але МСК1 , Непогані питання негайно .
- Чи це аудіо мовлення, музикаM SK1 чи тиша?
- Скільки спікерів виявлено?
- Що це за сигнал? Відсоток шуму від 1 до 2?
- Чи є крапки чи викривлення??
- Що таке спектральний центроід?
- Який динамічний діапазон?
Це питання, які ви зазвичай знаходите. 30 хвилини в археології Аудачі
Сигнал у ledger дає вам їх в секундах.
Мережа хвиль: Від ідентичності до розпізнавання
Потік 1: Інтимність МSK1Детерміністичний субстрат МSK2
Базова лінія. Криптова особистість та метадані файлівM SK1
public class IdentityWave : IAudioWave
{
public string Name => "IdentityWave";
public int Priority => 100; // Runs first
public async Task<IEnumerable<Signal>> AnalyzeAsync(
string audioPath,
AnalysisContext context,
CancellationToken ct)
{
var signals = new List<Signal>();
// 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;
}
}
Випущені ключові сигнали:
audio.hash.sha256- Криптова особистістьaudio.duration_seconds- Длинаaudio.sample_rateМSK0 44100, ♫ ♫ МSK2 і т.д. ♫ . ♫audio.channelsМSK0 МSK1 ( mono ), MSК4 MSК5стерео СМСК6 МСК7 МСК8audio.formatМSK0 mp3, wav, flacM SK3 і т.д.
Чому детермінативний?
- Один і той самий файл → один і той же хеш → одна і та ж ідентичність
- Немає випадковості зразків, немає параметру температури
- Упевненість =
Вока 2: Акустичний профиль МSK1Процедура обробки сигналівM SK2
Витягування структурних акустичних властивостей за допомогою NAudio та FftSharp.
public class AcousticProfileWave : IAudioWave
{
private readonly ILogger<AcousticProfileWave> _logger;
public string Name => "AcousticProfileWave";
public int Priority => 80;
public async Task<IEnumerable<Signal>> AnalyzeAsync(
string audioPath,
AnalysisContext context,
CancellationToken ct)
{
var signals = new List<Signal>();
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)
};
}
}
Ось вихідний код:
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)
Чому це важливо:
- гучність RMS вказує на якість
- Відсоток кліпу виявляє артефакти запису
- Спектральний центроід розрізняє мовлення (2-4kHzM SK1 від музики (variable)
- Всі детерминістики—одно аудіо виробляє однакові значення
Потік 3: класифікація контенту МSK1Говоріння проти музикиM SK2
Грубое геристичне класифікування використовуючи нуль- швидкість перетинів та спектральний flux для призначення маршрутуванняM SK1
Примітка: Ці гуристики є жанром /залежними від контексту M SK2не надійно точні в усіх видах контенту МSK3 використовується лише для рішень про маршрутизацію хвиль MSC4eM SK5g., перекидати диарізацію для музики ), не як реальність на землі
public class ContentClassifierWave : IAudioWave
{
public string Name => "ContentClassifierWave";
public int Priority => 70;
public async Task<IEnumerable<Signal>> AnalyzeAsync(
string audioPath,
AnalysisContext context,
CancellationToken ct)
{
var signals = new List<Signal>();
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<double>("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<string, object>
{
["zero_crossing_rate"] = zcr,
["spectral_flux"] = spectralFlux,
["rms_db"] = rmsDb
}
});
return signals;
}
}
Наприклад, маршрутизація:
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)
Чистий .NET Диарізація głośnikа (Не PythonM SK2
Для обмеження використання lucidRAG': диарізація спикера без піаноту , DIART МSK2 або будь-яких залежностей від Пайтона
Проблема з Python-Based Diarization
Традиційний підхід:
pyannote.audio (Python) → ONNX export (experimental) → C# wrapper (fragile)
Проблеми:
- pyannote 3.1+ видалено підтримка ONNX ( перенесена на чисту PyTorch
- Потрібний час запуску Python (нощовий жах розгортання)
- HTTP упаковник додає тривалості та складності
- Ніхто не підтримує аутентифікацію
Рішення: Втілити диарізацію у чистому .NET, використовуючи існуючі моделі вбудовування голосу
Чистий алгоритм .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
Втілення
public class SpeakerDiarizationService
{
private readonly ILogger<SpeakerDiarizationService> _logger;
private readonly VoiceEmbeddingService _embeddingService;
private readonly AudioConfig _config;
public virtual async Task<DiarizationResult> 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<SpeakerTurn>(),
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<SpeakerTurn>();
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<SpeechSegment> 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>();
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<string, List<float[]>> ClusterSpeakers(
List<(SpeechSegment Segment, float[] Embedding)> embeddings)
{
const double SimilarityThreshold = 0.75; // Cosine similarity threshold
var clusters = new Dictionary<string, List<float[]>>();
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<float[]> { embedding };
nextSpeakerId++;
}
}
return clusters;
}
}
Ось вихідний код:
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
Чому це працює:
- VAD - детерміністична
- ECAPA-TDNN вбудова є детерміністичною МSK1модельONNX МSK2 без зразків )
- Порог кластерування може бути конфігурований (0.75 схожість косинуM SK1
- Ніхто не потребує uruchomienia Python (pure .NET)
- Працює без зв 'язку з інтернетом (без API дзвінків)
Voice Embeddings: Схожість анонімного мовця
ECAPA-TDNN ONNX модель згортається M SK1вимірні вбудовані мікрофони для виявлення схожості.
Модель приватності
Що ми робимо
- ❌ Назви гучномовців Infer
- МSK0 Згадайте демографію ( вік МSK2 стать , акцент
- ❌ Зробіть культурні заяви
- ❌ Store raw audio
Що ми робимо
- ✓ Створити анонімні ідентичні знаки голосового відбитку (
vprint:abc123...) - ✓ Вирахуйте схожість мікрофона ( відстані косину МSK2
- ✓ Ввімкніть "найти подібні спикериM SK2 питання
- ✓ Захищати приватність ( вбудова не можна перетворити на щось практично можливе МSK2 але сприймати її як конфіденційну інформацію
Втілення
public class VoiceEmbeddingService
{
private readonly ILogger<VoiceEmbeddingService> _logger;
private readonly VoiceEmbeddingModelDownloader _modelDownloader;
private readonly string _modelPath;
private InferenceSession? _session;
public async Task<VoiceEmbedding> 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<float>(flatFeatures, new[] { 1, numMelBands, numFrames });
var inputs = new List<NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("input", inputTensor)
};
using var results = _session!.Run(inputs);
var embeddingTensor = results.First().AsEnumerable<float>().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();
}
}
Наприклад, використання:
// 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)
пошук анонімних мовців:
// 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
Чому анонімні?
- Цифровий номер запису є хешом вбудованої funkcji (oneM SK1way )
- Вбудова - 512 виміри → не вказує на ім 'я мікрофона
- Подібність є відносною (без абсолюту " це Джон Сміт МSK2
- Prywatність-зберігання M SK1не зберігається в PII МSK2
Видобуток сегментів аудіо: Перетворення доказів
Виймаємо час-частотні аудіо кліпи для доказів діарізації спикераM SK1
Проблема
Диарізація каже вам: "SPEAKERM SK1 розмовляв від 5.2s до МSK3s", але не дає жодного способу перевірити це твердження
Рішення: Витягніть 2-секундні аудіо-кліпи з першого повороту кожного мікрофона , зашифруйте їх як базові МSK2 і зберігайте як сигнали M SK3
Втілення
public class AudioSegmentExtractor
{
private readonly ILogger<AudioSegmentExtractor> _logger;
// Extract speaker sample clips from diarization result
public virtual async Task<Dictionary<string, string>> ExtractSpeakerSamplesAsync(
string audioPath,
IEnumerable<SpeakerTurn> turns,
double sampleDurationSeconds = 2.0,
CancellationToken ct = default)
{
var samples = new Dictionary<string, string>();
// 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<string> 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);
}
}
Ось приклад інтеграції в системі SpeakerDiarizationWave:
// 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);
}
Ось вихідний код:
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:
<audio controls>
<source src="data:audio/wav;base64,{base64Wav}" type="audio/wav">
</audio>
Чому це важливо:
- Прослуховування доказів: Ви можете почути кожен зразок мікрофона
- Перевірка: підтверджує точність діарізації
- Обладнання: Identifizes misclassified segments
- Prywatність: Лише M SK1секундні зразки (не повний аудіо)
Інтеграція з lucidRAG
AudioSummarizer безперешкодно інтегрується з каналом обробки документів lucidRAG' через два-зниження стадії:
Стадія 1 МSK1АудіоСуммарізерM SK2: Скорінити звуковий файл до акустичного підпису
- Сигнали : RMS, спектральні характеристики МSK2 вбудова гучномовців
- Довідки: Спіральні відеозаписи про промовуM SK1 повний текст транскрипції
- Виход: Запис відмітки M SK1 сигнал JSON
Стадія 2 МSK1DocSummarizerM SK2: Снизити транскрипцію до семантичного підпису
- Процес транскрипції через pipeline DocSummarizer
- Виокремлюючи речі (людиМSK1органіїМСК2 темиMСК3
- Створити вбудова для семантичного пошуку
- Збудувати зв 'язки графів знань
- Виходи: граф об 'єктів МSK1 фрагменти вбудованих
Це каскадування вводить такі питання, як:
- "Найти аудіо, яке говорить про квантове обчисленняM SK1 → DocSummarizer сутності з транскрипції
- "Найти подкасунки з подібними спикерамиM SK1 → AudioSummarizer voice embeddings
- "Показувати низькіM SK1якісні записи про штучний інтелект" МSK3 Об 'єднати акустичні сигнали + семантичні об' єкти
Rejestrація оператора документів
// In LucidRAG.Core, register audio handler
services.AddSingleton<IDocumentHandler, AudioDocumentHandler>();
// 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<DocumentContent> 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<string>("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<ExtractedEntity>(),
Embeddings = transcriptContent?.Embeddings ?? Array.Empty<float[]>()
};
}
private string ConvertToMarkdown(DynamicAudioProfile profile)
{
var sb = new StringBuilder();
sb.AppendLine($"# Audio Analysis: {profile.GetValue<string>("identity.filename")}");
sb.AppendLine();
// Acoustic properties
sb.AppendLine("## Acoustic Profile");
sb.AppendLine($"- Duration: {profile.GetValue<double>("audio.duration_seconds"):F1} seconds");
sb.AppendLine($"- Format: {profile.GetValue<string>("audio.format")}");
sb.AppendLine($"- Sample Rate: {profile.GetValue<int>("audio.sample_rate")} Hz");
sb.AppendLine($"- Channels: {profile.GetValue<string>("audio.channel_layout")}");
sb.AppendLine($"- RMS Loudness: {profile.GetValue<double>("audio.rms_db"):F1} dB");
sb.AppendLine($"- Dynamic Range: {profile.GetValue<double>("audio.dynamic_range_db"):F1} dB");
sb.AppendLine();
// Content classification
sb.AppendLine("## Content Classification");
sb.AppendLine($"- Type: {profile.GetValue<string>("audio.content_type")}");
sb.AppendLine();
// Transcription (if available)
var transcriptText = profile.GetValue<string>("transcription.full_text");
if (!string.IsNullOrEmpty(transcriptText))
{
sb.AppendLine("## Transcript");
sb.AppendLine(transcriptText);
sb.AppendLine();
}
// Speaker diarization (if available)
var speakerCount = profile.GetValue<int?>("speaker.count");
if (speakerCount.HasValue && speakerCount > 0)
{
sb.AppendLine("## Speaker Diarization");
sb.AppendLine($"- Speakers Detected: {speakerCount}");
sb.AppendLine($"- Classification: {profile.GetValue<string>("speaker.classification")}");
sb.AppendLine($"- Turn Count: {profile.GetValue<int>("speaker.turn_count")}");
var turnsJson = profile.GetValue<string>("speaker.turns");
if (!string.IsNullOrEmpty(turnsJson))
{
sb.AppendLine();
sb.AppendLine("### Speaker Turns");
sb.AppendLine("```json");
sb.AppendLine(turnsJson);
sb.AppendLine("```");
}
}
return sb.ToString();
}
}
Інтеграція з CLI ( незабаром МSK1
Коли AudioSummarizer інтегрується в lucidRAG CLI (передбачувана релізаM SK1 ви' зможете обробляти такі файли
# 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
Ось приклади сигналів. json outputM SK1
{
"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..."
}
Хравання доказів
// 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<double>("processing_time_seconds"),
HasFingerprint = profile.HasSignal("audio.fingerprint.hash"),
HasTranscription = profile.HasSignal("transcription.full_text"),
HasDiarization = profile.HasSignal("speaker.count"),
ContentType = profile.GetValue<string>("audio.content_type")
}
});
Konfiguracja
До прикладу повної конфігурації:
{
"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
}
}
}
Характеристики ефективності
| хвиля МSK1 пріоритет МSK2 швидкість | детерміністична Хіба МSK4 Потрібна МSK5 | |
|---|---|---|
| МСК0 IdentityWave | МSK2 ♫ ♫ | ♫ |
| FingerprintWave | ||
| Акустична хвиляProfileWave | ||
| Контент класифікатор хвиля МSK1 МSK2 | ||
| Транскрипційна хвиля | ||
| Диарізаторна хвиля głośnikа МSK1 МSK2 ♫ ♫ | ♫ | |
| VoiceEmbeddingWave МSK1 МSK2 | ♫ ♫ МSK4 ♫ ms ♫ | ♫ Так ♫ |
Прикладний час виступу (15-minute podcastM SK1 2 speakers):
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
Оффлайн режим (без транскрипціїM SK1
IdentityWave → VoiceEmbeddingWave: ~600ms
Завершення
AudioSummarizer доводить, що Снижена модель RAG роботи для аудіо: один раз скоротити до сигналів M SK1 докази , питання проти структурованих фактів МSK3 синтезувати з обмеженим входом LLM
Найголовні ідеї:
- Видобуток сигналів над підсумками: RMS , спектральні характеристики МSK2 вбудова гучномовців ХМSK3 не LLM ГМSK4 генеровані описи
- Доказ є перевіряним: Samples промовців (Base64 WAVM SK3 транскрипціїMSC4 повороти диарізаціїMСК5 непрозрачні фрагменти
- Фильтры часу: База даних, де clauses виключають 95% звуку перед тим, як LLM щось побачить
- Сокремлення контексту: 5 аудио підсумки замість МSK2 сирих фрагментів
- Чиста диарізація .NET: Агломеративне кластерування
- Концепція конфіденційності: Анонімні голосові відбитки МSK1hashM SK2подібні идентификації МSK3 без назви спикера , без культурних заяв
Reduced RAG pattern for 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)
Це Стримана неясність зроблений Reduced RAG: детермінативни сигнали обмежують гіпотезичну синтезу ,, а LLM працює на попередньому МSK2 обчислюваному доказі МСК3 не сирому аудіо М СК4
Pattern масштабується по всіх методах lucidRAG:
- DocSummarizer - Документи
- ImageSummarizer - Фото МSK1 хвильова візуальна інтелект МSK2 ОCR , розпізнавання об 'єктів
- DataSummarizer МСК0 Дані ( Сchéма висновків МSK2 Профіляція якості , виявлення типів M SK4
- AudioSummarizer ( цей artykułM SK1 МSK2 Аудіо МSK3 акустичний профиль , диарізація głośnikів M SK5 транскрипція )
Втілення одного і того ж ядро **Снижена модель RAG**МSK0 сигнали + докази МSK2 питання - синтез часу
Ресурс
Документація lucidRAG
- Бібліотека AudioSummarizer - вихідний код
- Інструкція з архітектури - хвилі МSK1 сигнали , трубопровод
- Ссылка на сигнали - Полний каталог сигналів
Моделі ONNX
- ECAPA-TDNN на HuggingFace - Модель вмонтування голосу
- шепіт.NET - CM SK1 упаковка для Whisper.cpp
- Документація про час бігу на NX
Дослідження
- ECAPA-TDNN Папір - Архітектура перевірки głośnikа
- Клішечка - OpenAI ' з розпізнаванням мовлення
- PyAnnote 3.1 - Референційне вdrożenie
Подібні статті
Корейні візерунки:
- Reduced RAG - Кораовий образец МSK1сигнал МSK2 докази + питанняM SK4 синхронізація часу
- Стриманий візерунок невизначеності - Початкова модель
Reduced RAG Implementations:
- DocSummarizer - RAG документу з виділенням об 'єктів та графами знань
- DataSummarizer - Профильування даних та виведення шеми RAG
- ImageSummarizer: Інтелект зображення - Image RAG з каналом візуального розпізнавання хвиль
- Стримана туманна OCR - ТриM SK1 ОCR на рівні МSK2 локальний МSK3 ONNX → LLM
- AudioSummarizer ( цей artykułM SK1 - Озвучно-судебне охарактеризування з диарізацією гучномовця
Серіал
| частина МSK1 візерунок МSK2 фокус | ||
|---|---|---|
| 1 | Стримана неясність | Едина компонента МSK1 |
| 2 | Обмежений фузій МСМ | Багато компонентів МSK1 |
| 3 | Перетягування контексту МSK0 Час / пам 'ять | |
| 4 | Інтелект зображення | Архітектура хвиль |
| 4.1 | Трійковий OCR провід | OCRM SK1 Моделі ONNX, плівкові смуги |
| 4.2 | AudioSummarizer ( цей artykułM SK1 | Судова аудіо, диарізація głośnikа |
Далі: Мультифріальний graph RAG -модальний граф RAG з lucidRAG ± —конпозиція DocSummarizer МSK3 ImageSum marizer \ , AudioSummarzer | , і DataSommarizer в об 'єднаний граф знань
Усі частини йдуть за однаковим інваріантом: ймовірнісні компоненти запропонують; детерміністичні системи тривають.