quietfield

GGUF speech-recognition weights

Quantized GGUF conversions of two upstream speech-recognition models, hosted here so downloads resolve from one place. The weights are conversions of the upstream releases; no fine-tuning or other modification has been applied.

Both are licensed Apache-2.0 by their original authors, and that licence carries over unchanged. Credit for the models belongs to the upstream teams.

Transcribing long recordings

Split the audio. There is no configuration of these weights that transcribes a multi-hour recording in one pass, and the reasons are arithmetic rather than a matter of tuning. Written out here because the obvious first instinct — raise the declared limit and re-upload — does not work, and the way it fails is quiet rather than loud.

The limit people find first is not the binding one

The Arabic model declares stt.cohere.encoder.pos_emb_max_len = 5000, which fixes how much audio one encoder pass accepts:

hop_length 160 @ 16 kHz  = 100 frames/s
8x encoder subsampling   =  12.5 frames/s
5000 frames / 12.5       = 400.0 s

so max_audio_ms is 400000 and longer input is rejected with input too long. That figure is metadata, not a trained weight — the encoder uses relative positional encoding (attn.linear_pos, attn.pos_bias_u, attn.pos_bias_v), computed at inference time, and no tensor caps sequence length. Editing the field really does let the model accept more: patched to 15000, it consumed 6694 frames in one pass.

The transcript came back roughly half the length of the same audio split into two in-spec passes. Which brings up the limit that actually binds.

The decoder is the binding limit

stt.cohere.decoder.max_seq_len = 1024

and in practice a run stops at 512 generated tokens:

cohere run: output truncated at 512 tokens — decode reached the
context/budget before end-of-stream

A pass carrying more speech than that does not return a short transcript — it fails, and the partial is only available on the error. A three-hour Arabic transcript is on the order of 90,000-150,000 tokens, so a single pass can emit about 0.4% of it. Doubling the cap to the declared 1024 reaches 0.9%. No edit to this file closes that gap.

And the encoder could not afford it anyway

Self-attention cost grows with the square of sequence length. At 12.5 frames/s, with 8 heads and 48 encoder layers:

One layer of the three-hour case needs about 292 GB across its heads, and there are 48 layers. Raising the declared cap does not make that affordable.

What to do instead

Split on silence into segments under the limit, transcribe each, and concatenate. Cutting in a pause means segments need no overlap and no token-level de-duplication. Size the segments to the decoder budget, not the encoder ceiling: around 60 s of speech is a reasonable target, with a retry that splits any segment which still truncates.

Measured this way on Arabic speech, scoring recall of distinct source sentences rather than character count (the model applies inverse text normalisation, so a correct transcript is legitimately shorter than its source):

Sizing the same segments to the 400 s encoder ceiling instead recovered 40/150 (27%) on the first of those, because most segments overran the decoder and failed.

See Bain et al., WhisperX: Time-Accurate Speech Transcription of Long-Form Audio (Interspeech 2023) for the VAD "Cut & Merge" segmentation this follows.

Verifying a download

shasum -a 256 cohere-transcribe-arabic-07-2026-Q4_K_M.gguf
# 4671080cd10ffc6166e1e1b36216f9b51e1455f170d55c59cff7b81332ad4621

shasum -a 256 whisper-small.en-Q8_0.gguf
# 9614e6b7fda2d26018e4f268aece8ca25a83296ea0b534169a585b740bfd71ef