anilkeshwani/mls-focalcodec

MLS English with FocalCodec 50 Hz units

The English part of Multilingual LibriSpeech (MLS; Pratap et al., 2020) with each utterance encoded as discrete speech units by FocalCodec at 50 Hz, whose binary spherical quantizer (BSQ) has 13 bits and so 8192 codes, together with the transcript, three derived word-level views of it and word-level forced alignments. Audio is not included.

This dataset was used to train Llama 3.2 1B on speech units by supervised fine-tuning (SFT, speech in, transcript out) and continued pretraining (CPT) in the speech-integration project, which compares HuBERT, SpeechTokenizer, Mimi and FocalCodec units. The same files feed SFT and CPT. Interleaved CPT uses the word alignments to switch between speech and text at word boundaries.

Splits

Split	Rows	Files	Path
train	10,808,037	54	data/train-*.parquet
validation	3,807	1	data/validation-*.parquet
test	3,769	1	data/test-*.parquet

Row counts of the codes_only config, from the remote parquet footers:

Split	Rows	Files	Path
train	10,808,037	37	train/*.parquet
validation	3,807	1	dev/*.parquet
test	3,769	1	test/*.parquet

The split names follow the datasets convention: the MLS dev split is validation.

Configs in this repo

• default: the parquet files under data/, with the same 11 columns in the same order as anilkeshwani/mls-hubert_large_ll60k-layer_22. The FocalCodec codes are in speech_tokens.
• codes_only: the original upload (August 2025) under train/, dev/ and test/, with only ID and focalcodec_tokens. The codes are the same as in default. Load it with load_dataset("anilkeshwani/mls-focalcodec", "codes_only"). Code that called load_dataset("anilkeshwani/mls-focalcodec") and expected focalcodec_tokens needs this config name now.

The default files were built from the codes-only files and the HuBERT repo, whose rows are in the same order in every split. transcript, duration, tokenized and the two alignment columns were joined by scripts/data/join_mls_focalcodec_transcripts.py --with_alignments of the speech-integration project; sample_rate, num_samples, normalized and uroman were attached from the HuBERT repo during the conversion to parquet, which asserted equal IDs for every row.

Verification of the default files

Split	Rows (local source)	Rows (parquet)	Sampled rows	ID and codes equal to codes_only	Text, duration and alignment columns equal to the HuBERT repo
train	10,808,037	10,808,037	20,000	20,000 of 20,000	all 9 columns equal for 20,000 of 20,000
validation	3,807	3,807	3,807 (all)	3,807 of 3,807	all 9 columns equal for 3,807 of 3,807
test	3,769	3,769	3,769 (all)	3,769 of 3,769	all 9 columns equal for 3,769 of 3,769

Rows were sampled uniformly without replacement (seed 20261028) and compared by SHA-256 of the ID with the int64 codes, and of each text, duration and alignment value, against the remote files at anilkeshwani/mls-focalcodec@d5abd20 and anilkeshwani/mls-hubert_large_ll60k-layer_22@a2dc02b. The remote files were checked against the SHA-256 the Hub reports for them. During the conversion every row of every split was also checked: same ID as the HuBERT repo at the same position, and equal transcript, duration, tokenized and alignment times.

Columns

Column	Type	Description
ID	string	MLS utterance ID, <speaker>_<book>_<utterance> (for example 10226_10111_000000). Unique.
transcript	string	The MLS English transcript as released (lower case, no punctuation).
duration	float64	Audio duration in seconds (num_samples / sample_rate). MLS segments are 10 to 20 s long.
sample_rate	float64	Sample rate of the source FLAC audio, 16000 for every row.
num_samples	int64	Number of audio samples in the source FLAC file.
tokenized	list of string	transcript split on whitespace: the words, in order.
normalized	list of string	Each word of tokenized after MMS text normalization (see below). Same length as tokenized.
uroman	list of string	Each normalized word romanized with uroman, letters separated by spaces (for example t i m o t h y). Same length as tokenized. This is the input to the forced aligner.
speech_tokens	list of int64	Unit sequence at the encoder frame rate, 50 Hz (one unit per 20 ms, 320 samples at 16 kHz), before any deduplication: consecutive repeats are kept. Values are codebook indices in [0, 8191] (8192 codes). Length is about duration x frame rate.
aligned_token_start_time	list of float64	Start time in seconds of each word of tokenized, from the forced alignment. Same length as tokenized.
aligned_token_end_time	list of float64	End time in seconds of each word of tokenized. Same length as tokenized.

Speech units

• Codebook size: 8192 (values 0 to 8191)
• Frame rate: 50 Hz (one unit per 20 ms, 320 samples at 16 kHz)
• Stored as: int64, one list per utterance, the raw encoder output with consecutive repeats kept

The script that encoded the audio is not in the project repositories. The following configuration reproduces the stored units (October 2026 check on 100 MLS English FLAC files: lengths equal for all, 99.45% of units equal, 5 of 100 utterances identical). Every mismatch is a flip of exactly one of the 13 BSQ bits at a frame whose latent is close to zero (median |latent| 8.6e-5 at mismatched frames against 5.9e-3 over all frames), so the differences come from floating-point noise. Half precision or padded batching gave clearly lower agreement (72% to 97%), which shows the stored units were made in fp32 without padding.

• Model: lucadellalib/focalcodec_50hz (revision d6d6d9524e52155c85193c2c3b8da1cf8842f019; the weights have not changed since 2025-02-11), with the focalcodec code at commit 68be6ce (February 2025, current when this repo was first uploaded in August 2025).
• Input: the 16 kHz MLS FLAC audio, mono, unpadded and unbatched, in fp32.
• Codes: model.sig_to_toks(x), one 13-bit BSQ code (0 to 8191) per 20 ms frame.

In the speech-integration project, consecutive repeated units are removed when a sample is built (speech.deduplicate, on by default). For the BPE variants, BPE is then applied on the fly to the deduplicated sequence with the small merge models in anilkeshwani/speech-integration-speech-bpe. Neither step changes the stored data.

Transcripts and text fields

The four text columns are views of the same MLS transcript, produced by scripts/uromanize.py of speech-text-alignment:

1. transcript: the transcript from the MLS English release, unchanged.
2. tokenized: transcript.strip().split().
3. normalized: each word passed through text_normalize (sardalign/text_normalization.py, the text normalization of the MMS forced-alignment recipe with the English configuration): Unicode normalization, lower casing, removal of punctuation and of words made only of digits, whitespace collapsed. MLS English is already lower case without punctuation, so normalized equals tokenized in every row checked (all 3,807 dev rows and the first 100,000 train rows).
4. uroman: each normalized word romanized with uroman (Uroman.romanize_string_core, language eng), then split into space-separated characters and restricted to a to z, apostrophe and space (normalize_uroman). This is the character sequence the aligner sees.

Word alignments

aligned_token_start_time and aligned_token_end_time give one interval in seconds per word of tokenized, on the time axis of the original 16 kHz audio. They are independent of the speech tokenizer, so the same times apply to every repo in this family and can be mapped to unit positions by multiplying by the frame rate.

They were produced by CTC forced alignment with the MMS forced-alignment model, in scripts/align_and_hubert_encode.py and sardalign/align.py of speech-text-alignment:

• Acoustic model: the multilingual MMS alignment model over uroman characters (https://dl.fbaipublicfiles.com/mms/torchaudio/ctc_alignment_mling_uroman/model.pt and its dictionary.txt), a wav2vec 2.0 model with 24 transformer layers and 31 output characters, loaded with torchaudio.models.wav2vec2_model (sardalign/utils/align.py, load_mms_aligner_model_and_dict). This is the model of the fairseq MMS data preparation recipe and of torchaudio's MMS_FA pipeline.
• Emissions: computed in 30 s windows with 10% context on each side, log-softmax over characters, one frame per about 20 ms.
• Alignment: torchaudio.functional.forced_align (Viterbi CTC alignment) of the uroman character sequence of the whole transcript, without a <star> token.
• Word spans: consecutive character segments are grouped into words (get_spans). A word's span is extended into the neighboring silence (blank) segments: up to the midpoint of each inner silence, and to the start of the leading or end of the trailing silence for the first and last word. Times are frame index x frame stride (get_span_times). So the first word usually starts at 0.0 and adjacent words share a boundary.

The script skips an utterance when its alignment fails (empty transcript, or a transcript too long for CTC alignment). No MLS English utterance was skipped: the dataset has all 10,808,037 train, 3,807 dev and 3,769 test utterances of the release.

Loading

import math

from datasets import load_dataset

ds = load_dataset("anilkeshwani/mls-focalcodec", split="validation")
row = ds[0]
print(row["ID"], row["transcript"])
print(len(row["speech_tokens"]), "units for", row["duration"], "s")

# word-level view: units that fall inside each word
rate = 50  # units per second
for word, start, end in zip(row["tokenized"], row["aligned_token_start_time"], row["aligned_token_end_time"]):
    print(word, row["speech_tokens"][int(start * rate) : math.ceil(end * rate)][:10])

The train split is large (10.8M rows). Use streaming=True or data_files to read part of it.

Provenance

• Audio and transcripts: MLS English, the 16 kHz FLAC release from OpenSLR (https://www.openslr.org/94/).
• Text processing and word alignment: speech-text-alignment (paths above refer to commit 09b39af).
• Units: see "Speech units" above.
• Use: the speech-integration project repository (data configs conf/data/{sft,cpt}/mls-focalcodec*.yaml). That repository was not public at the time of writing.
• This card was written in October 2026. It was added without changing any data file.

License

The data are released under the Creative Commons Attribution 4.0 International license (CC BY 4.0), the license of MLS. The transcripts are those of MLS, and the units and alignments are derived from MLS audio. When you use this dataset, attribute MLS by citing Pratap et al. (2020) below. MLS also asks users not to attempt to determine the identity of its speakers.

The models used to compute the units and alignments have their own licenses and this dataset contains none of their weights or code: FocalCodec (Apache 2.0). The word alignments come from the MMS forced-alignment model (CC BY-NC 4.0). The CC BY-NC 4.0 terms of the MMS license cover that model's weights and code, and the license texts do not address outputs such as the alignments released here; we release them under CC BY 4.0. Whether non-commercial model terms reach a model's outputs is not settled. If you plan commercial use, check this for your jurisdiction.

Citation

If you use this dataset, please cite MLS and the speech tokenizer:

MLS (Pratap et al., Interspeech 2020):

@inproceedings{pratap2020mls,
  title     = {{MLS}: A Large-Scale Multilingual Dataset for Speech Research},
  author    = {Pratap, Vineel and Xu, Qiantong and Sriram, Anuroop and Synnaeve, Gabriel and Collobert, Ronan},
  booktitle = {Interspeech 2020},
  pages     = {2757--2761},
  year      = {2020},
  publisher = {ISCA},
  doi       = {10.21437/Interspeech.2020-2826},
  eprint    = {2012.03411},
  archivePrefix = {arXiv}
}

FocalCodec (Della Libera et al., NeurIPS 2025):

@inproceedings{dellalibera2025focalcodec,
  title     = {{FocalCodec}: Low-Bitrate Speech Coding via Focal Modulation Networks},
  author    = {Della Libera, Luca and Paissan, Francesco and Subakan, Cem and Ravanelli, Mirco},
  booktitle = {Advances in Neural Information Processing Systems (NeurIPS)},
  year      = {2025},
  url       = {https://openreview.net/forum?id=7Z3wQSu3mH},
  eprint    = {2502.04465},
  archivePrefix = {arXiv}
}

MMS, whose forced-alignment model produced the word alignments (Pratap et al., JMLR 2024):

@article{pratap2024mms,
  title   = {Scaling Speech Technology to 1,000+ Languages},
  author  = {Pratap, Vineel and Tjandra, Andros and Shi, Bowen and Tomasello, Paden and Babu, Arun and Kundu, Sayani and Elkahky, Ali and Ni, Zhaoheng and Vyas, Apoorv and Fazel-Zarandi, Maryam and Baevski, Alexei and Adi, Yossi and Zhang, Xiaohui and Hsu, Wei-Ning and Conneau, Alexis and Auli, Michael},
  journal = {Journal of Machine Learning Research},
  volume  = {25},
  number  = {97},
  pages   = {1--52},
  year    = {2024},
  url     = {http://jmlr.org/papers/v25/23-1318.html},
  eprint  = {2305.13516},
  archivePrefix = {arXiv}
}

uroman (Hermjakob et al., ACL 2018 demos):

@inproceedings{hermjakob2018uroman,
  title     = {Out-of-the-box Universal {R}omanization Tool uroman},
  author    = {Hermjakob, Ulf and May, Jonathan and Knight, Kevin},
  editor    = {Liu, Fei and Solorio, Thamar},
  booktitle = {Proceedings of {ACL} 2018, System Demonstrations},
  pages     = {13--18},
  month     = jul,
  year      = {2018},
  address   = {Melbourne, Australia},
  publisher = {Association for Computational Linguistics},
  doi       = {10.18653/v1/P18-4003}
}

Related repos

• anilkeshwani/mls-hubert_large_ll60k-layer_22: HuBERT Large layer 22 k-means 5000 units, 50 Hz
• anilkeshwani/mls-speechtokenizer-rvq_0: SpeechTokenizer RVQ level 0 units, 50 Hz
• anilkeshwani/mls-mimi-srvq_0: Mimi split-RVQ level 0 (semantic) units, 12.5 Hz
• anilkeshwani/speech-integration-eval-sets: ASR test sets and LibriSpeech dev analysis sets with the same four tokenizers
• anilkeshwani/speech-integration-speech-bpe: BPE models over the deduplicated units of each tokenizer
• anilkeshwani/mls-speechtokenizer: all eight SpeechTokenizer RVQ levels (source of mls-speechtokenizer-rvq_0)
• anilkeshwani/mls-mimi: all eight Mimi split-RVQ levels (source of mls-mimi-srvq_0)
• Collection: Speech units for LLM speech integration (MLS English)