The tokenized training data of DACFlow-EN-10k, an English text-to-speech model with zero-shot voice cloning (VoiceHub/DACFlow-EN-10k). The training source SynDataLab-EN/echo-clones-4m-en in the form the model reads (codec latents), with each clip's text and voice: 3,748,029 clips, which is all 3,983,250 clips of the source except the 235,221 of the 236 voices held out for evaluation. With it, the exact list of the 3,400,911 clips the model trains on.

"10k" in the name: about ten thousand hours of English speech (9,543 h in the training list, 10,837 h in the shards).

Want to listen? The model's own samples are on VoiceHub/DACFlow-EN-10k. This repo holds no audio.


The model	VoiceHub/DACFlow-EN-10k, which trains on this data
Made from	SynDataLab-EN/echo-clones-4m-en (revision `aebc7c787c64`)
In the shards	3,748,029 clips, 10,837 hours, 3,764 voices
The training list (`echo_en_v1`)	3,400,911 clips, 9,543 hours, 3,587 voices (version `data-4255c6734a7d5b5e`)
Size	1,501 files, 250.8 GB
Licence	apache-2.0 (see Provenance and licence)

What a "token" is here

The model never sees waveforms. An audio codec, Semantic-DACVAE (codec id Aratako/Semantic-DACVAE-Japanese@737fbad2a679f880), turned each clip into latents: 25 frames per second, each frame a list of 128 numbers (stored as float16). The model learns to generate these frames from a text and a short voice prompt, and the codec's decoder turns frames back into 48 kHz audio. They are continuous numbers, not IDs from a vocabulary: "tokenized" here means "turned into codec frames". A 4-second sentence is 100 frames x 128 numbers = 25.6 kB, about 15 times smaller than the same audio as 16-bit samples.

Files

path	what is inside	files	size
`tts_en/latents/echo_en/shard-<tag>-NNNNNN.bin`	the latents of about 7,511 clips back to back: float16, 128 numbers per frame, 25 frames per second	499	249.7 GB
`tts_en/latents/echo_en/shard-<tag>-NNNNNN.idx.json`	where each clip starts in the `.bin` (`offsets`, in frames) and how long it is (`n_frames`); `keys`, `dim`, `dtype` and the codec id	499	154.5 MB
`tts_en/latents/echo_en/shard-<tag>-NNNNNN.meta.parquet`	one row per clip, in the same order: `key`, `text`, `speaker` (the voice), `duration` (seconds), `orig_sr`, `license`, and `source` + `id` (`<source file>-<row>`: the clip's row in the source dataset)	499	501.1 MB
`tts_en/catalogs/echo_en_v1/catalog.parquet`	the exact training list: one row per clip the model trains on (The catalog)	1	486.5 MB
`tts_en/catalogs/echo_en_v1/version.json`	how that list was made: the filters, the hours, how many clips each filter dropped	1	13.3 kB
`tts_en/latent_stats.json`	the mean and std of each of the 128 numbers (`latstats-c07cbda91e95`): the model works on (latent - mean) / std	1	6.0 kB
`tts_en/silence_latent.npy`	the latent of silence (1 x 128, float32): the model pads voice prompts with it	1	640 B
`release/`	`manifest.jsonl` (every file above with its size and sha256), `release.json` (the numbers on this page)	2	-

<tag> = g<time_ns>-<group> names one processing group (16 source parquet files); there are 499.

What is not here

No audio. To listen, use the model's samples on VoiceHub/DACFlow-EN-10k, the source dataset's viewer, or decode a clip yourself (Hear a clip).
No REPA targets, annotations or evaluation sets. You do not need them to read, decode or train on these latents; the project keeps them in its working backup VoiceHub/DACFlow-EN-10k-backup.
Not the source dataset. The original audio and texts are SynDataLab-EN/echo-clones-4m-en; each clip's source + id points to its row there.
Not usable with another codec. The latents belong to this exact codec version: Hub revision 96adcf1937e1 of Aratako/Semantic-DACVAE-Japanese. Its weights.pth is the codec id 737fbad2a679f880 above (the project's fingerprint of the weights): two ids, one version.

How to use

Download

Everything is 250.8 GB. One group (about 7,511 clips) is enough to try it:

from huggingface_hub import snapshot_download

tag = "g1790656525369654176-00001"  # any group; release/manifest.jsonl lists every file
local = snapshot_download("VoiceHub/DACFlow-EN-10k-data", repo_type="dataset", local_dir="DACFlow-EN-10k-data",
                          allow_patterns=[f"tts_en/latents/echo_en/*{tag}*", "tts_en/latent_stats.json", "tts_en/catalogs/*"])  # + the catalog: 486.5 MB

No allow_patterns: everything.

Read one clip (numpy only)

import json

import numpy as np
import pyarrow.parquet as pq

shard = f"{local}/tts_en/latents/echo_en/shard-{tag}-000000"
idx = json.load(open(shard + ".idx.json"))  # keys, offsets, n_frames, dim, dtype
meta = pq.read_table(shard + ".meta.parquet").to_pylist()  # one row per clip: key, text, speaker, duration, source, id, ...
lat = np.memmap(shard + ".bin", dtype=idx["dtype"], mode="r").reshape(-1, idx["dim"])
i = 0
z = np.asarray(lat[idx["offsets"][i] : idx["offsets"][i] + idx["n_frames"][i]], np.float32)  # [frames, 128], 25 frames per second
print(meta[i]["speaker"], meta[i]["text"], z.shape)

Hear a clip

import soundfile as sf
import torch
from dacvae import DACVAE  # pip install git+https://github.com/facebookresearch/dacvae
from huggingface_hub import hf_hub_download

weights = hf_hub_download("Aratako/Semantic-DACVAE-Japanese", "weights.pth", revision="96adcf1937e1ff46ec0817a07c80f2d7d64998f0")  # the codec version of these latents
codec = DACVAE.load(weights).eval()
codec.decoder.alpha = 0.0  # this codec was fine-tuned without the watermark: bypass it, as its model card does
codec.decoder.watermark = lambda x, message=None, d=codec.decoder: d.wm_model.encoder_block.forward_no_conv(x)
with torch.no_grad():
    wav = codec.decode(torch.from_numpy(z).T[None])[0, 0].numpy()  # z from 'Read one clip', as stored -> 48 kHz audio
sf.write("clip.wav", wav, codec.sample_rate)

Decode the latents as they are stored (no normalization). The audio is the same, sample for sample, as the project's own decoder gives.

The catalog: the exact training list

tts_en/catalogs/echo_en_v1/catalog.parquet has one row per clip the model trains on: 3,400,911 rows, of which 3,346 are the val split (held back to watch the training) and the rest train. Columns: key, text, speaker (echo_en:<voice>), n_frames, n_tokens, shard + offset (where its latents are: a path relative to tts_en/ and the first frame), split, rate (characters per second), asr_cer_min, lead_sil_ms / trail_sil_ms, and a few columns you can ignore (ssl_shard / ssl_offset, dnsmos, emotion_label, ...).

177 voices in the shards (176,403 clips) are not in the catalog; they are kept for the unseen-voice test, so train from the catalog.

import numpy as np
import pyarrow.parquet as pq

cat = pq.read_table(f"{local}/tts_en/catalogs/echo_en_v1/catalog.parquet", columns=["key", "text", "speaker", "shard", "offset", "n_frames", "split"],
                    filters=[("shard", "==", f"latents/echo_en/shard-{tag}-000000.bin")])  # the rows of the group you downloaded
row = cat.slice(0, 1).to_pylist()[0]
lat = np.memmap(f"{local}/tts_en/{row['shard']}", dtype=np.float16, mode="r").reshape(-1, 128)
z = np.asarray(lat[row["offset"] : row["offset"] + row["n_frames"]], np.float32)
print(row["split"], row["speaker"], row["text"], z.shape)

How the list was made, from every clip in the shards:

clips left out because of	clips	hours
(every clip in the shards)	3,748,029	10,837.1
the 177 echo-unseen voices (kept for the unseen-voice test)	176,403	488.5
a pause longer than 6 s inside the clip	124,610	651.3
the clip ran into EchoTTS's length cap with silence (a generation failure)	17,770	123.4
more text than the audio can hold (more text tokens than latent frames)	26,949	27.4
a speech recognizer heard other words (Parakeet CER > 0.3)	1,300	3.1
the sentence is in an evaluation set	86	0.1
kept: the training list	3,400,911	9,543.3

A clip that fails several filters is counted once. All the filters and their exact settings are in version.json.

How it was made

Read every source parquet file of SynDataLab-EN/echo-clones-4m-en once, 16 at a time (3,983,250 clips). The clips of the 236 voices held out for evaluation (235,221) were set aside: none of them is here.
Encode each clip at 48 kHz with the codec's encoder (exact fp32) and store the mean of its latent as float16.
Check every clip (a speech recognizer's transcript and score, the silences) and filter them into the catalog, leaving out the echo-unseen voices and any sentence of an evaluation set.
Publish the training latents, the catalog and the statistics here; each file is checked against the Hub's own record of it (size and sha256), and release/manifest.jsonl lists them all.

Provenance and licence

This dataset: apache-2.0 (owner decision, 2026-09-29).
Source: SynDataLab-EN/echo-clones-4m-en; its card states apache-2.0. Its speech was generated with EchoTTS (jordand/echo-tts-base, cc-by-nc-sa-4.0 on its card) from the reference voices of SynDataLab-EN-Refs/echo-ref-speakers-4k-en and the texts of SynDataLab-EN-Refs/echo-4m-text-en (neither card states a licence). Check these terms yourself before any commercial use.
All of the speech is synthetic (EchoTTS voice clones); there are no real recordings here.
Models used to make it (each under its own licence; none of their weights are here): Aratako/Semantic-DACVAE-Japanese (MIT, the codec), nvidia/parakeet-ctc-1.1b (CC BY 4.0, the filter's transcripts).

Models trained or fine-tuned on VoiceHub/DACFlow-EN-10k-data

VoiceHub/DACFlow-EN-10k

Text-to-Speech • Updated 3 minutes ago

DACFlow-EN-10k-data