wildernesslabs/kea-b-0.1

Kea-B 0.1

Kea-B 0.1 is an English speech recognizer in 91.24 MB. It is NVIDIA's Parakeet-TDT-0.6B-v2 with almost every weight stored as a single bit (+1 or −1, with one scale per row) and its decoder in 8-bit integers. The original is 2,472 MB.

Across the seven English test sets NVIDIA reports, it averages a 6.77% word error rate, against 6.44% for the original. Kea-B 0.0 scored 7.05% at 105.3 MB, so 0.1 is both smaller and more accurate. It even edges out our 2-bit Kea-T (6.84%) at about half its size.

Results

Test word error rate (%), greedy decoding, lower is better:

Model	LS clean	LS other	AMI	Earnings-22	GigaSpeech	SPGISpeech	VoxPopuli	Mean of 7	Common Voice
Original (NVIDIA's numbers)	1.69	3.19	11.16	11.15	9.74	2.17	5.95	6.44	n/a
Kea-T	2.05	4.20	10.42	11.72	10.35	2.94	6.19	6.84	12.56
Kea-B 0.0	2.20	4.56	10.65	12.17	10.46	3.01	6.30	7.05	13.42
Kea-B 0.1 (this model)	2.07	4.32	9.89	10.86	10.29	3.67	6.29	6.77	11.35

Kea-B 0.1 is scored the same way as Kea-B 0.0 and Kea-T: weights rebuilt in FP32 from this repository. On our INT8 × 1-bit GPU kernels, which it was trained for, the mean is 6.77% and no set moves by more than 0.05 points. Kea-B 0.1 has trained on Common Voice audio (test speakers and sentences removed), so its Common Voice score isn't comparable with the others. EVALUATION.md has every number and how it was measured.

What changed since 0.0

• Better labels. It learned from a stronger teacher: a full-precision Parakeet fine-tuned on transcripts from IBM's Granite Speech, instead of the original model's own output.
• Trained for the kernels. During training its activations go through the same INT8 rounding our GPU kernels use, so the accuracy holds when it runs on them.
• An 8-bit decoder. The prediction and joint networks moved from FP16 to INT8.
• Harder audio. Far-field meeting recordings, Common Voice and technical speech joined the training mix.

Where it's worse

• Spelled-out letters ("F-I-T-Z") are often joined into one word or dropped.
• SPGISpeech is 0.66 points worse than Kea-B 0.0. Kea-B 0.1 writes down fillers and false starts that SPGISpeech's references clean up, and trailing "…" that the scorer counts as a word.
• It mixes up EBITDA and EBIT more often than a matched control model did.

Use it

pip install "nemo_toolkit[asr]"
hf download wildernesslabs/kea-b-0.1 --local-dir kea-b-0.1
python kea-b-0.1/load_kea_b.py clip.wav    # 16 kHz audio; prints the transcript

import sys; sys.path.insert(0, "kea-b-0.1")
from load_kea_b import load, transcribe
model = load("kea-b-0.1", device="cuda")    # or "cpu"
print(transcribe(model, ["clip.wav"]))

load_kea_b.py checks every file against its manifest and rebuilds an ordinary FP32 NeMo model. You get the accuracy above, but not the memory or speed savings: those come from running the 1-bit weights directly, as our GPU kernels do.

Files

Path	Size	What
bundle.safetensors, manifest.json, tokenizer/	91,345,312 bytes	The model: 1-bit codes, INT8 decoder, FP16 for the rest.
compat/	105,299,804 bytes	The same weights in Kea-B 0.0's format, for tools that read it. load("kea-b-0.1/compat") gives the identical model.
load_kea_b.py		Loader and command-line tool (MIT License). Reads either format.
EVALUATION.md, TRAINING.md		Every result, the recipe and the training data.

More

The training and evaluation code is at https://github.com/ajbarryiii/wilderness-labs-stt (finetune/relabel). Earlier releases: Kea-B 0.0 and Kea-T.

The weights and documents are licensed CC-BY-4.0, like the base model they modify, NVIDIA's nvidia/parakeet-tdt-0.6b-v2. NOTICE lists the changes, the training data and the tools, with their licences.