whisper-hu-large-v3-turbo-finetuned — GGML (whisper.cpp)

GGML quantizations of sarpba/whisper-hu-large-v3-turbo-finetuned, a Hungarian fine-tune of openai/whisper-large-v3-turbo, packaged for whisper.cpp (ggml-*.bin, the legacy GGML container that whisper-cli / whisper-server load — not GGUF, and not a transformers checkpoint).

Magyarul, röviden: ez a repó a magyar Whisper-large-v3-turbo fine-tune whisper.cpp-hez készült GGML kvantált változatait tartalmazza (f16, q8_0, q5_0, q4_0). A q8_0 gyakorlatilag veszteségmentes (WER-ben mérve a különbség 0,0 pont), a q5_0/q4_0 pedig 0,1–0,2 WER-pontot veszít, miközben a modell 2,8–3,4× kisebb. A modell szövegfelismerésre való; a saját időbélyegei ebben a runtime-ban megbízhatatlanok (lásd Limitations), szószintű időzítéshez külső aligner kell. Az eredeti modellkártya figyelmeztet, hogy a CTranslate2 kvantálás tönkreteszi a modellt — a GGML/whisper.cpp átalakítás nem mutat ilyen romlást.

Files

Which one? q8_0 is the recommended default (quality-neutral vs f16, 1.9× smaller). Use q5_0 when disk/RAM matters, q4_0 only when the smallest possible file is needed. f16 is included as the exact reference of the conversion (bit-identical weights to the source checkpoint up to the f16 cast).

Measured quality and speed

Protocol: 1 000 utterances of CommonVoice-22 Hungarian test split (speaker-disjoint from the fine-tune's training pool as far as documented, 1.589 h of audio), 16 kHz mono, greedy decoding (-bs 1 -bo 1 -nf), whisper-server with concurrency 1, RTX 3090, whisper.cpp v1.9.5 (commit 231638a, ggml 0.27.0, CUDA 13.0). Text normalized with the benchmark's Hungarian normalizer (NORM_V=2: lowercase, punctuation stripped, Hungarian accents kept — á é í ó ő ú ű are not folded). WER/CER are percentages.

Reading: on Hungarian, q8_0 is free (−0.02 WER points is noise), q5_0/q4_0 cost ~0.1–0.2 points while being 2.8–3.4× smaller. Speed barely changes with quantization because at turbo size the 3090 is not memory-bound; the win is file size / RAM / CPU cache, not wall time. The same weights in the PyTorch runtime score 10.85 % WER — the GGML conversion does not change accuracy.

This table is the upload-time re-run of the quick test (2026-10-25, 1 000 utts, raw rows in benchmark.json); an independent earlier run of the same protocol gave 10.74 / 10.72 / 10.85 / 10.91 % WER — identical within 0.01 pt, so the numbers are stable. q5_0 re-quantized from the f16 file is byte-identical to the shipped q5_0 file (deterministic converter).

Usage

1. Get whisper.cpp and build it

git clone https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
cmake -B build -DGGML_CUDA=1        # or no flag for CPU-only
cmake --build build -j --config Release

2. Download a quantization and transcribe

hf download sarpba/whisper-hu-large-v3-turbo-finetuned-GGML \
  ggml-hu-whisper-large-v3-turbo-finetuned-q8_0.bin --local-dir .

# whisper.cpp needs 16 kHz mono WAV
ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le audio.wav

./build/bin/whisper-cli \
  -m ggml-hu-whisper-large-v3-turbo-finetuned-q8_0.bin \
  -l hu -f audio.wav

Useful flags (whisper.cpp v1.9.5):

• -l hu — force Hungarian (the model is Hungarian-only in practice).
• -bs 1 -bo 1 -nf — greedy decoding + no temperature fallback (this is what the WER table above used; the CLI default is beam search -bs 5 -bo 5).
• -dev 0 — pick GPU 0; -ng means no GPU (CPU) in this build, -t 8 sets CPU threads.
• -mc 0 — disable text context (≈25 % faster on short utterances, but it removes cross-segment context; check accuracy on your long-form audio before adopting it).
• Output formats: -oj (JSON segments), -ojf (JSON with per-token timestamps), -osrt / -ovtt / -ocsv. Word-level words[] is produced by whisper-server with response_format=verbose_json, not by whisper-cli.

3. Server mode

./build/bin/whisper-server -m ggml-hu-whisper-large-v3-turbo-finetuned-q8_0.bin \
  -l hu -dev 0 --host 127.0.0.1 --port 8080
curl -F file=@audio.wav -F response_format=json \
     -F temperature=0.0 http://127.0.0.1:8080/inference

How these files were produced

The source is an HF transformers checkpoint, which whisper.cpp cannot read directly. The pipeline (all steps reproducible, CPU-only, ~1 min total):

HF safetensors  --(conversion/hf_to_openai_pt.py)-->  OpenAI .pt layout
                --(whisper.cpp models/convert-pt-to-ggml.py)-->  ggml f16 .bin
                --(whisper-quantize)-->  q8_0 / q5_0 / q4_0

# 0) source checkpoint (pin the revision!)
hf download sarpba/whisper-hu-large-v3-turbo-finetuned --revision 9d63092bd80b66729b86f2c6d044a964afb39f7f --local-dir src

# 1) HF transformers names -> OpenAI/ggml tensor contract
python conversion/hf_to_openai_pt.py src model-openai-f16.pt

# 2) .pt -> legacy ggml .bin (needs openai/whisper's mel_filters.npz + multilingual.tiktoken)
git clone https://github.com/openai/whisper
python whisper.cpp/models/convert-pt-to-ggml.py model-openai-f16.pt whisper .

# 3) quantization
whisper.cpp/build/bin/whisper-quantize ggml-model.bin out-q8_0.bin q8_0
whisper.cpp/build/bin/whisper-quantize ggml-model.bin out-q5_0.bin q5_0
whisper.cpp/build/bin/whisper-quantize ggml-model.bin out-q4_0.bin q4_0

Conversion notes worth knowing:

• The remapper is needed because HF transformers and whisper.cpp disagree on LayerNorm semantics (self_attn_layer_norm / final_layer_norm map to swapped ggml attn_ln / mlp_ln names) and on the encoder post-conv norm (conv_norm_layer vs layer_norm) — naive name matching silently produces a model that loads but transcribes garbage.
• The produced tensor list is 587/587 identical (names, shapes, types) to ggerganov/whisper.cpp's ggml-large-v3-turbo.bin; only the weight data differs. That equality is the conversion's correctness proof.
• Dtypes must follow the OpenAI layout (f16 for matmul/conv/token weights, f32 for biases, LayerNorm gains and positional embeddings), otherwise the ggml loader's byte-count checks fail or misparse the stream.

Limitations

• No reliable timestamps from this model in whisper.cpp. The fine-tune's own timestamp tokens are degenerate: a 5.9 s utterance is reported as a single segment 0.84 → 30.00 s (and it is not a CLI bug — the base turbo model's segments are sane in the same build). Use this model for text, and get word timings from a forced aligner (e.g. a Hungarian wav2vec2 CTC model or MFA).
• Hungarian read speech domain. Numbers above are on CommonVoice-22 HU (clean read speech, ~1.6 h sample). Expect higher error on noisy, telephone or conversational audio. Punctuation and the model's spelling of rare proper nouns are not guaranteed (e.g. it may write Bázpárt for Baasz Párt).
• Not loadable by transformers, faster-whisper or CTranslate2. This is a whisper.cpp GGML repo; use the original repo for the PyTorch weights. The original model card explicitly warns that the CT2 int8/float16 conversion breaks the model (truncated output); the GGML files here were verified not to have that problem (word-for-word identical hypotheses to the fp16 PyTorch model on Hungarian samples, accents intact, no truncation).
• This is the legacy GGML .bin container, not GGUF. whisper.cpp does not consume GGUF for Whisper models; do not rename these files to .gguf.

License

MIT — inherited from openai/whisper-large-v3-turbo (MIT) and the fine-tune card (license: mit). See LICENSE.

Provenance

• Source: sarpba/whisper-hu-large-v3-turbo-finetuned @ 9d63092bd80b66729b86f2c6d044a964afb39f7f
• Base: openai/whisper-large-v3-turbo @ 41f01f3fe87f28c78e2fbf8b568835947dd65ed9
• Toolchain: whisper.cpp v1.9.5 (231638a0717b7822784297e5980965ffcec05810), ggml 0.27.0
• Produced on 2026-10-25; benchmark rows in benchmark.json.