A clean, multi-speaker synthetic speech corpus for Ngiemboon (NNH), a Grassfields Bantu language of western Cameroon. Each item pairs a cleaned NNH sentence with machine-generated speech audio, intended for training and fine-tuning small, on-device text-to-speech (TTS) models for this low-resource language.

⚠️ Synthetic data. The audio is generated by a TTS model (not recorded from human speakers). See How the data was generated and Limitations.

Dataset summary

Property	Value
Language	Ngiemboon / `nnh` (Cameroon)
Task	Text-to-speech (TTS)
Audio	Mono, 24 000 Hz, WAV bytes embedded in Parquet
Speakers	6 reference voices (see Speakers)
Sentences	~44 000 cleaned NNH segments
Total samples (target)	~264 000 (each sentence × each speaker)
Source text	Derived from `mimba/text2text` (`nnh_fra`)
Generation model	OmniVoice (k2-fsa), zero-shot clone-by-reference

⚡ How to use (audio is stored as bytes — read this)

The audio column is not a plain array: it is stored as a struct {"bytes": <WAV file bytes>, "path": None}. This is the standard, self-contained way to ship audio inside Parquet, and it is exactly the internal representation of the 🤗 datasets Audio feature. The HF web viewer shows the raw bytes, but in code you decode them in one of two ways.

Option A — Let `datasets` decode it (recommended)

Cast the column to the Audio feature; decoding then happens automatically on access.

from datasets import load_dataset, Audio

ds = load_dataset("mimba/nnh-tts-dataset", split="train")
ds = ds.cast_column("audio", Audio(sampling_rate=24000))

sample = ds[0]
print(sample["id"], "|", sample["speaker_id"], "|", sample["gender"])
print(sample["text"])

audio = sample["audio"]              # {'array': np.float32[...], 'sampling_rate': 24000, 'path': None}
print(audio["array"].shape, audio["sampling_rate"])

Option B — Decode the bytes yourself (always works)

The bytes are a complete WAV file, so soundfile reads them directly from memory.

import io
import soundfile as sf
from datasets import load_dataset

ds = load_dataset("mimba/nnh-tts-dataset", split="train")
sample = ds[0]

audio_bytes = sample["audio"]["bytes"]
array, sr = sf.read(io.BytesIO(audio_bytes))   # array: np.ndarray, sr: 24000
print(array.shape, sr)

Play it in a notebook

import IPython.display as ipd
ipd.display(ipd.Audio(array, rate=sr))

Save it to a .wav file

import soundfile as sf
sf.write("nnh_sample_0.wav", array, sr)

Stream instead of downloading everything (large dataset!)

With ~264k samples, prefer streaming when you only need to iterate.

from datasets import load_dataset
import io, soundfile as sf

ds = load_dataset("mimba/nnh-tts-dataset", split="train", streaming=True)
for sample in ds:
    array, sr = sf.read(io.BytesIO(sample["audio"]["bytes"]))
    text = sample["text"]
    # ... feed (text, array) to your pipeline ...
    break

Filter by speaker or gender

ds = load_dataset("mimba/nnh-tts-dataset", split="train")

female_only = ds.filter(lambda x: x["gender"] == "F")
one_speaker = ds.filter(lambda x: x["speaker_id"] == "spk_m2")

Example: prepare (text, audio) pairs for TTS fine-tuning

Most token-based TTS recipes (e.g. NeuTTS / Orpheus-style) need the raw waveform so they can encode it with a neural audio codec. This dataset is ready for that:

import io, soundfile as sf
from datasets import load_dataset

ds = load_dataset("mimba/nnh-tts-dataset", split="train")

def to_pair(sample):
    array, sr = sf.read(io.BytesIO(sample["audio"]["bytes"]))
    return {"text": sample["text"], "wav": array, "sr": sr}

# array + text are now ready to be tokenised by your codec (NeuCodec, SNAC, etc.)
example = to_pair(ds[0])
print(example["text"], example["wav"].shape, example["sr"])

Data fields

Field	Type	Description
`id`	`string`	Unique sample id, e.g. `spk_m2_001234`.
`speaker_id`	`string`	Reference voice id (`spk_m1` … `spk_f2`).
`gender`	`string`	`M` or `F` (label of the reference voice — see caveat below).
`text`	`string`	Cleaned NNH sentence (the spoken text).
`audio`	`dict`	`{"bytes": <WAV bytes, 24 kHz mono>, "path": None}`.
`sampling_rate`	`int`	Always `24000`.
`duration`	`float`	Audio duration in seconds.
`src_idx`	`int`	Row index in the source `mimba/text2text` (`nnh_fra`) for traceability.

Because the same sentence is spoken by every speaker, you get parallel data across voices (useful for multi-speaker training and voice cloning), and src_idx lets you map any sample back to its original verse.

Speakers

Six distinct NNH reference voices were used for zero-shot cloning. Each voice re-speaks the full set of sentences.

`speaker_id`	`gender` (label)
`spk_m1`	M
`spk_m2`	M
`spk_m3`	M
`spk_m4`	M
`spk_f1`	F
`spk_f2`	F

⚠️ Verify gender labels. Labels come from the generation configuration and were not re-checked acoustically for every voice. If gender matters for your use case, confirm by listening, or re-derive labels with a gender classifier before relying on them.

How the data was generated

Text comes from mimba/text2text (nnh_fra split), itself derived from Bible translations and other NNH sources.
The NNH text was cleaned and segmented: tonal diacritics (´ ˇ ^) and the modifier apostropheʼ(U+02BC) are **preserved as letters**; straight apostrophes were corrected toʼ; editorial punctuation (« » " " [ ] ( ) … – ) and non-breaking spaces were removed; sentences with digits and very short fragments were dropped; long verses were split on strong punctuation (then commas), with every final segment ending in ., ?or!`.
Audio was synthesized with OmniVoice (k2-fsa), a multilingual zero-shot TTS model that natively supports NNH, in clone-by-reference mode (language_id='nnh', deterministic config: num_step=32, temperatures = 0). Each sentence was rendered in each reference voice.
Output audio: float32 mono at 24 000 Hz, WAV-encoded and embedded as bytes, written in Parquet shards (e.g. data/spk_m2-00007.parquet).

Limitations and known issues

Synthetic, not human. All audio is model-generated. It inherits OmniVoice's NNH pronunciation and prosody, which may not perfectly match a native speaker, and can contain TTS artifacts.
Gender labels may be inconsistent for at least one speaker (see Speakers).
Source-text bias. The text is predominantly of biblical/religious origin, so vocabulary, register and domain are skewed accordingly and are not representative of everyday conversation.
Phoneme coverage depends on the source sentences; rare sounds may be under-represented.
No human validation of every sample. Spot-check before using at scale.

Licensing considerations

license: other is set deliberately. Before redistributing or using this dataset commercially, please verify:

the license/copyright of the source text (Bible translations and other sources behind mimba/text2text may carry their own terms), and
the licensing implications of the OmniVoice-generated audio for your intended use.

If you need a permissive, clearly-licensed corpus, confirm both of the above for your specific case.

Intended use

This dataset was built to fine-tune small, on-device TTS models (e.g. ~0.2B token-based models) so they can pronounce Ngiemboon and clone voices, as part of an offline mobile TTS effort for NNH. It can also serve as a base for adding expressive/non-verbal tags at a later fine-tuning stage.

Citation

If you use this dataset, please credit the Mimba project and OmniVoice (k2-fsa) as the speech generator, and cite the source-text dataset mimba/text2text.

Contact

For questions or contributions, please open a discussion in the "Community" tab of this repository.

BibTeX entry and citation info

@misc{
      title={nnh-tts-dataset: Small Out-of-domain resource for various africain languages}, 
      author={Mimba Ngouana Fofou},
      year={2026},
}

Contact For all questions contact @Mimba.

Downloads last month: 886

Total file size:

26 GB

Mimba NNH TTS Dataset — Ngiemboon Synthetic Speech