{"id":40,"date":"2026-11-19T03:38:19","date_gmt":"2026-11-19T03:38:19","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/speaker-diarization-pyannote-speech-datasets\/"},"modified":"2026-11-19T03:38:19","modified_gmt":"2026-11-19T03:38:19","slug":"speaker-diarization-pyannote-speech-datasets","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/speaker-diarization-pyannote-speech-datasets\/","title":{"rendered":"Speaker Diarization with pyannote for Speech Datasets"},"content":{"rendered":"<p>A speech dataset scraped from podcasts, interviews and talk shows is useless for TTS until you know who is speaking when, and only half useful for ASR. Speaker diarization answers that question, and pyannote.audio is the open-source default for it. This guide covers what diarization outputs, which pyannote pipeline to use as of pyannote.audio 4.1, how to measure DER, and how to turn the output into single-speaker clips and speaker-attributed Whisper transcripts.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Pipeline:<\/strong> <code>pyannote\/speaker-diarization-community-1<\/code> on pyannote.audio 4.x. <code>speaker-diarization-3.1<\/code> is now labelled legacy. Both are gated on Hugging Face: accept the conditions, then pass a token.<\/li>\n<li><strong>Output:<\/strong> (start, end, speaker) turns, saved as RTTM. Labels like <code>SPEAKER_00<\/code> mean nothing outside their file.<\/li>\n<li><strong>Two outputs since 4.0:<\/strong> <code>speaker_diarization<\/code> keeps overlapping speech; <code>exclusive_speaker_diarization<\/code> allows one speaker at a time, which is what you want for aligning words.<\/li>\n<li><strong>For TTS,<\/strong> keep only turns with no overlap and no other speaker within a safety margin.<\/li>\n<li><strong>Measure DER on hand-labelled files from your own sources.<\/strong> pyannote's published numbers range from under 10% to nearly 50% depending on the domain.<\/li>\n<li><strong>Plan GPU time with a formula<\/strong> and a speed you measured yourself.<\/li>\n<\/ul>\n<h2>What speaker diarization outputs<\/h2>\n<p>Diarization splits a recording into speech turns and gives each turn an anonymous speaker label. It does not identify people. pyannote writes the result as RTTM:<\/p>\n<pre><code>SPEAKER ep0412 1 6.665 4.120 &lt;NA&gt; &lt;NA&gt; SPEAKER_00 &lt;NA&gt; &lt;NA&gt;\nSPEAKER ep0412 1 10.580 2.310 &lt;NA&gt; &lt;NA&gt; SPEAKER_01 &lt;NA&gt; &lt;NA&gt;\nSPEAKER ep0412 1 12.400 0.910 &lt;NA&gt; &lt;NA&gt; SPEAKER_00 &lt;NA&gt; &lt;NA&gt;<\/code><\/pre>\n<p>Field 2 is the file URI, field 4 the start in seconds, field 5 the <em>duration<\/em> (not the end time) and field 8 the speaker. <code>Annotation.write_rttm()<\/code> in pyannote.core rejects URIs and labels that contain spaces, because the format is space-separated. Two things to remember: turns can overlap when people talk at once, and labels are per file. <code>SPEAKER_00<\/code> in one episode has nothing to do with <code>SPEAKER_00<\/code> in the next.<\/p>\n<h2>Which pyannote pipeline to use<\/h2>\n<p>pyannote.audio 4.1.0 was released on PyPI on 17 November 2026 and requires Python 3.11 or newer. Version 4.0.0 (September 2025) introduced <code>community-1<\/code>, which switched from agglomerative clustering to VBx clustering and added exclusive diarization. The <a href=\"https:\/\/github.com\/pyannote\/pyannote-audio\">pyannote-audio README<\/a> lists three pipelines:<\/p>\n<table>\n<thead>\n<tr>\n<th>Pipeline<\/th>\n<th>Runs<\/th>\n<th>License<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/huggingface.co\/pyannote\/speaker-diarization-community-1\">speaker-diarization-community-1<\/a><\/td>\n<td>Locally<\/td>\n<td>CC-BY-4.0<\/td>\n<td>Regular and exclusive diarization, plus per-speaker embeddings<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/huggingface.co\/pyannote\/speaker-diarization-3.1\">speaker-diarization-3.1<\/a><\/td>\n<td>Locally<\/td>\n<td>MIT<\/td>\n<td>Legacy; mono 16 kHz input, downmixed and resampled automatically<\/td>\n<\/tr>\n<tr>\n<td>speaker-diarization-precision-2<\/td>\n<td>pyannoteAI servers<\/td>\n<td>Commercial<\/td>\n<td>pyannoteAI API key; audio leaves your infrastructure<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>A selection from the README's benchmark (DER %, updated 2025-09). These are the maintainers' own numbers:<\/p>\n<table>\n<thead>\n<tr>\n<th>Dataset<\/th>\n<th>3.1 (legacy)<\/th>\n<th>community-1<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>VoxConverse v0.3<\/td>\n<td>11.2<\/td>\n<td>11.2<\/td>\n<\/tr>\n<tr>\n<td>AMI (IHM)<\/td>\n<td>18.8<\/td>\n<td>17.0<\/td>\n<\/tr>\n<tr>\n<td>DIHARD 3 (full)<\/td>\n<td>21.4<\/td>\n<td>20.2<\/td>\n<\/tr>\n<tr>\n<td>AVA-AVD<\/td>\n<td>49.7<\/td>\n<td>44.6<\/td>\n<\/tr>\n<tr>\n<td>Ego4D (dev.)<\/td>\n<td>51.2<\/td>\n<td>46.8<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a href=\"https:\/\/github.com\/joonson\/voxconverse\">VoxConverse<\/a> is built from multi-speaker clips extracted from YouTube videos and scores far better than movies (AVA-AVD) or egocentric video (Ego4D). Your error rate will depend more on your source mix than on the pipeline version.<\/p>\n<h3>Setup and gated access<\/h3>\n<p>Install ffmpeg (since 4.0, audio is decoded by torchcodec; the sox and soundfile backends are gone), then <code>pip install pyannote.audio<\/code>. On Hugging Face, accept the user conditions on the community-1 page: the repository is public, but its files are gated. Create an access token and keep it in an environment variable. Older tutorials stop working for two reasons: 4.0 renamed <code>use_auth_token=<\/code> to <code>token=<\/code> and replaced <code>name@revision<\/code> with a <code>revision=<\/code> argument. For air-gapped nodes, the changelog shows how to <code>git clone<\/code> the pipeline repo with git-lfs and pass the local path to <code>Pipeline.from_pretrained()<\/code>. Optional usage telemetry can be turned off with <code>PYANNOTE_METRICS_ENABLED=0<\/code>.<\/p>\n<h2>The Python API<\/h2>\n<pre><code>import os\nimport torch\nfrom pyannote.audio import Pipeline\n\npipeline = Pipeline.from_pretrained(\n    \"pyannote\/speaker-diarization-community-1\",\n    token=os.environ[\"HF_TOKEN\"],\n)\npipeline.to(torch.device(\"cuda\"))\n\noutput = pipeline(\"ep0412.wav\")                      # speaker count estimated\noutput = pipeline(\"ep0412.wav\", num_speakers=2)      # exactly 2\noutput = pipeline(\"ep0412.wav\", min_speakers=1, max_speakers=6)\n\nfor turn, speaker in output.speaker_diarization:\n    print(f\"{turn.start:.2f} {turn.end:.2f} {speaker}\")<\/code><\/pre>\n<p>Details from <code>SpeakerDiarization.apply<\/code> in the source:<\/p>\n<ul>\n<li><code>min_speakers<\/code>\/<code>max_speakers<\/code> are ignored when <code>num_speakers<\/code> is set. If the detected count falls outside the bounds, the pipeline warns instead of failing.<\/li>\n<li>It returns a <code>DiarizeOutput<\/code> with <code>speaker_diarization<\/code>, <code>exclusive_speaker_diarization<\/code> and <code>speaker_embeddings<\/code> (one row per speaker, in <code>labels()<\/code> order). The legacy 3.1 pipeline returns a plain <code>Annotation<\/code>.<\/li>\n<li>Unknown keyword arguments only produce a warning, so a typo like <code>max_speaker<\/code> is silently ignored.<\/li>\n<li>Audio you have already decoded can be passed as <code>{\"waveform\": tensor, \"sample_rate\": sr}<\/code>.<\/li>\n<\/ul>\n<p>Only fix a speaker count you can trust. A podcast with \"2 hosts\" in its description also has guests, ad reads and clips, so loose bounds usually beat a confident wrong number.<\/p>\n<h2>A worker that writes RTTM and a manifest<\/h2>\n<pre><code># diarize_worker.py\n# usage: HF_TOKEN=... python diarize_worker.py files.txt out_dir\nimport json\nimport os\nimport sys\nimport time\nfrom pathlib import Path\n\nimport torch\nfrom pyannote.audio import Pipeline\n\nPIPELINE = \"pyannote\/speaker-diarization-community-1\"\npipeline = Pipeline.from_pretrained(PIPELINE, token=os.environ[\"HF_TOKEN\"])\npipeline.to(torch.device(\"cuda\"))\n\n\ndef diarize(audio: Path, out_dir: Path) -&gt; dict:\n    uri = audio.stem  # no spaces allowed in RTTM\n    t0 = time.monotonic()\n    out = pipeline(str(audio), min_speakers=1, max_speakers=8)\n    wall = time.monotonic() - t0\n    diar, excl = out.speaker_diarization, out.exclusive_speaker_diarization\n    diar.uri = excl.uri = uri\n    with (out_dir \/ f\"{uri}.rttm\").open(\"w\") as f:\n        diar.write_rttm(f)\n    with (out_dir \/ f\"{uri}.exclusive.rttm\").open(\"w\") as f:\n        excl.write_rttm(f)\n    return {\n        \"audio_id\": uri,\n        \"pipeline\": PIPELINE,\n        \"n_speakers\": len(diar.labels()),\n        \"speech_s\": round(diar.get_timeline().support().duration(), 3),\n        \"overlap_s\": round(diar.get_overlap().duration(), 3),\n        \"speaker_s\": {spk: round(d, 3) for spk, d in diar.chart()},\n        \"wall_s\": round(wall, 3),\n    }\n\n\nif __name__ == \"__main__\":\n    files, 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 m:\n        for line in files.read_text(encoding=\"utf-8\").splitlines():\n            audio = Path(line.strip())\n            if not line.strip() or (out_dir \/ f\"{audio.stem}.rttm\").exists():\n                continue\n            try:\n                row = diarize(audio, out_dir)\n            except Exception as e:\n                row = {\"audio_id\": audio.stem, \"error\": repr(e)}\n            m.write(json.dumps(row) + \"\\n\")\n            m.flush()<\/code><\/pre>\n<p>Overlap ratio, dominant-speaker share and speaker count become cheap filter columns, the same properties discussed in <a href=\"https:\/\/globalcorpora.com\/blog\/speech-training-data-asr-tts-ready-audio\/\">what makes speech data ASR- and TTS-ready<\/a>. Record library versions alongside the pipeline name, as the <a href=\"https:\/\/globalcorpora.com\/blog\/training-data-documentation-datasheets-provenance\/\">provenance guide<\/a> recommends.<\/p>\n<h2>Overlapped speech<\/h2>\n<p>pyannote's segmentation model handles overlap directly (the powerset formulation from Plaquet and Bredin, Interspeech 2023). Version 4.0 dropped the separate overlapped-speech-detection pipeline because overlap is part of the diarization output; <code>diar.get_overlap()<\/code> returns it as a <code>Timeline<\/code>. What to do with it depends on what you're training:<\/p>\n<ul>\n<li><strong>TTS \/ voice cloning:<\/strong> drop overlapped regions and any clip that touches them.<\/li>\n<li><strong>ASR:<\/strong> a transcript holds one word stream, so overlapped words get lost or mixed. Keep overlap only if your labels can represent it.<\/li>\n<li><strong>Conversational models:<\/strong> overlap is signal. Keep the regular output.<\/li>\n<\/ul>\n<h2>Selecting single-speaker segments for TTS<\/h2>\n<p>A turn with a single label isn't automatically clean. A backchannel (\"mm-hm\") a few hundred milliseconds away, or a boundary that is slightly off, puts a second voice into the clip. This function keeps a span only if it is long enough once overlap is removed <em>and<\/em> no other speaker is active within a margin around it:<\/p>\n<pre><code>from pyannote.core import Annotation, Segment\n\n\ndef single_speaker_clips(diar: Annotation, min_dur=2.0, max_dur=20.0,\n                         margin=0.5, merge_gap=0.3):\n    \"\"\"Yield (speaker, start, end, needs_split) for clean single-speaker spans.\"\"\"\n    if not diar:\n        return\n    clean = diar.extrude(diar.get_overlap())       # remove overlapped time\n    for spk in clean.labels():\n        others = diar.subset([spk], invert=True).get_timeline().support()\n        for seg in clean.label_timeline(spk).support(merge_gap):\n            if seg.duration &lt; min_dur:\n                continue\n            guard = Segment(max(0.0, seg.start - margin), seg.end + margin)\n            if others.crop(guard).duration() &gt; 0:\n                continue                           # another speaker too close\n            yield spk, round(seg.start, 3), round(seg.end, 3), seg.duration &gt; max_dur<\/code><\/pre>\n<ul>\n<li><strong><code>margin<\/code><\/strong> trades yield for purity. Listen to 100 random clips at two settings and count contaminated ones.<\/li>\n<li><strong><code>merge_gap<\/code><\/strong> joins short pauses. The margin check runs after merging, so an interjection inside a merged span still rejects it.<\/li>\n<li><strong>Long spans<\/strong> are flagged, not cut. Split them at Whisper word boundaries so no clip ends mid-word.<\/li>\n<\/ul>\n<p>Diarization only tells you who spoke. Music beds, noise and clipping need their own filters.<\/p>\n<h2>Combining diarization with Whisper or WhisperX timestamps<\/h2>\n<p>To attribute a transcript, assign each word to the speaker whose turn overlaps it most. Use the <em>exclusive<\/em> diarization here: pyannote added it specifically to make it easier to reconcile diarization with \"sometimes not so precise\" transcription timestamps. With the per-word JSONL from <a href=\"https:\/\/globalcorpora.com\/blog\/whisper-transcription-at-scale-speech-datasets\/\">our Whisper at scale guide<\/a> (fields <code>w<\/code>, <code>start<\/code>, <code>end<\/code>):<\/p>\n<pre><code>from pyannote.core import Annotation, Segment\n\n\ndef label_words(words: list[dict], excl: Annotation) -&gt; list[dict]:\n    \"\"\"Attach the speaker with the longest overlap to each word.\"\"\"\n    for w in words:\n        start, end = w[\"start\"], w[\"end\"]\n        if end &lt;= start:                       # zero-length word timestamps\n            start, end = start - 0.05, end + 0.05\n        w[\"speaker\"] = excl.argmax(Segment(max(0.0, start), end))  # None if no overlap\n    return words<\/code><\/pre>\n<p>Then group consecutive same-speaker words into utterances. Words left with <code>None<\/code> fall between turns. They are often hallucinations or speech the diarizer missed, so check them before dropping.<\/p>\n<p><a href=\"https:\/\/github.com\/m-bain\/whisperX\">WhisperX<\/a> builds this in. Its <code>DiarizationPipeline(token=..., device=...)<\/code> wraps pyannote (community-1, per its README), and <code>whisperx.assign_word_speakers()<\/code> labels aligned words. Its README states the limits plainly: overlapping speech isn't handled well, \"diarization is far from perfect\", and words that can't be aligned, like \"2014.\" or \"\u00a313.60\", get no timing.<\/p>\n<h2>Measuring DER with pyannote.metrics<\/h2>\n<p><code>DER = (false alarm + missed detection + speaker confusion) \/ total reference speech<\/code><\/p>\n<p>Confusion is counted after the optimal one-to-one mapping between hypothesis and reference labels. False alarm is unbounded, so DER can exceed 100%. Always report <code>collar<\/code> (seconds ignored around reference boundaries) and <code>skip_overlap<\/code> with the number. Both default to 0.0 and False in pyannote.metrics.<\/p>\n<pre><code>from pyannote.core import Annotation\nfrom pyannote.database.util import load_rttm\nfrom pyannote.metrics.diarization import DiarizationErrorRate\n\nrefs = load_rttm(\"reference.rttm\")      # {uri: Annotation}\nhyps = load_rttm(\"hypothesis.rttm\")\n\nmetric = DiarizationErrorRate(collar=0.0, skip_overlap=False)\nfor uri, ref in refs.items():\n    d = metric(ref, hyps.get(uri, Annotation(uri=uri)), detailed=True)\n    print(uri, round(d[\"diarization error rate\"], 3), \"miss\", round(d[\"missed detection\"], 1),\n          \"fa\", round(d[\"false alarm\"], 1), \"conf\", round(d[\"confusion\"], 1))\n\nprint(\"overall DER:\", round(abs(metric), 3))<\/code><\/pre>\n<p>If references cover only part of each file, pass a UEM (<code>uem=<\/code>, loadable with <code>load_uem<\/code>). The components tell you more than the total. High confusion means speakers were merged or split, which hurts TTS. High miss or false alarm means speech-detection errors, which distort hour counts. Build the reference set from your own sources, stratified by source type, and check clip purity with <a href=\"https:\/\/globalcorpora.com\/blog\/measuring-curated-dataset-accuracy-audits-wilson-intervals\/\">audit sampling and confidence intervals<\/a>.<\/p>\n<h2>GPU throughput: reason with a formula<\/h2>\n<p>Measure <strong>s\/h<\/strong>, the wall-clock seconds per hour of audio on one GPU, on your own files. Then:<\/p>\n<ul>\n<li><code>GPU-hours = audio_hours &times; s\/h \/ 3600<\/code><\/li>\n<li><code>wall-clock hours = GPU-hours \/ number_of_GPUs<\/code><\/li>\n<\/ul>\n<p>The README publishes one reference point: community-1 self-hosted on an NVIDIA H100 80GB took 31 s per hour of audio on AMI (~1-hour files) and 37 s on DIHARD 3 (~5-minute files). <em>If<\/em> 31 s\/h held for your data, 100,000 hours would take 100,000 &times; 31 \/ 3600 &asymp; 861 H100-hours. Use that to size a pilot, not to promise a deadline.<\/p>\n<ul>\n<li><strong>Sliding windows:<\/strong> by the constructor default, segmentation windows overlap by 90%, and one embedding is extracted per (window, local speaker slot). Cost grows with duration, and clustering grows with the embedding count, so time very long files separately.<\/li>\n<li><strong>Batching:<\/strong> <code>segmentation_batch_size<\/code> and <code>embedding_batch_size<\/code> control GPU batches. Raise them while watching VRAM.<\/li>\n<li><strong>Decoding:<\/strong> CPU-side ffmpeg decoding can starve the GPU. Decode once and share the waveform with Whisper, or run several workers per GPU.<\/li>\n<li><strong>Stacked passes:<\/strong> Whisper, alignment and diarization each add their own s\/h.<\/li>\n<\/ul>\n<h2>Common failure modes<\/h2>\n<table>\n<thead>\n<tr>\n<th>Failure<\/th>\n<th>What you see<\/th>\n<th>Mitigation<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Music and singing<\/td>\n<td>Speech detected over music beds; a singer becomes a \"speaker\"<\/td>\n<td>Music\/speech classifier first; drop low speech-ratio files or regions<\/td>\n<\/tr>\n<tr>\n<td>Laughter, applause, crowd noise<\/td>\n<td>Short false-alarm turns, sometimes a new speaker<\/td>\n<td>Drop very short turns; ignore speakers with tiny total time<\/td>\n<\/tr>\n<tr>\n<td>Short turns, backchannels<\/td>\n<td>\"Yeah\", \"right\" missed or absorbed by the main speaker<\/td>\n<td>Margin check above; clip purity audits<\/td>\n<\/tr>\n<tr>\n<td>Similar voices<\/td>\n<td>Two hosts merged into one label<\/td>\n<td>Compare speaker-count distribution with metadata; set <code>min_speakers<\/code> only when known<\/td>\n<\/tr>\n<tr>\n<td>One voice split in two<\/td>\n<td>Same person labelled twice after a mic change, phone segment or shouting<\/td>\n<td>Compare <code>speaker_embeddings<\/code> within a file; merge only after checking a sample<\/td>\n<\/tr>\n<tr>\n<td>Inserted clips, voice-overs<\/td>\n<td>Extra speakers from ads, trailers, quoted videos<\/td>\n<td>Keep only dominant speakers for TTS<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>A quick sanity check: plot <code>n_speakers<\/code> per source. If a solo-commentary channel shows four speakers in many files, the cause is usually music or noise, not guests.<\/p>\n<h2>Compliance<\/h2>\n<p>If the audio comes from YouTube, its Terms of Service restrict automated access and downloading, and copyright and licensing apply to the recordings. Some teams restrict collection to <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">Creative Commons material<\/a>. Voices are personal data under GDPR and similar laws. Speaker embeddings are designed to tell people apart, so some jurisdictions may treat them as biometric data, and hosted pipelines send the audio to a third party. 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 and metadata as JSONL\/Parquet with sha256 checksums and manifests to S3, GCS or Azure Blob, starting with a free sample batch. Diarization and transcription stay on your GPUs. Teams running their own yt-dlp stack (see <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-audio-only-download-for-speech-datasets\/\">audio-only downloads for speech datasets<\/a>) can use <a href=\"https:\/\/globalcorpora.com\/#pricing\">dedicated unmetered proxy capacity<\/a> instead.<\/p>\n<h2>FAQ<\/h2>\n<h3>Is pyannote speaker-diarization-3.1 still usable?<\/h3>\n<p>Yes. It's MIT-licensed, but the README labels it legacy. In the published benchmark, community-1 matches or beats it everywhere except REPERE, and adds exclusive diarization. When upgrading code to 4.x, change <code>use_auth_token<\/code> to <code>token<\/code> and handle the <code>DiarizeOutput<\/code> return type.<\/p>\n<h3>Why do I get a 401 or \"gated repo\" error?<\/h3>\n<p>The files are gated. Accept the user conditions on the model page with the same Hugging Face account that owns the token, then pass it with <code>token=<\/code>. Accepting with a personal account and using a CI account's token produces the same error.<\/p>\n<h3>How do I keep speaker labels consistent across files?<\/h3>\n<p>pyannote doesn't; labels are per file. Cluster <code>output.speaker_embeddings<\/code> across files or compare them with enrolled reference voices, and validate on a labelled sample. A false merge across files does more damage to TTS than a missed one.<\/p>\n<h3>What is a good DER?<\/h3>\n<p>It depends on the domain and the collar and overlap settings. pyannote's community-1 numbers run from about 9% (REPERE) to about 47% (Ego4D). Set a target from the downstream use: confusion matters most for TTS purity, miss and false alarm matter most for hour counts.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Speaker diarization with pyannote.audio 4.x for speech datasets: RTTM output, community-1, DER, overlap, Whisper word alignment and single-speaker TTS clips.<\/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":[109,64,33,110,106],"class_list":["post-40","post","type-post","status-publish","format-standard","hentry","category-guides","tag-pyannote","tag-speaker-diarization","tag-speech-datasets","tag-tts-data","tag-whisper"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/40","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=40"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/40\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=40"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=40"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=40"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}