Datasets:

uv-scripts
/

transcription

Script	Model	Backend	Output	Speed
`cohere-transcribe.py`	Cohere Transcribe (2B)	transformers	`.txt`	161x RT (A100)
`cohere-transcribe-vllm.py`	Cohere Transcribe (2B)	vLLM nightly	`.txt`	214x RT (A100)
`granite-turboctc-transcribe.py`	Granite Speech 5.0 TurboCTC (470M, English)	transformers (pinned `main`)	`.txt` (lowercase, no punctuation)	594x RT wall / ~5000x GPU-only (A100); 504x RT wall (A10G)
`buzzasr-transcribe.py`	BuzzASR (102 monolingual Whisper-large-v3 fine-tunes, 1.55B)	transformers	`.txt` (mostly lowercase, no punctuation)	20x RT (L4, sequential) / 51x RT (L4, chunked)
`easytranscriber-transcribe.py`	Cohere Transcribe 2B (default) or Whisper variants	easytranscriber	JSON word timestamps (+ optional `.txt` / `.srt`)	42.9x RT (L4)
`moss-transcribe-diarize.py`	MOSS-Transcribe-Diarize (0.9B)	transformers (remote code)	JSON speaker segments `{start, end, speaker, text}` (+ optional `.txt` / `.srt`)	3.2x RT (A10G, 74-min file)
`moss-transcribe-diarize-server.py`	MOSS-Transcribe-Diarize (0.9B)	in-job sgl-omni server	JSON speaker segments (+ optional `.txt`)	47.4x RT aggregate (A100, 6 streams)
`nemotron-transcribe.py`	Nemotron 3.5 Transcribe (30B MoE, ~4B active, 40 languages)	in-job vLLM 0.32 + NeMo Speech server	`.txt` (+ JSON word timestamps, speakers and diarization with `--timestamps`)	116x RT aggregate (RTX PRO 6000, 10 files) + ~8 min fixed setup
`nemotron-transcribe-saturate.py`	Nemotron 3.5 Transcribe (same model)	in-job SGLang-Omni server, driven by saturate	parquet `{id, text, finish_reason, duration_s, model, prompt, error}`	81x RT aggregate (RTX PRO 6000, 10 files) + ~9 min fixed setup

cohere-transcribe.py (recommended for plain text) — uses model.transcribe() with automatic long-form chunking, overlap, and reassembly. Stable dependencies.

cohere-transcribe-vllm.py — experimental vLLM variant. Faster but requires nightly vLLM and has minor duplication at chunk boundaries.

granite-turboctc-transcribe.py — when you have a lot of English audio and want raw text fast. Encoder-only CTC (one forward pass + argmax, no autoregressive decoding), so it cannot loop or hallucinate and the GPU is essentially idle: 5 hours of 1940s radio ran in 3.2 s of GPU time on an A100 (~~30x Cohere), with the job's wall time dominated by mp3 decoding and model load. Output is lowercase without punctuation or casing, and quality is a step below Cohere on hard audio (~~8.5% word disagreement with Cohere's transcripts on the same episodes, no ground truth). Files are fed whole by default — block attention makes cost linear in length and a 30-min file needs ~2.5 GB — with --chunk-seconds 30 for hour-plus files or a 24 GB card. Needs transformers from main (support landed 2026-08-25, pinned to a commit) until the next release; English only.

buzzasr-transcribe.py — when the audio is in a language Cohere doesn't cover (Armenian, Amharic, Georgian, Khmer, Lao, Sorani Kurdish, Wolof, Yoruba, …): one model per language for 102 FLEURS languages. BuzzASR (Findings of EMNLP 2026, MIT) fine-tunes Whisper-large-v3 once per FLEURS language, with a native tokenizer for the languages Whisper's tokenizer fragments; the authors report lower CER than Whisper-large-v3 zero-shot on 89/102 languages and the lowest of any open system on 31. Pass --language armenian (or the ISO code hy) and the matching BuzzASR/<language> checkpoint is loaded: every card tags both the name and the code, so the recipe resolves either with a tag filter on the org at run time (no table to maintain; new languages just work). Finding a model by hand is the same one-liner: hf models list --author BuzzASR --filter ckb --format quiet → BuzzASR/sorani-kurdish, or --search kurdish by name. The language prompt is baked into each model, so the model is never asked to detect the language. Default long-form decoding is Whisper's sequential algorithm (timestamps place each window, degenerate windows are re-decoded at higher temperature), which skipped no windows in our tests but is ~2.5x slower than --long-form chunked (the transformers pipeline), whose overlap merge drops text: on 3 h of Dutch audiobook the chunked run produced 14% fewer words than sequential, with whole sentences missing. Generation uses the authors' settings (greedy, no repeated 3-gram, repetition penalty 1.2), which also stop a genuinely repeated phrase from being written twice inside one 30 s window. Output is normalised like the training data (mostly lowercase, no punctuation); for a language Whisper already covers well, openai/whisper-large-v3 through the same recipe gives punctuated, cased text of the same completeness (see BENCHMARKS.md), so reach for BuzzASR where Whisper is weak. The recipe rebuilds each model's generation_config.json on load: the native-tokenizer checkpoints ship it flagged _from_model_config, which makes transformers drop the language prompt and timestamp ids and breaks long-form generation. --model openai/whisper-large-v3 runs the zero-shot base through the same loop as a control.

easytranscriber-transcribe.py — when you need word-level timestamps (subtitles, search indexing, forced alignment). Runs VAD → ASR → wav2vec2 emissions → forced alignment. Defaults to the Cohere backend so you get the same model as the other scripts with alignment on top; swap to --backend ct2 + a Whisper model for languages Cohere doesn't cover (e.g. Swedish via KBLab/kb-whisper-large).

moss-transcribe-diarize.py — when you need who said what. Joint transcription + speaker diarization + timestamps in one generation pass (no separate ASR/diarization/alignment stages). 128k context handles up to ~90 min of audio per file internally, so files are never pre-chunked and the anonymous speaker labels ([S01], [S02], ...) stay consistent across the whole recording. English + Chinese; also accepts video containers (mp4, mkv, ...); supports hotword biasing for names/jargon.

moss-transcribe-diarize-server.py — same model at ~12x the throughput for many files: serves it behind sglang-omni inside the job and posts files concurrently (continuous batching). Splits long tapes into ≤55-min clips to fit the context window (speaker labels reset between clips, recorded as part on each segment) and automatically continues from the last timestamp when the model stops early, reporting coverage_s per file. Needs a100-large — 24 GB cards OOM on long-tape KV. The hf jobs run command lives in the script docstring (server + driver in one job).

nemotron-transcribe.py — when you want punctuated text, speaker tags and word timestamps from one model, in 40 languages (speaker tags in 13, up to 8 speakers), and have enough audio to amortise a fixed 8 min setup. The model only serves on vLLM 0.32.0 with the NeMo Speech plugin, so the script starts that server inside the job and posts files concurrently: 10 half-hour 1940s radio episodes (4.9 h) took 2.5 min once the server was up, a $0.48 job on rtx-pro-6000. The [tool.hf-jobs] header sets the flavor and a prebuilt image (cr.hf.co/davanstrien/nemotron-transcribe, built in a Job by nemotron-transcribe-image.sh) that pins NeMo Speech to one commit and carries FlashInfer kernels already compiled for that GPU. --image vllm/vllm-openai:v0.32.0 makes the script install the stack at runtime instead (2 min slower; it downloads FlashInfer's precompiled kernels). Prompts are the model card's presets (--style verbatim|clean|speakers, or --prompt with Context terms: <names> for jargon), and the card's generation-loop guardrail is applied to every transcript. --timestamps adds a JSON per file with word start/end times, speaker tags and diarization segments, from the CTC head bundled in the checkpoint. Files over 55 min are split into equal parts, and speaker tags reset between parts. On the same 10 episodes, after Whisper-style text normalisation, its words differ from Cohere's by 7.0% (Granite vs Cohere: 7.7%; Nemotron vs Granite: 8.4%); there is no ground truth for these episodes, so this measures agreement, not accuracy. Once loaded it matches Cohere's speed (116x vs 120x RT on the same audio), but the fixed setup makes a 5-hour batch cost $0.48 against Cohere's $0.16 and Granite's $0.20, so reach for it when you need the speaker tags, timestamps or languages. The vLLM integration is NVIDIA's development path; the card says it is about 2x slower than their NIM.

nemotron-transcribe-saturate.py — the same model on SGLang-Omni (no NeMo), with saturate as the driver: a fixed window of files in flight (--concurrency), resumable parquet output keyed by input path, and durable error rows (--retry-errors). Input is a glob ("hf://buckets/user/audio/**/*.mp3"), output a dataset id or fsspec URI. It is plain transcription only, because SGLang-Omni's integration has no timestamps, speaker tags or translation; each file is one request of up to an hour. On the same 10 episodes it ran at 81x realtime once up (vLLM path: 116x) in a 12.8 min job; its text differs from the vLLM recipe's by 2.4% of words and from Cohere's by 7.3%, with no looping or truncated files. Two workarounds are pinned in its SERVING dict. The model card names SGLang-Omni 0.2.0, but that wheel predates the Nemotron integration, so a main commit is installed. The integration also expects the architecture name NeMoSpeechLMForConditionalGeneration while the Hub checkpoint declares Nemotron3_5TranscribeForConditionalGeneration, so the local copy's config.json is renamed before serving.

Notes

Tokenizer workaround: cohere-transcribe.py applies a one-line patch for a tokenizer compat issue. Will be removed once upstream fixes land (model discussion).
moss-transcribe-diarize: not gated (Apache 2.0). Uses trust_remote_code=True (model code lives in the model repo); inference helpers install from the model's GitHub repo pinned to a commit (the package isn't on PyPI). Generation time scales with audio length — long multi-speaker recordings emit tens of thousands of tokens, so watch the truncated flag in the output JSON.