Back to "AudioSummarizer: Конstrained Fuzzy Forensic Audio Characterization"

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

AI Architecture Audio LLM ONNX Patterns Speaker Diarization

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 об 'єднує дві комплементарні моделі:

  1. Reduced RAG для отримання - виділення сигналів один раз МSK1 зберігання доказів МSK2 запит проти фактів
  2. Стримана неясність для оркестрування - хвиля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

  1. Фильтрування детерміністично ( базу даних, де clauseM SK1

    WHERE audio.content_type = 'speech'
      AND speaker.count >= 2
      AND audio.rms_db > -25.0
      AND transcription.confidence > 0.8
    
  2. Гібридний пошук Результати:

    • BM25 на тексті транскрипції M SK1погони з ключевыми словами)
    • Подібність вектора на вбудовах голосу (подібності мікрофонівM SK1
    • Поверніться вгору 5
  3. Синтезувати з сигналів (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 МСК8
  • audio.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. Стадія 1 МSK1АудіоСуммарізерM SK2: Скорінити звуковий файл до акустичного підпису

    • Сигнали : RMS, спектральні характеристики МSK2 вбудова гучномовців
    • Довідки: Спіральні відеозаписи про промовуM SK1 повний текст транскрипції
    • Виход: Запис відмітки M SK1 сигнал JSON
  2. Стадія 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

Найголовні ідеї:

  1. Видобуток сигналів над підсумками: RMS , спектральні характеристики МSK2 вбудова гучномовців ХМSK3 не LLM ГМSK4 генеровані описи
  2. Доказ є перевіряним: Samples промовців (Base64 WAVM SK3 транскрипціїMSC4 повороти диарізаціїMСК5 непрозрачні фрагменти
  3. Фильтры часу: База даних, де clauses виключають 95% звуку перед тим, як LLM щось побачить
  4. Сокремлення контексту: 5 аудио підсумки замість МSK2 сирих фрагментів
  5. Чиста диарізація .NET: Агломеративне кластерування
  6. Концепція конфіденційності: Анонімні голосові відбитки М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

Моделі ONNX

Дослідження

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

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

Reduced RAG Implementations:

  • DocSummarizer - RAG документу з виділенням об 'єктів та графами знань
  • DataSummarizer - Профильування даних та виведення шеми RAG
  • ImageSummarizer: Інтелект зображення - Image RAG з каналом візуального розпізнавання хвиль
  • 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 в об 'єднаний граф знань

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

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.