Datasets:

Aybee5
/

HausaTTSEmbed

	---
	language:
	- ha
	license: mit
	task_categories:
	- text-to-speech
	size_categories:
	- 1K<n<10K
	tags:
	- hausa
	- tts
	- speech
	- audio
	- multi-speaker
	pretty_name: Hausa TTS Dataset
	configs:
	- config_name: default
	data_files:
	- split: train
	path: data/**
	---

	# Hausa TTS Dataset (HausaTTSEmbed)

	This dataset contains 1,283 Hausa language audio recordings with transcriptions for Text-to-Speech (TTS) model training.

	## Dataset Details

	- Language: Hausa (ha)
	- Total Samples: 1,283
	- Speakers: 3 unique speakers
	- Audio Format: WAV files
	- Sample Rate: Original recordings (will be resampled to 24kHz during training)
	- Text Length: 4-141 characters (average: 24 characters)

	## Dataset Structure

	Each example contains:

	- audio: Audio file in WAV format
	- text: Hausa transcription with proper diacritics (e.g., "Ansamu ɓaraka acikin shirin")
	- speaker_id: UUID of the speaker (3 unique values)

	### Data Fields

	```python
	{
	'audio': {
	'path': str, # Path to audio file
	'array': ndarray, # Audio waveform
	'sampling_rate': int
	},
	'text': str, # Hausa transcription
	'speaker_id': str # Speaker identifier
	}
	```

	## Usage

	### Recommended: Download All Files First

	To ensure all audio files are available and avoid rate limits, authenticate first:

	```python
	from huggingface_hub import snapshot_download, HfApi
	from datasets import load_dataset, Audio
	import os
	import time

	# IMPORTANT: Login FIRST and WAIT for confirmation
	# Method 1: Using token directly (RECOMMENDED for Colab)
	from huggingface_hub import login
	HF_TOKEN = "hf_YourTokenHere" # Get from https://huggingface.co/settings/tokens
	login(token=HF_TOKEN)

	# Verify login worked
	api = HfApi()
	user_info = api.whoami(token=HF_TOKEN)
	print(f"✓ Logged in as: {user_info['name']}")

	# Small delay to ensure auth propagates
	time.sleep(2)

	# Download entire dataset (parquet + all audio files)
	print("\nDownloading dataset (~2GB)...")
	local_dir = snapshot_download(
	"Aybee5/HausaTTSEmbed",
	repo_type="dataset",
	local_dir="hausa_tts_data",
	token=HF_TOKEN, # Pass token explicitly
	max_workers=1, # Reduce concurrent requests to avoid rate limits
	resume_download=True # Resume if interrupted
	)

	# Load from downloaded files
	dataset = load_dataset(
	"parquet",
	data_files=f"{local_dir}/data/*.parquet",
	split="train"
	)

	# Fix audio paths to absolute paths
	dataset = dataset.map(lambda x: {"audio": os.path.join(local_dir, x["audio"]), **x})

	# Cast to Audio type
	dataset = dataset.cast_column("audio", Audio(sampling_rate=22050))

	print(f"✓ Loaded {len(dataset)} samples")

	# Access sample
	sample = dataset[0]
	print(f"Text: {sample['text']}")
	print(f"Audio shape: {sample['audio']['array'].shape}")
	```

	Alternative: Interactive Login (prompts for token)

	```python
	from huggingface_hub import login, snapshot_download
	import time

	# This will prompt you to paste your token
	login()
	time.sleep(2) # Wait for auth to propagate

	# Then download
	local_dir = snapshot_download(
	"Aybee5/HausaTTSEmbed",
	repo_type="dataset",
	local_dir="hausa_tts_data",
	max_workers=1 # Reduce concurrent requests
	)
	```

	### For Unsloth TTS Training (Complete Code)

	Use this complete code in your Unsloth/Colab notebook:

	```python
	from huggingface_hub import snapshot_download, login, HfApi
	from datasets import load_dataset, Audio
	import os
	import time

	# ==================== STEP 1: AUTHENTICATE ====================
	# Replace with your actual token from https://huggingface.co/settings/tokens
	HF_TOKEN = "hf_YourTokenHere"

	print("Authenticating with HuggingFace...")
	login(token=HF_TOKEN)

	# Verify authentication
	api = HfApi()
	user_info = api.whoami(token=HF_TOKEN)
	print(f"✓ Logged in as: {user_info['name']}\n")

	# Wait for auth to propagate
	time.sleep(2)

	# ==================== STEP 2: DOWNLOAD DATASET ====================
	print("Downloading Hausa TTS dataset (~2GB)...")
	print("Using reduced concurrency to avoid rate limits...\n")

	local_dir = snapshot_download(
	"Aybee5/HausaTTSEmbed",
	repo_type="dataset",
	local_dir="/content/hausa_tts", # Use /content/ for Colab
	token=HF_TOKEN, # Pass token explicitly
	max_workers=1, # Single threaded to avoid rate limits
	resume_download=True
	)

	print(f"✓ Downloaded to: {local_dir}\n")

	# ==================== STEP 3: LOAD DATASET ====================
	raw_ds = load_dataset(
	"parquet",
	data_files=f"{local_dir}/data/*.parquet",
	split="train"
	)

	# ==================== STEP 4: FIX AUDIO PATHS ====================
	raw_ds = raw_ds.map(lambda x: {"audio": os.path.join(local_dir, x["audio"]), **x})

	# ==================== STEP 5: HANDLE SPEAKERS ====================
	speaker_key = "source"
	if "source" not in raw_ds.column_names and "speaker_id" not in raw_ds.column_names:
	print("Unsloth: No speaker found, adding default source")
	new_column = ["0"] * len(raw_ds)
	raw_ds = raw_ds.add_column("source", new_column)
	elif "source" not in raw_ds.column_names and "speaker_id" in raw_ds.column_names:
	speaker_key = "speaker_id"

	# ==================== STEP 6: RESAMPLE AUDIO ====================
	target_sampling_rate = 24000
	raw_ds = raw_ds.cast_column("audio", Audio(sampling_rate=target_sampling_rate))

	print(f"✓ Dataset ready: {len(raw_ds)} samples")
	print(f"✓ Speaker column: {speaker_key}\n")

	# ==================== STEP 7: OPTIONAL SPLIT ====================
	split_ds = raw_ds.train_test_split(test_size=0.1, seed=42)
	train_ds = split_ds['train']
	val_ds = split_ds['test']

	print(f"✓ Train: {len(train_ds)} samples")
	print(f"✓ Validation: {len(val_ds)} samples")

	# Continue with your Unsloth training!
	```

	Key Changes to Avoid Rate Limits:
	1. ✅ Pass `token=HF_TOKEN` explicitly to `snapshot_download()`
	2. ✅ Set `max_workers=1` to reduce concurrent requests
	3. ✅ Add `time.sleep(2)` after login to ensure auth propagates
	4. ✅ Verify authentication with `api.whoami()` before downloading
	5. ✅ Use `resume_download=True` to handle interruptions

	### With Transformers

	```python
	from transformers import AutoProcessor

	processor = AutoProcessor.from_pretrained("your-tts-model")

	def preprocess_function(examples):
	audio_arrays = [x["array"] for x in examples["audio"]]

	inputs = processor(
	text=examples["text"],
	audio=audio_arrays,
	sampling_rate=24000,
	return_tensors="pt",
	padding=True
	)

	return inputs

	# Apply preprocessing
	processed_ds = dataset.map(
	preprocess_function,
	batched=True,
	remove_columns=dataset.column_names
	)
	```

	## Dataset Statistics

	- Total Samples: 1,283
	- Unique Speakers: 3
	- Text Statistics:
	- Average length: 24.0 characters
	- Min length: 4 characters
	- Max length: 141 characters
	- Language: Hausa with proper Unicode diacritics

	## Data Source

	This dataset was created using Mimic Studio recordings for Hausa language TTS development.

	## Intended Use

	This dataset is intended for:
	- Training Hausa Text-to-Speech models
	- Fine-tuning multilingual TTS models on Hausa
	- Research in low-resource language TTS
	- Multi-speaker TTS model development

	## Limitations

	- Limited to 3 speakers (may affect speaker diversity in trained models)
	- Relatively small dataset size (1,283 samples)
	- Audio quality depends on recording conditions

	## Citation

	If you use this dataset, please cite:

	```bibtex
	@dataset{hausa_tts_embed,
	author = {Aybee5},
	title = {Hausa TTS Dataset (HausaTTSEmbed)},
	year = {2025},
	publisher = {Hugging Face},
	url = {https://huggingface.co/datasets/Aybee5/HausaTTSEmbed}
	}
	```

	## License

	Please specify your license here.

	## Contact

	For questions or issues regarding this dataset, please open an issue in the dataset repository.