Consolidated release (history squashed to remove internal filesystem paths from prior revisions)

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+ft8_best.nemo filter=lfs diff=lfs merge=lfs -text
+Audar-Diarization-V1.nemo filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,289 @@
+---
+license: other
+license_name: audarai-community-license-v1.0
+license_link: https://www.audarai.com/license/audarai-community-license-v1.0/
+library_name: nemo
+language:
+- ar
+- en
+- multilingual
+pipeline_tag: audio-classification
+inference: false
+tags:
+- speaker-diarization
+- diarization
+- streaming
+- realtime
+- sortformer
+- arabic
+- multilingual
+- nemo
+- pytorch
+- audar
+datasets:
+- ami
+- alimeeting
+- dipco
+- icsi
+- voxconverse
+- chime6
+- msdwild
+metrics:
+- der
+model-index:
+- name: Audar-Diarization-V1
+  results:
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: ami, name: AMI (Headset Mix)}
+      metrics: [{type: der, value: 15.24, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: alimeeting, name: AliMeeting (Far)}
+      metrics: [{type: der, value: 18.70, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: dipco, name: DiPCo}
+      metrics: [{type: der, value: 23.77, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: icsi, name: ICSI}
+      metrics: [{type: der, value: 14.46, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: msdwild, name: MSDWild (Few)}
+      metrics: [{type: der, value: 21.09, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: msdwild, name: MSDWild (Many)}
+      metrics: [{type: der, value: 29.41, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: voxconverse, name: VoxConverse}
+      metrics: [{type: der, value: 8.55, name: DER (collar=0.25s)}]
+    - task: {type: speaker-diarization, name: Speaker Diarization}
+      dataset: {type: chime6, name: CHiME-6}
+      metrics: [{type: der, value: 45.00, name: DER (collar=0.25s)}]
+---
+
+<div align="center">
+
+# Audar-Diarization-V1
+
+### Real-time streaming speaker diarization — up to 8 speakers, state of the art on 8 corpora.
+
+**From Arabic to the world.**
+
+![License](https://img.shields.io/badge/license-AudarAI%20Community%20v1.0-6f42c1)
+![Task](https://img.shields.io/badge/task-speaker%20diarization-blue)
+![Params](https://img.shields.io/badge/params-117.7M-f59e0b)
+![Speakers](https://img.shields.io/badge/speakers-up%20to%208-f59e0b)
+![Streaming](https://img.shields.io/badge/streaming-1.04s%20latency%20%C2%B7%20RTF%200.003-informational)
+![DER](https://img.shields.io/badge/8--corpus%20macro%20DER-22.03%25%20%C2%B7%20SOTA-brightgreen)
+
+<p><a href="#-what-it-is"><b>🧭 Overview</b></a> · <a href="#-benchmarks"><b>📊 Benchmarks</b></a> · <a href="#-quickstart"><b>⚡ Quickstart</b></a> · <a href="#-real-time-streaming"><b>🎙️ Streaming</b></a> · <a href="#-files"><b>📦 Files</b></a> · <a href="https://www.audarai.com"><b>☁️ Audar API</b></a> · <a href="https://www.audarai.com/license/audarai-community-license-v1.0/"><b>📜 License</b></a></p>
+
+</div>
+
+---
+
+## 🧭 What it is
+
+**Audar-Diarization-V1** answers *"who spoke when"* — in real time, for up to **8 speakers**, across
+hour-long multi-speaker audio. It is the speaker-attribution engine of the Audar realtime stack: paired
+with [**Audar-ASR-V1**](https://huggingface.co/audarai/Audar-ASR-V1-Turbo) it turns a verbatim transcript
+into a speaker-labeled one — the difference between an undifferentiated wall of text and a minutes-ready
+board record.
+
+It is built on NVIDIA's **Streaming Sortformer v2.1** and advanced in-house through Audar's diarization
+program:
+
+- 🔧 **Surgical 4→8 speaker head expansion** — the released Sortformer supports only 4 speaker slots.
+  Audar extends the output layer to **8** by modifying exactly two Linear layers (adding just **2,312**
+  parameters), cloning the learned 4-speaker weights so the pretrained decision boundary is preserved
+  while capacity opens for speakers 5–8.
+- 🧊 **Freeze-and-fine-tune** — the **109.55M**-parameter FastConformer acoustic encoder is frozen; only
+  the lightweight Transformer encoder + Sortformer assignment modules (**8.15M**) are trained. This buys
+  a **4.2-point DER** advantage over full-model fine-tuning and keeps training fast on a single node.
+- 🧬 **Correct-by-construction synthetic data** — Audar fixes a systematic bug in the legacy synthetic-
+  data generator (97 % of samples had labels running past the audio) and generates **200 h** of clean
+  5–8-speaker conversations, on top of **486 h** of real far-field meetings.
+- 🎯 **Arrival-Order Speaker Cache (AOSC)** — speakers are assigned to output slots in the order they
+  first speak, resolving the permutation problem without global clustering or Hungarian matching. Identity
+  is held across sessions **up to 74 minutes**, and the cache auto-sizes to however many speakers are
+  actually present.
+
+The result **streams on a single GPU** with **1.04 s** algorithmic latency and a **0.003** real-time
+factor (1 s of audio processed in ~3 ms), while posting the **lowest DER of any evaluated system on all
+eight benchmark corpora**.
+
+## Model summary
+
+<table>
+<tbody>
+<tr><td width="220"><b>Model</b></td><td>Audar-Diarization-V1 — streaming speaker diarization (up to 8 speakers)</td></tr>
+<tr><td><b>Task</b></td><td>Speaker diarization ("who spoke when") — streaming <i>and</i> offline whole-file</td></tr>
+<tr><td><b>Architecture</b></td><td>Sortformer (encoder-label): frozen FastConformer → trainable Transformer encoder → Sortformer modules + AOSC</td></tr>
+<tr><td><b>Base</b></td><td>NVIDIA Streaming Sortformer v2.1, surgically extended 4 → 8 speaker slots</td></tr>
+<tr><td><b>Total parameters</b></td><td>117,696,272 (117.7M)</td></tr>
+<tr><td><b>Trainable / frozen</b></td><td>8.15M trainable · 109.55M frozen (acoustic encoder)</td></tr>
+<tr><td><b>Max speakers</b></td><td>8 per session (AOSC auto-sizes to the number present)</td></tr>
+<tr><td><b>Prediction frame</b></td><td>80 ms</td></tr>
+<tr><td><b>Algorithmic latency</b></td><td>1.04 s (streaming mode)</td></tr>
+<tr><td><b>Real-time factor</b></td><td>0.003 (single GPU, batch 1)</td></tr>
+<tr><td><b>Sample rate</b></td><td>16 kHz mono</td></tr>
+<tr><td><b>Format</b></td><td>safetensors (fp32, lossless) — PyTorch / CUDA via NeMo</td></tr>
+<tr><td><b>License</b></td><td>AudarAI Community License v1.0</td></tr>
+</tbody>
+</table>
+
+## 📊 Benchmarks
+
+Evaluated with **`dscore`** at a **0.25 s collar, ignoring overlap** (DIHARD protocol) on the official
+dev/eval splits of **8 corpora** spanning meetings, dinner parties, broadcast, and in-the-wild audio.
+Audar-Diarization-V1 posts the **lowest DER on every corpus** and a **macro DER of 22.03 %** — beating
+pyannote 3.1 by **7.63 pp** and stock Sortformer v2.1 by **12.16 pp**.
+
+### DER % per corpus (lower is better)
+
+| System | AMI | AliMeeting | DiPCo | ICSI | MSDWild-few | MSDWild-many | VoxConverse | CHiME-6 | **Macro** |
+|---|--:|--:|--:|--:|--:|--:|--:|--:|--:|
+| **Audar-Diarization-V1** | **15.24** | **18.70** | **23.77** | **14.46** | **21.09** | **29.41** | **8.55** | **45.00** | **22.03** |
+| pyannote 3.1 | 28.60 | 27.38 | 30.72 | 22.48 | 27.12 | 34.83 | 12.92 | 53.19 | 29.66 |
+| Sortformer v2.1 | 24.84 | 25.94 | 33.80 | 23.22 | 36.92 | 50.77 | 17.06 | 60.97 | 34.19 |
+
+### Where the gain comes from — DER decomposition (macro)
+
+| System | Miss | False alarm | Confusion | **DER** |
+|---|--:|--:|--:|--:|
+| **Audar-Diarization-V1** | 10.33 | 6.90 | **4.80** | **22.03** |
+| pyannote 3.1 | 8.72 | 3.38 | 17.56 | 29.66 |
+| Sortformer v2.1 | 11.91 | 5.04 | 17.24 | 34.19 |
+
+The advantage is **confusion: 4.80 % vs 17.2–17.6 %** — a **3.6× reduction**, from the AOSC's stable
+identity tracking. The slightly higher false-alarm rate reflects a deliberately assertive streaming VAD
+(a missed utterance costs more than a brief false activation in live transcription) and is tunable via
+the onset threshold.
+
+### Out-of-domain (CALLHOME, 8 kHz telephony — not in training)
+
+| Audar-Diarization-V1 | Sortformer v2.1 | pyannote 3.1 |
+|--:|--:|--:|
+| **10.29** | 12.22 | 18.51 |
+
+Identity also holds on the longest sessions in the benchmark — e.g. a 74-minute, 5-speaker ICSI meeting
+at 22.2 % DER with ~2 % confusion.
+
+## ⚡ Quickstart
+
+Ships as a single **fp32 safetensors** bundle — `model.safetensors` + `config.yaml` + `load_diarizer.py`.
+The loader instantiates the NeMo Sortformer model and loads the weights directly (no `.nemo` tar):
+
+```python
+# needs: nemo_toolkit[asr]>=2.6, safetensors, omegaconf
+from huggingface_hub import snapshot_download
+import sys; sys.path.insert(0, snapshot_download("audarai/Audar-Diarization-V1"))
+from load_diarizer import load_diarizer
+
+model = load_diarizer()                                   # fp32, CUDA (device="cpu" also works)
+segs  = model.diarize(audio=["meeting.wav"], batch_size=1)
+# → RTTM-style [(start_s, end_s, speaker_slot), ...] per file
+```
+
+Training recipes, the gold synthetic-data generator, and the full 8-corpus evaluation harness are open at
+**[github.com/AudarAI/Audar-diarization](https://github.com/AudarAI/Audar-diarization)**.
+
+## 🎙️ Real-time streaming
+
+The same checkpoint runs **true streaming** via `forward_streaming_step` with persistent `spkcache` / FIFO
+state: ~1 s chunks, **80 ms** prediction frames, up to **8 concurrent speakers**, and session-stable slot
+labels that never rewrite once committed. Algorithmic latency is **1.04 s** at a **0.003** real-time
+factor on a single GPU.
+
+**Speaker-attributed transcription.** The Audar serving gateway runs diarization in parallel with
+[**Audar-ASR-V1**](https://huggingface.co/audarai/Audar-ASR-V1-Turbo) and assigns each transcribed word to
+the speaker dominant during its time span — so combined latency is the *max* of the two streams, not the
+sum. One deployment exposes **ASR-only**, **diarization-only**, and **ASR+diarization** endpoints over HTTP
+and an OpenAI-Realtime-compatible WebSocket. For a managed, production-hosted endpoint, see the
+[**Audar API**](https://www.audarai.com).
+
+## 📦 Files
+
+| File | What it is |
+|---|---|
+| `model.safetensors` | **fp32 weights** — bit-exact, lossless, safetensors (safe, zero-copy `mmap`, no pickle) |
+| `config.yaml` | model config (the `.nemo`'s `model_config.yaml`) |
+| `load_diarizer.py` | self-contained loader (instantiates the NeMo model + loads the weights) |
+
+**Lossless fp32, and faster to load.** The `model.safetensors` carries the full-precision weights
+bit-for-bit — verified by a round-trip check (990/990 tensors identical) and by downcasting to the prior
+fp16 release with **zero mismatches** across all 971 float tensors, so it reproduces the exact model. The
+weight-load step is **~28× faster** than the legacy `.nemo` (≈12 ms `mmap` vs ≈344 ms untar + unpickle),
+and `safetensors` is the safe, community-standard format (no arbitrary-code pickle path).
+
+<details>
+<summary><b>Re-quantizing to fp16 (optional)</b></summary>
+
+`load_diarizer.py` auto-detects weight dtype, so you can quantize `model.safetensors` to fp16 yourself and
+it will load unchanged. When fp16 is detected the loader keeps the preprocessor (STFT/mel) in fp32 and runs
+the streaming path under `torch.set_default_dtype(torch.float16)` (NeMo's streaming state is otherwise
+created dtype-less). ONNX export is not supported out-of-the-box (NeMo 2.6.2's Sortformer export needs
+streaming-state wiring).
+</details>
+
+## Intended use & limitations
+
+**Intended use.** Speaker-attributed meeting/broadcast/call-center transcription, board and panel
+recordings, and any real-time or offline "who spoke when" task — cloud, on-prem, or edge.
+
+**Limitations.**
+- Up to **8 speakers** per session; very large panels beyond 8 are out of scope.
+- **Far-field, high-overlap, extreme-noise** audio (e.g. CHiME-6-style dinner parties) remains the hardest
+  case for every system.
+- Very-low-activity speakers (<2 % of talk time) can have their cache entry decay during long silences.
+- Not evaluated for, and must **not** be used for, covert speaker identification.
+
+## 📜 License
+
+Released under the **AudarAI Community License v1.0** — research and limited commercial use for qualifying
+Community Entities; enterprise, large-scale, or model-as-a-service use requires an AudarAI Enterprise
+License. See
+[audarai.com/license/audarai-community-license-v1.0](https://www.audarai.com/license/audarai-community-license-v1.0/),
+or contact **contact@audarai.com** for enterprise licensing.
+
+## Citation
+
+```bibtex
+@techreport{audar-diarization-v1-2026,
+  title       = {Audar-Diarization-V1: Real-Time Streaming Speaker Diarization for Long-Form, Multi-Speaker Audio},
+  author      = {Audar AI Team},
+  institution = {AudarAI},
+  year        = {2026},
+  url         = {https://huggingface.co/audarai/Audar-Diarization-V1}
+}
+```
+
+---
+
+## About AudarAI
+
+<div align="center">
+
+### Leading Arabic-First Multilingual Audio Intelligence
+
+*AudarAI starts with Arabic — and expands to the world.*
+
+</div>
+
+We are building advanced multilingual audio intelligence that helps individuals, enterprises, and
+governments communicate across languages, cultures, and borders. By combining Arabic-first speech
+technology with global multilingual AI, AudarAI transforms voice into understanding, interaction,
+and connection.
+
+Our work spans speech recognition, speech understanding, speaker diarization, voice-enabled digital
+assistants, human-computer interaction, and intelligent audio systems designed for real-world impact.
+From empowering people to access technology in their native language to helping organizations communicate
+globally, AudarAI is shaping a future where every voice can be heard, understood, and connected.
+
+**Arabic-first. Multilingual by design. Human-centered at heart.**
+
+<div align="center">
+
+**[🌐 www.audarai.com](https://www.audarai.com)** · [🤗 Hugging Face](https://huggingface.co/audarai) · [GitHub](https://github.com/AudarAI) · contact@audarai.com
+
+© 2026 AUDARAI PTE. LTD. · Licensed under the AudarAI Community License v1.0
+
+</div>

config.yaml

@@ -0,0 +1,161 @@
+sample_rate: 16000
+pil_weight: 0.5
+ats_weight: 0.5
+max_num_of_spks: 8
+streaming_mode: true
+model_defaults:
+  fc_d_model: 512
+  tf_d_model: 192
+train_ds:
+  manifest_filepath: null
+  sample_rate: 16000
+  num_spks: 8
+  session_len_sec: 90
+  soft_label_thres: 0.5
+  soft_targets: false
+  labels: null
+  batch_size: 4
+  shuffle: true
+  num_workers: 2
+  validation_mode: false
+  use_lhotse: false
+  use_bucketing: false
+  pin_memory: true
+  window_stride: 0.01
+  subsampling_factor: 8
+validation_ds:
+  manifest_filepath: null
+  is_tarred: false
+  tarred_audio_filepaths: null
+  sample_rate: 16000
+  num_spks: 8
+  session_len_sec: 90
+  soft_label_thres: 0.5
+  soft_targets: false
+  labels: null
+  batch_size: 4
+  shuffle: false
+  num_workers: 2
+  validation_mode: true
+  use_lhotse: false
+  use_bucketing: false
+  drop_last: false
+  pin_memory: true
+  window_stride: 0.01
+  subsampling_factor: 8
+test_ds:
+  manifest_filepath: null
+  is_tarred: false
+  tarred_audio_filepaths: null
+  sample_rate: 16000
+  num_spks: 8
+  session_len_sec: 90
+  soft_label_thres: 0.5
+  soft_targets: false
+  labels: null
+  batch_size: 4
+  shuffle: false
+  seq_eval_mode: true
+  num_workers: 18
+  validation_mode: true
+  use_lhotse: false
+  use_bucketing: false
+  drop_last: false
+  pin_memory: true
+  window_stride: 0.01
+  subsampling_factor: 8
+preprocessor:
+  _target_: nemo.collections.asr.modules.AudioToMelSpectrogramPreprocessor
+  normalize: NA
+  window_size: 0.025
+  sample_rate: 16000
+  window_stride: 0.01
+  window: hann
+  features: 128
+  n_fft: 512
+  frame_splicing: 1
+  dither: 1.0e-05
+sortformer_modules:
+  _target_: nemo.collections.asr.modules.sortformer_modules.SortformerModules
+  num_spks: 8
+  dropout_rate: 0.5
+  fc_d_model: 512
+  tf_d_model: 192
+  spkcache_len: 188
+  fifo_len: 0
+  chunk_len: 188
+  spkcache_update_period: 188
+  chunk_left_context: 1
+  chunk_right_context: 1
+  spkcache_sil_frames_per_spk: 3
+  scores_add_rnd: 0
+  pred_score_threshold: 0.25
+  max_index: 99999
+  scores_boost_latest: 0.05
+  sil_threshold: 0.2
+  strong_boost_rate: 0.75
+  weak_boost_rate: 1.5
+  min_pos_scores_rate: 0.5
+  causal_attn_rate: 0.5
+  causal_attn_rc: 7
+encoder:
+  _target_: nemo.collections.asr.modules.ConformerEncoder
+  feat_in: 128
+  feat_out: -1
+  n_layers: 17
+  d_model: 512
+  subsampling: dw_striding
+  subsampling_factor: 8
+  subsampling_conv_channels: 256
+  causal_downsampling: false
+  ff_expansion_factor: 4
+  self_attention_model: rel_pos
+  n_heads: 8
+  att_context_size:
+  - -1
+  - -1
+  att_context_style: regular
+  xscaling: true
+  untie_biases: true
+  pos_emb_max_len: 5000
+  conv_kernel_size: 9
+  conv_norm_type: batch_norm
+  conv_context_size: null
+  dropout: 0.1
+  dropout_pre_encoder: 0.1
+  dropout_emb: 0.0
+  dropout_att: 0.1
+  stochastic_depth_drop_prob: 0.0
+  stochastic_depth_mode: linear
+  stochastic_depth_start_layer: 1
+transformer_encoder:
+  _target_: nemo.collections.asr.modules.transformer.transformer_encoders.TransformerEncoder
+  num_layers: 18
+  hidden_size: 192
+  inner_size: 768
+  num_attention_heads: 8
+  attn_score_dropout: 0.5
+  attn_layer_dropout: 0.5
+  ffn_dropout: 0.5
+  hidden_act: relu
+  pre_ln: false
+  pre_ln_final_layer_norm: true
+loss:
+  _target_: nemo.collections.asr.losses.bce_loss.BCELoss
+  weight: null
+  reduction: mean
+lr: 0.0001
+optim:
+  name: adamw
+  lr: 2.0e-05
+  betas:
+  - 0.9
+  - 0.98
+  weight_decay: 0.001
+  sched:
+    name: InverseSquareRootAnnealing
+    warmup_steps: 500
+    warmup_ratio: null
+    min_lr: 1.0e-06
+target: nemo.collections.asr.models.sortformer_diar_models.SortformerEncLabelModel
+nemo_version: 2.7.3

load_diarizer.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Load the ft8 Sortformer diarizer from config.yaml + model.safetensors — fp32, lossless, no .nemo tar.
+
+Native path that works (NeMo 2.6.2, torch 2.10):
+  1. cfg = OmegaConf.load("config.yaml")     # the .nemo model_config.yaml IS the
+     model-level cfg (top-level keys: encoder, sortformer_modules, ... — NOT nested
+     under 'model'). Identical to restore_from(..., return_config=True).
+  2. Null out train_ds / validation_ds / test_ds: ModelPT.__init__ otherwise tries to
+     build dataloaders from cluster manifest paths that don't exist at serve time.
+  3. model = SortformerEncLabelModel(cfg=cfg)   # direct instantiation works
+  4. model.load_state_dict(safetensors_sd, strict=True)
+
+fp16 quirks (ONLY relevant if you re-quantize to fp16 yourself; the shipped weights are
+fp32 and the loader skips all of this — kept so the community can quantize freely):
+  * preprocessor.* (STFT window + mel fb) is kept fp32 in the safetensors; after
+    model.half() we re-float the preprocessor and cast its output features to fp16.
+    Halving the STFT itself degrades mel features / breaks torch.stft dtype paths.
+  * Sortformer's STREAMING path creates fp32 state tensors internally
+    (sortformer_modules.init_streaming_state / streaming_update use torch.zeros
+    without dtype). torch.cat promotes the fp16 chunk to fp32 and the fp16 encoder
+    then throws "expected scalar type Float but found Half". Fix: run forward with
+    torch.set_default_dtype(torch.float16) so those internal states are fp16 too.
+  * forward returns fp32 preds (cast at the end) so NeMo's CPU post-processing
+    (ts_vad_post_processing) never sees Half tensors.
+
+Usage:
+    from load_diarizer import load_diarizer
+    model = load_diarizer()                     # dtype auto-detected (fp32 shipped)
+    segs  = model.diarize(audio=["x.wav"], batch_size=1,
+                          postprocessing_yaml=pp_yaml, verbose=False)
+"""
+import os
+import torch
+from omegaconf import OmegaConf, open_dict
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def load_diarizer(artifact_dir: str = _HERE, device: str = "cuda"):
+    from nemo.collections.asr.models import SortformerEncLabelModel
+    from safetensors.torch import load_file
+
+    cfg = OmegaConf.load(os.path.join(artifact_dir, "config.yaml"))
+    if "model" in cfg and "encoder" not in cfg:   # nested checkpoint (not ft8; safety)
+        cfg = cfg.model
+    with open_dict(cfg):
+        for k in ("train_ds", "validation_ds", "test_ds"):
+            if k in cfg:
+                cfg[k] = None
+
+    model = SortformerEncLabelModel(cfg=cfg)
+
+    sd = load_file(os.path.join(artifact_dir, "model.safetensors"))
+    fp16 = any(v.dtype == torch.float16 for v in sd.values())
+    if fp16:
+        model = model.half()
+        model.preprocessor.float()          # STFT/mel stays fp32 (matches fp32 sd keys)
+    info = model.load_state_dict(sd, strict=True)
+    assert not info.missing_keys and not info.unexpected_keys
+
+    if fp16:
+        # bridge fp32 mel features -> fp16 encoder
+        _orig_pre = model.preprocessor.forward
+
+        def _cast_pre(*a, **kw):
+            out = _orig_pre(*a, **kw)
+            if isinstance(out, tuple):
+                return (out[0].half(),) + tuple(out[1:])
+            return out.half()
+
+        model.preprocessor.forward = _cast_pre
+
+        # make internally-created streaming state (spkcache/fifo zeros) fp16 as well,
+        # and hand fp32 preds back to NeMo's CPU post-processing
+        _orig_fwd = model.forward
+
+        def _half_fwd(*a, **kw):
+            prev = torch.get_default_dtype()
+            torch.set_default_dtype(torch.float16)
+            try:
+                out = _orig_fwd(*a, **kw)
+            finally:
+                torch.set_default_dtype(prev)
+            if torch.is_tensor(out) and out.is_floating_point():
+                return out.float()
+            return out
+
+        model.forward = _half_fwd
+
+    model = model.to(device).eval()
+    return model
+
+
+if __name__ == "__main__":
+    m = load_diarizer()
+    n = sum(p.numel() for p in m.parameters())
+    print(f"loaded OK: {n/1e6:.1f}M params, encoder dtype={next(m.encoder.parameters()).dtype}")

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86444dd50d63cad3875ef3aab679ebc842466511c49753f9869b8e4ad5395cba
+size 471103752