loom-ai-org/wakehubert-tiny-loom

WakeHuBERT tiny (streaming speech features for wake words)

TigreGotico's 0.64M-parameter causal feature extractor, distilled from HuBERT-base for wake-word detection, exported for loom.cpp in four precisions. Family 13: audio in, one 128-dimensional feature vector per 20 ms frame out.

This is a loom.cpp export: a single self-describing GGUF that carries its own graph topologies, tokenizer (if any) and driver script, produced by loom-exporter.

Original model

Exported from TigreGotico/wakehubert-tiny. The F32 file carries the same parameters unmodified, in loom.cpp's GGUF format; the others are quantized from them (see Files).

License

apache-2.0, inherited from the base model above.

Language(s)

en, de, nl, fr, es, it, pt, pl

Usage

Run it with loom-py -- loom-py-rt on PyPI:

pip install -U "loom-py-rt[hub]"

import loom

# This repo holds four precisions of one model; name the file you want (see "Files" below).
model = loom.Model.from_pretrained("loom-ai-org/wakehubert-tiny-loom", "wakehubert-tiny-f32.gguf")

# Audio is a mono float list at 16 kHz. `infer` returns every frame's features in one flat list, and
# the file declares its own frame rate: one frame per 320 samples.
flat = model.infer(waveform=audio)
hop = round(model.contract["sample_rate"] / model.contract["frame_rate"])
dim = len(flat) // (len(audio) // hop)
features = [flat[i:i + dim] for i in range(0, len(flat), dim)]
print(len(features), dim)
# one row per 20 ms of audio, 128 features each: 550 128 for an 11 s clip

# Each row describes the speech about 100 ms before its frame ends; a wake-word classifier is trained
# on a window of these rows, and its decision rule is yours.

The layer underneath

The call above is model.infer(...), which passes your arguments straight to the driver this GGUF embeds; no high-level door answers this model's output yet.

model.driver_source prints that driver, including a header comment documenting every argument it accepts for this model, and is the authority on it. See loom-py for the API and loom.cpp for what the engine does between the two.

Known limitations

Use model.infer, not speech2embeddings. This file's embeddings are per FRAME, and loom's speech2embeddings door returns one vector per clip, so it refuses this model with an error naming the granularity (it is still listed in model.capabilities). infer returns the frames, row-major.

One call is one whole clip, offline. The model is strictly causal -- frame t depends only on audio before sample 320 x (t + 1), within a 2.5 s receptive field -- and it was trained to describe each HuBERT frame 100 ms late, so a detector built on it reacts about that long after the word ends. To stream it, call it on a sliding buffer that keeps 40,000 samples (2.5 s) of context and take the newest frames: those then equal the offline ones. A clip shorter than 320 samples gives no frames. Audio must be mono 16 kHz.

Every precision keeps the front end in F32. The log-mel's DFT basis is the one weight this model cannot spare precision in: at F16 its rounding in the near-empty high bins of a loud frame is amplified by the log, which took the worst frame to cosine 0.976 before the basis was exempted. Upstream's own int8 file keeps its front end in float too.

Upstream evaluates it on one English wake word and one benchmark, and notes that agreement with the teacher predicts detection quality poorly: judge it, and any of the quantized files, by a detector trained on its features.

Files

One model in several precisions; every file carries the same graph and driver. The quantized ones pack the convolution and projection weights (loom-export --quantize <type>), so their numbers differ from the original model's by the amount noted.

• wakehubert-tiny-f32.gguf -- full precision, 3.3 MB. Matches upstream's PyTorch model to float rounding: largest difference 3.4e-5 on features up to 11.5, cosine 1.000000 on every frame.
• wakehubert-tiny-f16.gguf -- 2.0 MB. Mean cosine 1.000000 to the PyTorch model, worst frame 0.999998. A size choice, not a speed one: on an x86 CPU it runs about 1.4x SLOWER than F32 (the quantized files run at F32's speed).
• wakehubert-tiny-q8_0.gguf -- 1.4 MB. Mean cosine 0.99992, worst frame 0.99978 -- closer than upstream's own wakehubert_int8.onnx (mean 0.9975).
• wakehubert-tiny-q4_1.gguf -- 1.2 MB. Mean cosine 0.987, worst frame 0.972: a measurably different feature space. A detector trained on the F32 features needs re-validating on these, or training on them.