Munch

	---
	license: cc-by-4.0
	task_categories:
	- text-to-speech
	- automatic-speech-recognition
	- audio-to-audio
	language:
	- ur
	tags:
	- Urdu
	- TTS
	- LargeScaleDataset
	pretty_name: Munch
	---
	# Munch - Large-Scale Urdu Text-to-Speech Dataset

	[![Dataset](https://img.shields.io/badge/🤗%20Dataset-Munch-blue)](https://huggingface.co/datasets/humair025/Munch)
	[![Hashed Index](https://img.shields.io/badge/🤗%20Index-hashed__data-green)](https://huggingface.co/datasets/humair025/hashed_data)
	[![Size](https://img.shields.io/badge/Size-1.27TB-orange)]()
	[![Rows](https://img.shields.io/badge/Rows-4.17M-brightgreen)]()
	[![License](https://img.shields.io/badge/License-CC--BY--4.0-yellow)]()

	## 📖 Dataset Description

	Munch is a large-scale Urdu Text-to-Speech (TTS) dataset containing high-quality audio recordings paired with Urdu text transcripts. The dataset features multiple voice variations and natural pronunciation patterns suitable for training and evaluating Urdu TTS models.




	### Rough Assumption :

	4.17 million audio clips, if each 20 seconds long, total about 11,500+ hours of audio.


	### Key Features

	- 🎤 13 Different Voices: alloy, echo, fable, onyx, nova, shimmer, coral, verse, ballad, ash, sage, amuch, dan
	- 🗣️ Natural Urdu Pronunciation: Proper handling of Urdu script, punctuation, and intonation
	- 📊 Large Scale: 4,167,500 audio-text pairs
	- 🎵 High Quality Audio: PCM16 format, 22.05 kHz sample rate
	- 💾 Efficient Storage: Parquet format with compression
	- 📇 Lightweight Index Available: [Hashed index](https://huggingface.co/datasets/humair025/hashed_data) for exploration without downloading full dataset

	### Dataset Statistics

	\| Metric \| Value \|
	\|--------\|-------\|
	\| Total Size \| 1.27 TB \|
	\| Total Rows \| 4,167,500 \|
	\| Number of Files \| ~8,300 parquet files \|
	\| Audio Format \| PCM16 (raw audio bytes) \|
	\| Sample Rate \| 22,050 Hz \|
	\| Bit Depth \| 16-bit signed integer \|
	\| Text Language \| Urdu (with occasional mixed language) \|
	\| Voice Count \| 13 unique voices \|
	\| Avg Audio Size \| ~50 KB to 5MB per sample \|
	\| Avg Duration \| ~3-5 seconds per sample \|
	\| Total Duration \| ~7,500-15,800 hours of audio \|

	### 🔗 Companion Dataset

	For efficient exploration without downloading the full 1.27 TB dataset, use the [Munch Hashed Index](https://huggingface.co/datasets/humair025/hashed_data):
	- 📊 Contains all metadata + SHA-256 hashes of audio
	- 💾 Only ~1 GB (99.92% smaller)
	- ⚡ Search 4.17M records in seconds
	- 🎯 Selectively download only what you need

	### Related Datasets

	- This Dataset (v1): [humair025/Munch](https://huggingface.co/datasets/humair025/Munch) - 1.27 TB, 4.17M samples
	- Munch-1 (v2): [humair025/munch-1](https://huggingface.co/datasets/humair025/munch-1) - 3.28 TB, 3.86M samples (newer version)
	- Hashed Index (v1): [humair025/hashed_data](https://huggingface.co/datasets/humair025/hashed_data) - Index for this dataset
	- Hashed Index (v2): [humair025/hashed_data_munch_1](https://huggingface.co/datasets/humair025/hashed_data_munch_1) - Index for Munch-1

	---

	## 🚀 Quick Start

	### Installation

	```bash
	pip install datasets pandas numpy scipy
	```

	### Basic Usage

	```python
	from datasets import load_dataset
	import numpy as np
	import io
	from scipy.io import wavfile
	import IPython.display as ipd

	# Load a specific file
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_125841_0a26c418.parquet",
	split="train"
	)

	# Helper function to convert PCM16 bytes to WAV
	def pcm16_bytes_to_wav(pcm_bytes, sample_rate=22050):
	audio_array = np.frombuffer(pcm_bytes, dtype=np.int16)
	wav_io = io.BytesIO()
	wavfile.write(wav_io, sample_rate, audio_array)
	wav_io.seek(0)
	return wav_io

	# Play first audio sample
	row = ds[0]
	wav_io = pcm16_bytes_to_wav(row['audio_bytes'])
	ipd.display(ipd.Audio(wav_io, rate=22050))

	print(f"Text: {row['text']}")
	print(f"Voice: {row['voice']}")
	```

	### Efficient Exploration (Recommended)

	Instead of downloading the full 1.27 TB dataset, start with the hashed index:

	```python
	from datasets import load_dataset
	import pandas as pd

	# Load the lightweight index (~1 GB)
	index_ds = load_dataset("humair025/hashed_data", split="train")
	index_df = pd.DataFrame(index_ds)

	# Explore the dataset
	print(f"Total samples: {len(index_df)}")
	print(f"Voices: {index_df['voice'].unique()}")
	print(f"Voice distribution:\n{index_df['voice'].value_counts()}")

	# Find specific samples
	ash_samples = index_df[index_df['voice'] == 'ash']
	short_audio = index_df[index_df['audio_size_bytes'] < 40000]

	# Download only what you need
	files_needed = ash_samples['parquet_file_name'].unique()[:10]
	ds = load_dataset(
	"humair025/Munch",
	data_files=list(files_needed),
	split="train"
	)
	```

	### Load Multiple Files

	```python
	# Load first 10 files
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_*.parquet", # Wildcard pattern
	split="train"
	)

	print(f"Total samples: {len(ds)}")
	```

	### Batch Processing

	```python
	from huggingface_hub import HfApi

	# Get all parquet files
	api = HfApi()
	files = api.list_repo_files(repo_id="humair025/Munch", repo_type="dataset")
	parquet_files = [f for f in files if f.endswith('.parquet')]

	print(f"Total files: {len(parquet_files)}")

	# Load first 20 files
	batch = parquet_files[:20]
	ds = load_dataset(
	"humair025/Munch",
	data_files=batch,
	split="train"
	)
	```

	---

	## 📊 Dataset Structure

	### Data Fields

	Each row in the dataset contains:

	\| Field \| Type \| Description \|
	\|-------\|------\|-------------\|
	\| `id` \| int \| Paragraph ID (sequential) \|
	\| `text` \| string \| Original Urdu text \|
	\| `transcript` \| string \| TTS transcript (may differ slightly from input) \|
	\| `voice` \| string \| Voice name used (e.g., "ash", "sage", "coral") \|
	\| `audio_bytes` \| bytes \| Raw PCM16 audio data \|
	\| `timestamp` \| string \| ISO format timestamp of generation (nullable) \|
	\| `error` \| string \| Error message if generation failed (nullable) \|

	### Example Row

	```python
	{
	'id': 42,
	'text': 'یہ ایک نمونہ متن ہے۔',
	'transcript': 'یہ ایک نمونہ متن ہے۔',
	'voice': 'ash',
	'audio_bytes': b'\x00\x01...', # PCM16 bytes
	'timestamp': '2025-12-03T13:03:14.123456',
	'error': None
	}
	```

	---

	## 🎯 Use Cases

	### 1. TTS Model Training
	Train Urdu text-to-speech models with diverse voice samples:
	- Fine-tune existing TTS models
	- Train voice cloning systems
	- Develop multi-speaker TTS
	- Create voice conversion models

	### 2. Speech Recognition
	Develop Urdu ASR systems:
	- Train speech-to-text models
	- Evaluate transcription accuracy
	- Research Urdu phonetics
	- Build pronunciation dictionaries

	### 3. Voice Research
	Study voice characteristics and patterns:
	- Analyze voice similarity
	- Research pronunciation patterns
	- Study Urdu phonetics and prosody
	- Compare voice quality metrics

	### 4. Audio Processing
	Develop audio processing pipelines:
	- Audio enhancement
	- Noise reduction
	- Speech synthesis evaluation
	- Audio quality assessment

	### 5. Linguistic Analysis
	Explore linguistic patterns:
	- Text analysis and corpus linguistics
	- Punctuation usage patterns
	- Sentence structure analysis
	- Code-switching research (Urdu-English)

	---

	## 🔧 Advanced Usage

	### Voice Distribution Analysis

	```python
	import pandas as pd
	from collections import Counter

	# Using the hashed index (recommended)
	index_ds = load_dataset("humair025/hashed_data", split="train")
	index_df = pd.DataFrame(index_ds)

	# Count voice usage
	voice_counts = index_df['voice'].value_counts()
	print("Voice Distribution:")
	for voice, count in voice_counts.items():
	percentage = (count / len(index_df)) * 100
	print(f" {voice}: {count:,} samples ({percentage:.2f}%)")
	```

	### Audio Length Analysis

	```python
	# Using the hashed index
	avg_size = index_df['audio_size_bytes'].mean()
	avg_duration = (avg_size / 2) / 22050 # bytes to seconds

	print(f"Average audio size: {avg_size/1024:.2f} KB")
	print(f"Average duration: {avg_duration:.2f} seconds")

	# Duration distribution
	durations = (index_df['audio_size_bytes'] / 2) / 22050
	print(f"Min duration: {durations.min():.2f}s")
	print(f"Max duration: {durations.max():.2f}s")
	print(f"Median duration: {durations.median():.2f}s")
	```

	### Text Statistics

	```python
	# Text length analysis
	text_lengths = index_df['text'].str.len()
	word_counts = index_df['text'].str.split().str.len()

	print(f"Average characters: {text_lengths.mean():.0f}")
	print(f"Average words: {word_counts.mean():.0f}")
	print(f"Longest text: {text_lengths.max()} characters")
	```

	### Duplicate Detection

	```python
	# Find duplicate audio using hashes
	duplicates = index_df[index_df.duplicated(subset=['audio_bytes_hash'], keep=False)]

	if len(duplicates) > 0:
	print(f"Found {len(duplicates):,} duplicate rows")
	print(f"Unique audio: {index_df['audio_bytes_hash'].nunique():,}")
	redundancy = (1 - index_df['audio_bytes_hash'].nunique()/len(index_df)) * 100
	print(f"Redundancy: {redundancy:.2f}%")
	else:
	print("No duplicates found!")
	```

	### Export to WAV Files

	```python
	import os
	from tqdm import tqdm

	# Load specific samples
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_*.parquet",
	split="train"
	)

	os.makedirs("audio_files", exist_ok=True)

	for i, row in enumerate(tqdm(ds[:100])): # First 100 samples
	wav_io = pcm16_bytes_to_wav(row['audio_bytes'])
	filename = f"audio_files/sample_{i:04d}_{row['voice']}.wav"
	with open(filename, 'wb') as f:
	f.write(wav_io.read())
	```

	### Selective Download by Voice

	```python
	# Using hashed index to find files
	voice_of_interest = 'ash'
	ash_files = index_df[index_df['voice'] == voice_of_interest]['parquet_file_name'].unique()

	print(f"Files containing '{voice_of_interest}' voice: {len(ash_files)}")

	# Download first 10 files with ash voice
	ds = load_dataset(
	"humair025/Munch",
	data_files=list(ash_files[:10]),
	split="train"
	)

	print(f"Loaded {len(ds)} samples")
	```

	---

	## 📝 Dataset Creation

	This dataset was generated using a high-performance parallel TTS pipeline with the following characteristics:

	### Generation Pipeline

	- Concurrent Processing: 10-20 parallel workers
	- Voice Rotation: Sequential rotation through 13 voices
	- Quality Control: Automatic retry with exponential backoff
	- Fault Tolerance: Checkpoint-based resumption
	- Smart Batching: Efficient 500-row batches
	- API: OpenAI-compatible TTS endpoints

	### Pipeline Features

	- ✅ Natural Urdu pronunciation with proper intonation
	- ✅ Punctuation-aware pausing:
	- `؟` (question mark): 400ms pause with higher pitch
	- `!` (exclamation): 300ms pause with emphasis
	- `،` (comma): 500ms pause
	- `۔` (full stop): 1000ms pause
	- ✅ Mixed-language support for technical terms
	- ✅ Variable pacing for natural flow
	- ✅ Error handling and logging

	---

	## ⚠️ Important Notes

	### Audio Format
	- Audio is stored as raw PCM16 bytes (not WAV files)
	- Must be converted before playback (see examples above)
	- Sample rate: 22,050 Hz
	- Bit depth: 16-bit signed integer
	- Channels: Mono (1 channel)

	### Large Dataset Considerations
	- 💾 Size: 1.27 TB total - download selectively
	- 📦 Files: ~8,300 individual parquet files
	- ⚡ Streaming: Recommended for full dataset access
	- 🔄 Batching: Load files in batches to manage memory
	- 📊 Index First: Use [hashed index](https://huggingface.co/datasets/humair025/hashed_data) to explore before downloading

	### Recommended Workflow

	1. Explore: Load the [hashed index](https://huggingface.co/datasets/humair025/hashed_data) (~1 GB)
	2. Filter: Find samples matching your criteria
	3. Download: Selectively download only needed parquet files
	4. Process: Work with manageable subsets

	### Potential Data Issues

	⚠️ Duplicates: This dataset may contain duplicate audio samples. Use the hashed index for deduplication:

	```python
	# Get unique samples only
	unique_df = index_df.drop_duplicates(subset=['audio_bytes_hash'], keep='first')
	unique_files = unique_df['parquet_file_name'].unique()
	```

	⚠️ Quality Variance: Some samples may have:
	- Low volume or clipping
	- Mispronunciations (especially for rare words)
	- Background noise
	- Transcription differences from input text

	---

	## 📊 Performance Tips

	### Memory Management

	```python
	# DON'T: Load entire dataset at once
	# ds = load_dataset("humair025/Munch", split="train") # 1.27 TB!

	# DO: Use streaming mode
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_*.parquet",
	split="train",
	streaming=True # Stream data instead of loading all
	)

	# Process in batches
	for i, batch in enumerate(ds.iter(batch_size=100)):
	# Process 100 samples at a time
	if i >= 10: # Process only first 1000 samples
	break
	```

	### Efficient File Selection

	```python
	# Select specific date range
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_*.parquet", # Only Dec 3rd files
	split="train"
	)

	# Or specific time range
	ds = load_dataset(
	"humair025/Munch",
	data_files="tts_data_20251203_1303*.parquet", # Around 13:03
	split="train"
	)

	# Or use the index to find specific files
	target_files = index_df[index_df['voice'] == 'ash']['parquet_file_name'].unique()[:5]
	ds = load_dataset("humair025/Munch", data_files=list(target_files), split="train")
	```

	### Storage Optimization

	```python
	# If storage is limited, consider:
	# 1. Download only specific voices
	# 2. Download in batches and process incrementally
	# 3. Use the hashed index for metadata-only analysis
	# 4. Delete processed files after feature extraction
	```

	---

	## 📜 Citation

	If you use this dataset in your research, please cite:

	### BibTeX

	```bibtex
	@dataset{munch_urdu_tts_2025,
	title={Munch: Large-Scale Urdu Text-to-Speech Dataset},
	author={Munir, Humair},
	year={2025},
	publisher={Hugging Face},
	howpublished={\url{https://huggingface.co/datasets/humair025/Munch}},
	note={4.17M audio-text pairs across 13 voices}
	}
	```

	### APA Format

	```
	Munir, H. (2025). Munch: Large-Scale Urdu Text-to-Speech Dataset [Dataset].
	Hugging Face. https://huggingface.co/datasets/humair025/Munch
	```

	### MLA Format

	```
	Munir, Humair. "Munch: Large-Scale Urdu Text-to-Speech Dataset." Hugging Face, 2025,
	https://huggingface.co/datasets/humair025/Munch.
	```

	---

	## 🤝 Contributing

	Issues, suggestions, and contributions are welcome! Please:
	- 🐛 Report data quality issues
	- 💡 Suggest improvements
	- 📝 Share your use cases and research
	- 🔧 Contribute analysis scripts or tools

	## 📄 License

	This dataset is released under the Creative Commons Attribution 4.0 International (CC-BY-4.0) license.

	You are free to:
	- ✅ Share — copy and redistribute the material in any medium or format
	- ✅ Adapt — remix, transform, and build upon the material for any purpose
	- ✅ Commercial use — use the dataset for commercial purposes

	Under the following terms:
	- 📝 Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made

	---

	## 🔗 Important Links

	- 🎧 [This Dataset (Full Audio)](https://huggingface.co/datasets/humair025/Munch) - 1.27 TB
	- 📊 [Hashed Index](https://huggingface.co/datasets/humair025/hashed_data) - ~1 GB metadata + hashes
	- 🔄 [Munch-1 (Newer Version)](https://huggingface.co/datasets/humair025/munch-1) - 3.28 TB, 3.86M samples
	- 💬 [Discussions](https://huggingface.co/datasets/humair025/Munch/discussions) - Ask questions, share research
	- 🐛 [Report Issues](https://huggingface.co/datasets/humair025/Munch/discussions) - Data quality problems

	---

	## 🙏 Acknowledgments

	- TTS Generation: OpenAI-compatible API endpoints
	- Voices: 13 high-quality voice models (alloy, echo, fable, onyx, nova, shimmer, coral, verse, ballad, ash, sage, amuch, dan)
	- Infrastructure: HuggingFace Datasets platform
	- Tools: Python, datasets, pandas, numpy, scipy

	---

	## 📈 Usage Statistics

	Help us understand how the dataset is used:
	- Training TTS models
	- Speech recognition research
	- Voice cloning experiments
	- Linguistic analysis
	- Educational purposes
	- Other (please share in discussions!)

	---

	## ⚡ Quick Start Tips

	1. First Time Users: Start with the [hashed index](https://huggingface.co/datasets/humair025/hashed_data) (~1 GB) to explore the dataset
	2. Download Smart: Use the index to find specific samples, then download only those parquet files
	3. Memory Matters: Use streaming mode if working with large subsets
	4. Deduplication: Check for duplicates using audio hashes before training
	5. Voice Selection: Each voice has ~320k samples - choose based on your needs
	6. Consider Munch-1: A newer version with 3.86M samples is also available at [humair025/munch-1](https://huggingface.co/datasets/humair025/munch-1)

	---

	Note: This is a large dataset (1.27 TB, 4.17M samples). Please download selectively based on your needs. Consider using the [hashed index](https://huggingface.co/datasets/humair025/hashed_data) for exploration and selective downloading.

	Last Updated: December 2025

	Status: ✅ Complete - All ~8,300 files uploaded

	---

	💡 Pro Tip: Download the lightweight [hashed index](https://huggingface.co/datasets/humair025/hashed_data) first to explore the dataset, find duplicates, and identify exactly which files you need - then download only those specific parquet files from this dataset!