Add model card

README.md

@@ -0,0 +1,131 @@
+---
+license: cc-by-4.0
+language:
+- en
+- es
+- fr
+- de
+- bg
+- hr
+- cs
+- da
+- nl
+- et
+- fi
+- el
+- hu
+- it
+- lv
+- lt
+- mt
+- pl
+- pt
+- ro
+- sk
+- sl
+- sv
+- ru
+- uk
+pipeline_tag: automatic-speech-recognition
+library_name: nemo
+base_model: nvidia/parakeet-tdt-0.6b-v3
+tags:
+- automatic-speech-recognition
+- speech
+- audio
+- Transducer
+- TDT
+- FastConformer
+- Conformer
+- pytorch
+- NeMo
+- bf16
+- fp16
+---
+
+# parakeet-tdt-0.6b-v3 — half-precision checkpoints
+
+Half-precision casts of NVIDIA's [`nvidia/parakeet-tdt-0.6b-v3`](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3),
+packaged as single `.nemo` archives for direct GPU loading. Two files, same
+weights, different 16-bit format:
+
+| File | Format | For |
+|---|---|---|
+| `parakeet-tdt-0.6b-v3-bf16.nemo` | bfloat16 | Ampere and newer (compute capability 8.0+) |
+| `parakeet-tdt-0.6b-v3-fp16.nemo` | float16 | anything with CUDA, including pre-Ampere (sm_75: GTX 16-series, RTX 20-series, Tesla T4) |
+
+Both are 1.25 GB and identical to the upstream model apart from the fp32 → 16-bit
+conversion. Restoring from either loads straight onto a CUDA GPU without ever
+materialising an fp32 copy, which is faster to start (~13 s vs ~22 s) and roughly
+halves peak load-time VRAM (~1.3 GB of weights).
+
+**Which one?** If your GPU does bf16, either works — they are statistically
+indistinguishable in accuracy (see below), and fp16 is marginally closer to fp32
+numerically. If your GPU predates Ampere, bf16 is not merely slower but
+unsupported, so use fp16.
+
+This repository redistributes the model under its original **CC BY 4.0** license.
+See the [upstream model card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3)
+for architecture, training data, supported languages, evaluation, and intended use.
+
+## Usage (NeMo)
+
+```python
+import nemo.collections.asr as nemo_asr
+from huggingface_hub import hf_hub_download
+
+ckpt = hf_hub_download("lightware-dev/parakeet-tdt-0.6b-v3",
+                       "parakeet-tdt-0.6b-v3-bf16.nemo")   # or -fp16.nemo
+model = nemo_asr.models.ASRModel.restore_from(ckpt, map_location="cuda")
+model.eval()
+print(model.transcribe(["audio.wav"]))
+```
+
+## fp16 vs bf16 vs fp32
+
+Measured over 208 clips (25.8 minutes): LibriSpeech `test-clean` samples, the same
+clips degraded with white noise at 10 dB and 5 dB SNR, babble at 5 dB, and a
+near-clipping loud variant, plus synthetic speech. Greedy TDT decoding, WER after
+text normalisation. The reference is the upstream fp32 checkpoint under an
+otherwise identical pipeline.
+
+| | fp32 | bf16 | fp16 |
+|---|---|---|---|
+| WER, all clips | 2.96 % | 2.99 % | 2.96 % |
+| WER, clean real speech | 2.40 % | 2.40 % | 2.40 % |
+| Encoder output vs fp32, mean relative L2 | — | 0.0436 | 0.0052 |
+| Encoder output vs fp32, worst cosine similarity | — | 0.8351 | 0.9948 |
+| Weights on disk / in VRAM | 2.5 GB | 1.31 GB | 1.31 GB |
+
+fp16 and bf16 produced **identical transcripts on 207 of 208 clips**. The WER
+difference between them is +0.026 pp (95 % bootstrap CI [0.000, +0.077],
+p = 0.74) — statistically indistinguishable, and exactly zero on real speech.
+
+fp16 tracks fp32 roughly 8× more closely than bf16 does at the activation level,
+which is what you would expect from its 10 mantissa bits against bf16's 7. No
+overflow was observed: zero non-finite activations anywhere, including on the
+deliberately near-clipping loud slice. The narrower fp16 exponent range is not a
+practical problem for this model at inference.
+
+Throughput was measured on an RTX 5090 (where all three are supported) — median
+real-time factor 0.0114 fp32, 0.0133 bf16, 0.0118 fp16. Expect very different
+absolute numbers on a pre-Ampere card; the point of that row is only that fp16 is
+not slower than bf16.
+
+**Caveats.** The evaluation corpus is English-only, so these figures say nothing
+about the other 24 languages the base model supports beyond the general
+expectation that a pure weight cast behaves the same way across them. Both
+checkpoints were cast from the upstream fp32 weights — the fp16 one is not a
+bf16 → fp16 round trip, which would inherit bf16's coarser mantissa for no benefit.
+
+## Provenance
+
+- **Base model:** `nvidia/parakeet-tdt-0.6b-v3`
+- **Change:** fp32 weights cast to bf16 / fp16, re-saved as `.nemo`
+  (701 float tensors, 627,090,582 parameters, unchanged key set)
+- **License:** CC BY 4.0 (inherited from the base model)
+- **Built and evaluated with:** [`lightware-dev/blurt`](https://github.com/lightware-dev/blurt) —
+  `scripts/build_bf16_ckpt.py` and `scripts/compare_precision.py`
+
+Previously published as `lightware-dev/parakeet-tdt-0.6b-v3-bf16` and
+`lightware-dev/parakeet-tdt-0.6b-v3-fp16`; both are now consolidated here.