{"id":39,"date":"2026-11-15T12:58:24","date_gmt":"2026-11-15T12:58:24","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/whisper-transcription-at-scale-speech-datasets\/"},"modified":"2026-11-15T12:58:24","modified_gmt":"2026-11-15T12:58:24","slug":"whisper-transcription-at-scale-speech-datasets","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/whisper-transcription-at-scale-speech-datasets\/","title":{"rendered":"Whisper Transcription at Scale for Speech Datasets"},"content":{"rendered":"<p>Running Whisper on one podcast is a one-liner. Running it over 50,000 hours of mixed YouTube audio is a different job: silence and music make the model invent text, long files fall into repetition loops, language labels are wrong, and nobody knows how many GPU-hours the run will take. This guide covers Whisper transcription at dataset scale: model choice, faster-whisper and WhisperX, VAD, failure modes, throughput math, output formats and quality checks, with APIs checked against the current repositories and model cards.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Model:<\/strong> <code>large-v3<\/code> for best accuracy, <code>large-v3-turbo<\/code> (809M parameters, 4 decoder layers instead of 32) when throughput matters more. Measure the WER difference on your own audio.<\/li>\n<li><strong>Runtime:<\/strong> faster-whisper's <code>BatchedInferencePipeline<\/code> for bulk transcription; WhisperX when you need forced-aligned word timestamps or speaker labels.<\/li>\n<li><strong>Always run VAD first.<\/strong> Hallucinations cluster in non-speech audio, and VAD also tells you how many hours are actually speech.<\/li>\n<li><strong>Keep every segment's <code>avg_logprob<\/code>, <code>compression_ratio<\/code> and <code>no_speech_prob<\/code><\/strong> and filter afterwards, especially in batched mode, which does not re-decode failed chunks.<\/li>\n<li><strong>Plan capacity with a measured RTFx<\/strong> (audio seconds per wall-clock second) from a pilot, not with someone else's benchmark.<\/li>\n<li><strong>Validate against manual YouTube subtitles<\/strong> with jiwer, treating the score as an agreement signal, not true WER.<\/li>\n<\/ul>\n<h2>Choosing a Whisper model<\/h2>\n<p>The <a href=\"https:\/\/github.com\/openai\/whisper\">openai\/whisper README<\/a> lists six sizes. VRAM and relative speed below are OpenAI's own approximate figures (English, A100); real-world speed varies with language, speaking rate and hardware.<\/p>\n<table>\n<thead>\n<tr>\n<th>Size<\/th>\n<th>Parameters<\/th>\n<th>English-only<\/th>\n<th>Required VRAM (approx.)<\/th>\n<th>Relative speed (approx.)<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>tiny<\/td>\n<td>39 M<\/td>\n<td><code>tiny.en<\/code><\/td>\n<td>~1 GB<\/td>\n<td>~10x<\/td>\n<\/tr>\n<tr>\n<td>base<\/td>\n<td>74 M<\/td>\n<td><code>base.en<\/code><\/td>\n<td>~1 GB<\/td>\n<td>~7x<\/td>\n<\/tr>\n<tr>\n<td>small<\/td>\n<td>244 M<\/td>\n<td><code>small.en<\/code><\/td>\n<td>~2 GB<\/td>\n<td>~4x<\/td>\n<\/tr>\n<tr>\n<td>medium<\/td>\n<td>769 M<\/td>\n<td><code>medium.en<\/code><\/td>\n<td>~5 GB<\/td>\n<td>~2x<\/td>\n<\/tr>\n<tr>\n<td>large (v3)<\/td>\n<td>1550 M<\/td>\n<td>none<\/td>\n<td>~10 GB<\/td>\n<td>1x<\/td>\n<\/tr>\n<tr>\n<td>turbo (large-v3-turbo)<\/td>\n<td>809 M<\/td>\n<td>none<\/td>\n<td>~6 GB<\/td>\n<td>~8x<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Details that matter for a dataset run:<\/p>\n<ul>\n<li><strong><code>large<\/code> now means <code>large-v3<\/code>.<\/strong> Both openai-whisper and faster-whisper map the alias <code>large<\/code> to the large-v3 checkpoint. Pin the explicit name in your manifests so a rerun is reproducible.<\/li>\n<li><strong>large-v3<\/strong> uses 128 Mel bins instead of 80 and was trained on 1 million hours of weakly labeled audio plus 4 million hours pseudo-labeled with large-v2, according to its <a href=\"https:\/\/huggingface.co\/openai\/whisper-large-v3\">model card<\/a>.<\/li>\n<li><strong>large-v3-turbo<\/strong> is, per its <a href=\"https:\/\/huggingface.co\/openai\/whisper-large-v3-turbo\">model card<\/a>, a fine-tuned, pruned large-v3 with the decoder reduced from 32 to 4 layers, \"at the expense of a minor quality degradation\". The README notes it is not trained for translation, which doesn't matter for same-language transcription.<\/li>\n<li><strong>Accuracy varies widely by language.<\/strong> OpenAI's per-language WER\/CER breakdown is in the README and the <a href=\"https:\/\/arxiv.org\/abs\/2212.04356\">Whisper paper<\/a>. For low-resource languages, run a pilot before committing GPU budget.<\/li>\n<\/ul>\n<h2>Choosing a runtime<\/h2>\n<table>\n<thead>\n<tr>\n<th>Runtime<\/th>\n<th>What it adds<\/th>\n<th>Use it for<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/github.com\/openai\/whisper\">openai-whisper<\/a><\/td>\n<td>Reference implementation, CLI with txt\/vtt\/srt\/tsv\/json output<\/td>\n<td>Small jobs, reproducing reference behavior<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/SYSTRAN\/faster-whisper\">faster-whisper<\/a><\/td>\n<td>CTranslate2 backend, int8\/fp16, built-in Silero VAD, batched pipeline<\/td>\n<td>Bulk transcription<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/m-bain\/whisperX\">WhisperX<\/a><\/td>\n<td>faster-whisper backend plus wav2vec2 forced alignment and pyannote diarization<\/td>\n<td>Precise word timing, speaker labels<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The faster-whisper README claims up to 4x the speed of openai\/whisper at the same accuracy with less memory, and publishes a benchmark: 13 minutes of audio with large-v2 on an RTX 3070 Ti took 1m03s unbatched and 17s with <code>batch_size=8<\/code> (fp16). That's roughly 46x real time for that one file on that GPU. Treat it as an order of magnitude, not a plan.<\/p>\n<h3>faster-whisper basics<\/h3>\n<p>The model constructor takes <code>device<\/code> (<code>\"cuda\"<\/code>, <code>\"cpu\"<\/code> or <code>\"auto\"<\/code>) and <code>compute_type<\/code> (<code>\"float16\"<\/code>, <code>\"int8_float16\"<\/code>, <code>\"int8\"<\/code> and others). <code>transcribe()<\/code> returns a <em>generator<\/em> of segments plus a <code>TranscriptionInfo<\/code>; nothing is decoded until you iterate:<\/p>\n<pre><code>from faster_whisper import WhisperModel\n\nmodel = WhisperModel(\"large-v3\", device=\"cuda\", compute_type=\"float16\")\nsegments, info = model.transcribe(\n    \"audio.opus\",\n    vad_filter=True,\n    word_timestamps=True,\n    condition_on_previous_text=False,\n)\nfor s in segments:  # decoding happens here\n    print(f\"[{s.start:.2f} -&gt; {s.end:.2f}] {s.text}\")<\/code><\/pre>\n<p>Audio is decoded with PyAV, so faster-whisper doesn't need a system ffmpeg. Feed it the native Opus or M4A you downloaded; see <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-audio-only-download-for-speech-datasets\/\">yt-dlp audio-only downloads for speech datasets<\/a> for getting those files without re-encoding.<\/p>\n<h2>VAD first: fewer hallucinations, honest hours<\/h2>\n<p>Whisper's model card states the problem directly: because it is trained on large-scale noisy data, \"the predictions may include texts that are not actually spoken in the audio input (i.e. hallucination)\". The <a href=\"https:\/\/arxiv.org\/abs\/2402.08021\">Careless Whisper<\/a> study found that roughly 1% of the transcriptions it examined contained entire hallucinated phrases or sentences, and that hallucinations occurred disproportionately for speakers with longer non-vocal stretches. Silence, music beds and applause are exactly where this happens.<\/p>\n<p>Voice-activity detection removes those stretches before the decoder sees them. The <a href=\"https:\/\/arxiv.org\/abs\/2303.00747\">WhisperX paper<\/a> also reports that VAD-based pre-segmentation improves long-form transcription quality and enables batching. In faster-whisper:<\/p>\n<ul>\n<li><strong>Sequential <code>WhisperModel.transcribe<\/code>:<\/strong> <code>vad_filter=False<\/code> by default. When enabled, the default is conservative and only removes silence longer than 2 seconds (<code>min_silence_duration_ms=2000<\/code>). Tune it with <code>vad_parameters=dict(min_silence_duration_ms=500)<\/code>.<\/li>\n<li><strong><code>BatchedInferencePipeline.transcribe<\/code>:<\/strong> <code>vad_filter=True<\/code> by default, with 160 ms minimum silence and speech chunks capped at the 30-second window. Disable VAD on a file longer than 30 seconds without passing <code>clip_timestamps<\/code> and it raises an error.<\/li>\n<\/ul>\n<p>A bonus: <code>info.duration_after_vad<\/code> is a free speech-duration measurement. Store it next to <code>info.duration<\/code>; it's the number behind \"hours\" discussed in <a href=\"https:\/\/globalcorpora.com\/blog\/speech-training-data-asr-tts-ready-audio\/\">what makes speech training data ASR- and TTS-ready<\/a>. VAD reduces hallucination on non-speech; it does not remove it, and it won't help with speech over loud music.<\/p>\n<h2>Known failure modes and the knobs that address them<\/h2>\n<table>\n<thead>\n<tr>\n<th>Failure<\/th>\n<th>What it looks like<\/th>\n<th>Mitigation<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Hallucination on non-speech<\/td>\n<td>Fluent sentences over silence, music or noise<\/td>\n<td>VAD; <code>no_speech_prob<\/code> filtering; <code>hallucination_silence_threshold<\/code> (requires word timestamps, sequential mode)<\/td>\n<\/tr>\n<tr>\n<td>Repetition loops<\/td>\n<td>The same phrase repeated dozens of times<\/td>\n<td><code>condition_on_previous_text=False<\/code>; compression-ratio checks; n-gram repetition filter<\/td>\n<\/tr>\n<tr>\n<td>Drift and bad timestamps<\/td>\n<td>Segment times seconds off on long files<\/td>\n<td>VAD segmentation; WhisperX forced alignment<\/td>\n<\/tr>\n<tr>\n<td>Wrong language<\/td>\n<td>English \"transcript\" of Spanish audio, or translated text<\/td>\n<td>Language-probability threshold, then re-run with a fixed <code>language<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The model card notes that the sequence-to-sequence architecture \"makes it prone to generating repetitive texts, which can be mitigated to some degree by beam search and temperature scheduling but not perfectly\". faster-whisper's docstring for <code>condition_on_previous_text<\/code> spells out the trade-off: disabling it may make text less consistent across windows, \"but the model becomes less prone to getting stuck in a failure loop, such as repetition looping or timestamps going out of sync\". WhisperX sets it to <code>False<\/code> by default.<\/p>\n<p>The sequential decoder uses temperature fallback: if a window's gzip <code>compression_ratio<\/code> exceeds 2.4 or its <code>avg_logprob<\/code> is below -1.0, it is re-decoded at a higher temperature. A window counts as silent when <code>no_speech_prob<\/code> exceeds 0.6 <em>and<\/em> the log-probability is below the threshold. These are the same defaults in openai-whisper and faster-whisper.<\/p>\n<p>One thing that is easy to miss when reading the source: <strong>the batched pipeline decodes each chunk once, at the first temperature only<\/strong>, so the fallback never re-decodes a bad chunk. The metrics are still returned per segment. That makes post-hoc filtering mandatory, not optional, for batched runs.<\/p>\n<p>A cheap extra guard: count word trigrams per segment and flag any segment where one trigram repeats several times. It catches loops that a compression-ratio threshold alone misses on short segments.<\/p>\n<h2>Language detection<\/h2>\n<p>Without a <code>language<\/code> argument, Whisper detects the language from the first 30-second window (faster-whisper exposes <code>language_detection_segments<\/code> to use more windows, and runs detection on VAD-filtered audio in batched mode). <code>info.language<\/code>, <code>info.language_probability<\/code> and <code>info.all_language_probs<\/code> come back with the result.<\/p>\n<p>A workable pattern for large collections:<\/p>\n<ol>\n<li>Run detection, keep the probability in the manifest.<\/li>\n<li>Accept files above a confidence threshold you calibrate on a hand-checked sample.<\/li>\n<li>Re-run low-confidence files with an explicit <code>language<\/code>, or route them to review. For genuinely mixed-language audio, <code>multilingual=True<\/code> runs detection on every segment.<\/li>\n<\/ol>\n<p>Don't trust video metadata for this; title language and spoken language often differ.<\/p>\n<h2>A batched worker that writes JSONL<\/h2>\n<p>This worker reads a list of audio paths, writes one segments file per input, appends a per-file row to a manifest, and skips finished files on restart. Run one process per GPU (set <code>CUDA_VISIBLE_DEVICES<\/code>) and shard the file list across processes.<\/p>\n<pre><code># transcribe_worker.py\n# usage: python transcribe_worker.py files.txt out_dir\nimport json\nimport os\nimport sys\nimport time\nfrom pathlib import Path\n\nfrom faster_whisper import BatchedInferencePipeline, WhisperModel\n\nMODEL = \"large-v3\"           # or \"large-v3-turbo\"\nCOMPUTE_TYPE = \"float16\"     # \"int8_float16\" to save VRAM\nBATCH_SIZE = 16              # lower it if you hit out-of-memory\n\nmodel = WhisperModel(MODEL, device=\"cuda\", compute_type=COMPUTE_TYPE)\npipe = BatchedInferencePipeline(model=model)\n\n\ndef r(x):\n    return round(float(x), 3)\n\n\ndef transcribe(audio_path: Path, out_dir: Path) -&gt; dict:\n    out_path = out_dir \/ f\"{audio_path.stem}.segments.jsonl\"\n    tmp_path = out_dir \/ f\"{audio_path.stem}.segments.tmp\"\n    t0 = time.monotonic()\n    segments, info = pipe.transcribe(\n        str(audio_path),\n        batch_size=BATCH_SIZE,\n        vad_filter=True,\n        word_timestamps=True,\n    )\n    n = 0\n    with tmp_path.open(\"w\", encoding=\"utf-8\") as f:\n        for s in segments:\n            row = {\n                \"audio_id\": audio_path.stem,\n                \"seg\": n,\n                \"start\": r(s.start),\n                \"end\": r(s.end),\n                \"text\": s.text.strip(),\n                \"avg_logprob\": r(s.avg_logprob),\n                \"compression_ratio\": r(s.compression_ratio),\n                \"no_speech_prob\": r(s.no_speech_prob),\n                \"words\": [\n                    {\"w\": w.word, \"start\": r(w.start), \"end\": r(w.end), \"p\": r(w.probability)}\n                    for w in (s.words or [])\n                ],\n            }\n            f.write(json.dumps(row, ensure_ascii=False) + \"\\n\")\n            n += 1\n    os.replace(tmp_path, out_path)  # only complete files get the final name\n    wall = time.monotonic() - t0\n    return {\n        \"audio_id\": audio_path.stem,\n        \"duration_s\": r(info.duration),\n        \"speech_s\": r(info.duration_after_vad),\n        \"language\": info.language,\n        \"language_probability\": r(info.language_probability),\n        \"n_segments\": n,\n        \"model\": MODEL,\n        \"compute_type\": COMPUTE_TYPE,\n        \"wall_s\": r(wall),\n        \"rtfx\": r(info.duration \/ wall) if wall &gt; 0 else None,\n    }\n\n\nif __name__ == \"__main__\":\n    file_list, out_dir = Path(sys.argv[1]), Path(sys.argv[2])\n    out_dir.mkdir(parents=True, exist_ok=True)\n    with (out_dir \/ \"manifest.jsonl\").open(\"a\", encoding=\"utf-8\") as manifest:\n        for line in file_list.read_text(encoding=\"utf-8\").splitlines():\n            if not line.strip():\n                continue\n            audio = Path(line.strip())\n            if (out_dir \/ f\"{audio.stem}.segments.jsonl\").exists():\n                continue\n            try:\n                row = transcribe(audio, out_dir)\n            except Exception as e:  # log and keep the worker alive\n                row = {\"audio_id\": audio.stem, \"error\": repr(e)}\n            manifest.write(json.dumps(row, ensure_ascii=False) + \"\\n\")\n            manifest.flush()<\/code><\/pre>\n<p>JSONL per file is easy to append, resume and grep. For training, compact it into Parquet or WebDataset shards later, as described in <a href=\"https:\/\/globalcorpora.com\/blog\/storing-video-datasets-webdataset-parquet-shards\/\">storing datasets as WebDataset and Parquet shards<\/a>. Record the model name, compute type and library versions in the manifest; a transcript without that provenance can't be regenerated or compared.<\/p>\n<h2>WhisperX: aligned words and speaker labels<\/h2>\n<p>Whisper's own word timestamps come from cross-attention and dynamic time warping. WhisperX adds a second pass that force-aligns the transcript to a language-specific wav2vec2 phoneme model, then optionally assigns speakers using pyannote. From the <a href=\"https:\/\/github.com\/m-bain\/whisperX\">WhisperX README<\/a>:<\/p>\n<pre><code>import whisperx\nfrom whisperx.diarize import DiarizationPipeline\n\ndevice = \"cuda\"\naudio = whisperx.load_audio(\"audio.opus\")\n\nmodel = whisperx.load_model(\"large-v3\", device, compute_type=\"float16\")\nresult = model.transcribe(audio, batch_size=16)\n\nmodel_a, metadata = whisperx.load_align_model(language_code=result[\"language\"], device=device)\nresult = whisperx.align(result[\"segments\"], model_a, metadata, audio, device,\n                        return_char_alignments=False)\n\ndiarize_model = DiarizationPipeline(token=\"HF_TOKEN\", device=device)\ndiarize_segments = diarize_model(audio)\nresult = whisperx.assign_word_speakers(diarize_segments, result)<\/code><\/pre>\n<p>Caveats from the README itself: diarization needs a Hugging Face token and acceptance of the <a href=\"https:\/\/huggingface.co\/pyannote\/speaker-diarization-community-1\">pyannote speaker-diarization-community-1<\/a> user agreement; words without characters in the alignment model's dictionary (for example \"2014.\" or \"\u00a313.60\") get no timing; overlapping speech is handled poorly; \"diarization is far from perfect\"; and alignment needs a wav2vec2 model for each language. If you only need segment-level text, the alignment and diarization passes are extra GPU time you can skip.<\/p>\n<h2>Throughput math<\/h2>\n<p>Use <strong>RTFx<\/strong> = audio seconds processed \/ wall-clock seconds, measured per GPU on your audio, model, batch size and compute type. Then:<\/p>\n<ul>\n<li><code>GPU-hours = audio_hours \/ RTFx<\/code><\/li>\n<li><code>wall-clock hours = audio_hours \/ (RTFx &times; number_of_GPUs)<\/code><\/li>\n<\/ul>\n<p>Which \"audio hours\" you plug in depends on whether RTFx was measured against file duration or post-VAD duration. The worker above measures against file duration, so VAD savings are already included.<\/p>\n<p>Worked example with <strong>assumed<\/strong> numbers, not measurements: 100,000 file hours, a pilot RTFx of 40 per GPU.<\/p>\n<table>\n<thead>\n<tr>\n<th>GPUs<\/th>\n<th>GPU-hours<\/th>\n<th>Wall-clock<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>8<\/td>\n<td>100,000 \/ 40 = 2,500<\/td>\n<td>2,500 \/ 8 = 312.5 h (~13 days)<\/td>\n<\/tr>\n<tr>\n<td>32<\/td>\n<td>2,500<\/td>\n<td>2,500 \/ 32 &asymp; 78 h (~3.3 days)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>If a turbo pilot measures RTFx 100 on the same data, GPU-hours drop to 1,000. Whether that's worth the accuracy cost is decided by the WER check below, not by the speed table.<\/p>\n<p>For a trustworthy RTFx, run a pilot of a few dozen hours stratified like the full collection (lengths, languages, speech ratio). Throughput depends on speech density and words spoken, so a pilot of clean audiobooks overstates speed on talk shows. Watch non-GPU bottlenecks too: CPU audio decoding, network storage reads, and per-file overhead on very short files.<\/p>\n<h2>Quality checks: WER against manual subtitles<\/h2>\n<p>When a video has creator-uploaded subtitles, you have a free reference. Download them with yt-dlp's <code>--write-subs<\/code> and keep the <code>info.json<\/code> so you can tell manual from automatic tracks; <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-download-subtitles-auto-captions\/\">our subtitles guide<\/a> covers the details. Don't use YouTube's auto-captions as a reference: they are another ASR system's output.<\/p>\n<p>Normalize both sides the same way, then score with <a href=\"https:\/\/github.com\/jitsi\/jiwer\">jiwer<\/a>. The normalizers ship with openai-whisper (<code>pip install openai-whisper jiwer<\/code>):<\/p>\n<pre><code>import jiwer\nfrom whisper.normalizers import EnglishTextNormalizer  # BasicTextNormalizer for other languages\n\nnormalize = EnglishTextNormalizer()\n\ndef agreement(reference_text: str, hypothesis_text: str) -&gt; dict:\n    ref = normalize(reference_text)\n    hyp = normalize(hypothesis_text)\n    out = jiwer.process_words(ref, hyp)\n    return {\n        \"wer\": out.wer,\n        \"substitutions\": out.substitutions,\n        \"deletions\": out.deletions,\n        \"insertions\": out.insertions,\n    }<\/code><\/pre>\n<p>Concatenate per file rather than matching subtitle cues to segments one by one; cue boundaries and segment boundaries don't line up. Since jiwer 4.0, an empty reference is allowed and every hypothesis word counts as an insertion, which is useful for testing hallucination on known-silent clips.<\/p>\n<p>Interpret the number carefully. Manual subtitles are frequently not verbatim: fillers and false starts are dropped, sentences are condensed, and some tracks are translations. A high score can mean bad ASR <em>or<\/em> a loose reference. Use it to:<\/p>\n<ul>\n<li><strong>Compare models and settings<\/strong> on the same files (large-v3 vs turbo, int8 vs fp16, VAD settings).<\/li>\n<li><strong>Find outliers:<\/strong> files with very high disagreement usually have wrong language, music, or a hallucination loop.<\/li>\n<li><strong>Calibrate filters<\/strong> for files that have no subtitles, using the segment metrics.<\/li>\n<\/ul>\n<p>Combine it with cheap per-segment checks that need no reference: <code>compression_ratio<\/code> above 2.4, <code>no_speech_prob<\/code> high with text present, words per second outside a plausible range, repeated n-grams, and segments whose word timestamps all collapse to one point. Then hand-audit a random sample of what passes, not only what fails.<\/p>\n<h2>Compliance<\/h2>\n<p>If the audio comes from YouTube, its Terms of Service restrict automated access and downloading. Copyright and licensing apply to the recordings and arguably to transcripts derived from them; some teams restrict collection to <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">Creative Commons material<\/a>. Voices and transcribed speech can be personal data under GDPR and similar laws, and diarization creates per-speaker records. Keep provenance per file, honor takedown and opt-out requests, and get legal review for your jurisdiction and use case.<\/p>\n<h2>If you'd rather not run the collection side yourself<\/h2>\n<p>Corpora's managed service delivers YouTube audio, subtitles (including manual tracks, where they exist, for use as references) and metadata as JSONL\/Parquet with sha256 checksums and manifests to S3, GCS or Azure Blob, starting with a free sample batch. Teams that run their own yt-dlp stack can use <a href=\"https:\/\/globalcorpora.com\/#pricing\">dedicated unmetered proxy capacity<\/a> instead. Transcription stays on your GPUs either way.<\/p>\n<h2>FAQ<\/h2>\n<h3>Is faster-whisper as accurate as openai-whisper?<\/h3>\n<p>It runs the same Whisper weights converted to CTranslate2, and its README claims the same accuracy at higher speed. Defaults differ (faster-whisper uses beam size 5, openai-whisper's <code>transcribe<\/code> uses 1), and int8 quantization or batched mode can shift results, so compare on a sample with identical settings.<\/p>\n<h3>Should I use large-v3 or large-v3-turbo?<\/h3>\n<p>Turbo has 809M parameters and a 4-layer decoder, and OpenAI describes the quality loss as minor. For high-resource languages and clean speech it is often the better trade; for low-resource languages, measure both on a labeled sample before deciding.<\/p>\n<h3>How do I stop Whisper from hallucinating on silence?<\/h3>\n<p>Run VAD before decoding (<code>vad_filter=True<\/code> in faster-whisper), disable <code>condition_on_previous_text<\/code>, and filter segments on <code>no_speech_prob<\/code>, <code>compression_ratio<\/code> and repetition afterwards. With word timestamps in sequential mode, <code>hallucination_silence_threshold<\/code> skips long silences when a hallucination is suspected. None of these remove the problem completely.<\/p>\n<h3>How long will it take to transcribe 10,000 hours?<\/h3>\n<p>Wall-clock hours = 10,000 \/ (RTFx &times; GPUs). Measure RTFx on a representative pilot with your exact model, batch size and compute type; at an assumed RTFx of 40, that's 250 GPU-hours.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Whisper transcription at scale: large-v3 vs turbo, faster-whisper batching, WhisperX alignment, VAD against hallucinations, throughput math and WER checks.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[34,107,33,106,108],"class_list":["post-39","post","type-post","status-publish","format-standard","hentry","category-guides","tag-asr","tag-faster-whisper","tag-speech-datasets","tag-whisper","tag-whisperx"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/39","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/comments?post=39"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/39\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=39"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=39"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=39"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}