tiny-aya-translate/tr-hi-mimi-encoded

TR↔HI Mimi-Encoded Parallel Speech

Pre-encoded parallel Turkish↔Hindi speech pairs for training speech-to-speech translation models. All audio has been tokenized through the Mimi neural audio codec (8 codebooks, 12.5 Hz, 24kHz) and stored as .pt files with word-level text alignments.

Dataset Summary

Source audio	~911 hours of synthetic parallel TR↔HI speech from tr-hi-parallel-speech-v2
TTS model	OmniVoice (voice design mode, 14 voice designs)
Text sources	FLORES (2K), OPUS-100 (9K), machine-translated conversational datasets (~45K)
Codec	Mimi — 8 codebooks at 12.5 Hz
Total encoded pairs	~1.24M train / ~65K val (full split)
Quality-filtered subset	~25K train / ~500 val
Directions	Bidirectional: Turkish→Hindi and Hindi→Turkish
QC	Round-trip ASR validation with faster-whisper (large-v3), 86% pass rate at WER ≤ 0.20

Files

Encoded Audio (packed as tars)

Each tar contains .pt files and their corresponding alignment JSONs:

mimi_encoded_batch1_tars0-12.tar.gz
mimi_encoded_batch3.tar.gz
...
mimi_encoded_batch10.tar.gz

Each .pt file contains:

{
    "src_codes": tensor([8, T_src]),   # source audio Mimi codes (8 codebooks × T frames)
    "tgt_codes": tensor([8, T_tgt]),   # target audio Mimi codes
    "src_text": str,                    # source language text
    "tgt_text": str,                    # target language text
    "src_lang": str, "tgt_lang": str,   # e.g. "tr" / "hi"
    "src_duration_s": float, "tgt_duration_s": float,
    "pair_id": str, "voice": str,
    "direction": str,                   # "tr->hi" or "hi->tr"
}

Each .pt file has two companion alignment JSONs, which map words to Mimi's 12.5 Hz frame grid for text-audio interleaving during training:

• {stem}.src.alignments.json — source-language word-level timestamps
• {stem}.tgt.alignments.json — target-language word-level timestamps

⚠️ Read this before writing a loader

The alignment paths inside splits/*.jsonl do not resolve as written. The manifests were generated with an earlier naming scheme and record encoded/{stem}_src.json. The files this dataset actually ships are {stem}.src.alignments.json / {stem}.tgt.alignments.json, and they extract to the data root — not into encoded/.

That is a double mismatch, in both the filename and the directory. It is not hypothetical: a checker that looked for the manifest's names found zero hits and the corpus was wrongly believed to have no text alignments at all, so two model releases trained audio-only before it was caught. There are 840,426 of each kind, at 100% coverage.

Resolve alignments by trying, in order: the manifest path as-is → encoded/

• basename → data_root/{stem}.{src,tgt}.alignments.json. A reference implementation is StreamingTranslationDataset._resolve_alignment in the model repo.

Splits

splits/
├── train.jsonl          # Full training split (~1.24M rows)
├── val.jsonl            # Full validation split (~65K rows)
├── train_26k.jsonl      # Quality-filtered 26K subset
└── val_500.jsonl        # Quality-filtered 500-sample val set

Each JSONL row:

{
    "pt_path": "encoded/conv_13222_female_young_hi_rev.pt",
    "direction": "hi->tr",
    "pair_id": "conv_13222",
    "voice": "female_young_hi",
    "src_align_path": "encoded/conv_13222_female_young_hi_rev_src.json",
    "tgt_align_path": "encoded/conv_13222_female_young_hi_rev_tgt.json"
}

The two *_align_path values above are reproduced verbatim from the shipped manifests and are stale — see the warning above for the paths that actually exist on disk.

26K Subset Construction

The train_26k.jsonl and val_500.jsonl splits are a quality-filtered subset designed for initial training experiments under compute constraints. Construction criteria:

• QC pass: only pairs that passed round-trip ASR validation (WER ≤ 0.20)
• Duration: source + target between 2–30 seconds
• Completeness: both source and target .pt files and alignment JSONs must exist
• Leak-free splitting: rows are grouped by pair_id before splitting, so the same text pair in different voices always lands in the same split
• Direction balance: approximately equal TR→HI and HI→TR samples

The full 1.24M split contains all encoded pairs including those that didn't pass strict QC, for teams that want to apply their own filtering.

Quality Control

Generated audio was validated using a round-trip ASR pipeline:

1. Transcribe each generated audio clip with faster-whisper (large-v3)
2. Compute WER against the original text prompt
3. Accept if WER ≤ 0.20 and duration is between 0.5s–30s

Additional metrics computed (available in the QC pipeline):

• DNSMOS — perceptual audio quality (neural MOS predictor)
• SNR — signal-to-noise ratio
• VAD speech ratio — fraction of clip containing actual speech
• CER — character error rate

Overall pass rate: 86% across validated shards. Failures concentrated in extreme voice designs (e.g., male_old_deep) and very long sentences.

Voice Designs

14 OmniVoice voice designs used for speaker diversity:

default, female_young_hi, male_mid_hi, female_high, male_elderly,
female_mid, male_young, female_brit, male_deep, female_teen,
male_teen, male_old_deep, female_old_low, male_old_russian

Usage

from huggingface_hub import hf_hub_download
import json, torch

# Download a split
split = hf_hub_download(
    "tiny-aya-translate/tr-hi-mimi-encoded",
    "splits/train_26k.jsonl",
    repo_type="dataset"
)

# Load a sample
with open(split) as f:
    row = json.loads(f.readline())

# Download and load the .pt file
pt_file = hf_hub_download(
    "tiny-aya-translate/tr-hi-mimi-encoded",
    row["pt_path"],
    repo_type="dataset"
)
data = torch.load(pt_file, weights_only=False)
print(data["src_codes"].shape)  # [8, T_src]
print(data["tgt_codes"].shape)  # [8, T_tgt]

For training with the model repo:

python scripts/train_hierarchical.py \
    --config configs/gpu/stage2_26k_parallel.yaml \
    --train_split splits/train_26k.jsonl \
    --val_split splits/val_500.jsonl \
    --encoded_dir encoded/

Related

• Model training code
• Data generation pipeline — private repo, not publicly browsable
• Audio QC pipeline
• Raw parallel speech (911h)
• Text pairs

Citation

@misc{tinyaya_tr_hi_mimi_encoded,
    title  = {TR-HI Mimi-Encoded Parallel Speech Dataset},
    author = {tiny-aya-translate},
    year   = {2026},
    url    = {https://huggingface.co/datasets/tiny-aya-translate/tr-hi-mimi-encoded}
}

Where this sits

The v0.3 speech-to-speech pipeline, end to end:

tr-hi-parallel-text          text triples (en pivot -> tr / hi)
        |  TTS
tr-hi-parallel-speech-v2     synthetic speech + QC signals
        |  Mimi encode
tr-hi-mimi-encoded           8-codebook tokens + word alignments
        |  Stage-2 training
tr-hi-s2st-v0.3              the released model

Model	tr-hi-s2st-v0.3
Text	tr-hi-parallel-text
Speech	tr-hi-parallel-speech-v2 · -v3
Encoded	tr-hi-mimi-encoded
Eval sets	fleurs-tr-hi-mimi-encoded · lahaja-eval · cv-tr-eval

Code

repo	what it does
model	Stage-2 training, evaluation harness and TPU launch tooling
sound-quality-check	4-stage speech-dataset quality control

Project

TinyAya Stage 2 — Turkish⇄Hindi speech-to-speech translation with a text inner-monologue: a LoRA-adapted Cohere2 backbone driving a frozen Moshi depth decoder over Mimi codes.

The v0.3 run covered 76,250 steps / 2.07 epochs on a Cloud TPU v6e-16 (best val composite 2.8199 @ step 76,000). Read honestly: the text inner-monologue learns to translate (free-run chrF++ ~25.7 / 25.1), while intelligible audio synthesis remains the frontier (ASR-chrF++ 3.7 / 9.6 against a 92.1 / 86.6 ground-truth-audio ceiling) — bounded by the frozen depth decoder, not by translation understanding.

• Results: v0.3 evaluation report
• Training run: W&B xzcb60bl · emergence report
• Blog: Adapting Moshi for Low-Resource Speech Translation

Compute for the v0.3 run was provided by Google's TPU Research Cloud (TRC).