humair025/hashed_data_munch_1

Munch-1 Hashed Index - Lightweight Audio Reference Dataset

📖 Overview

Munch-1 Hashed Index is a lightweight reference dataset that provides SHA-256 hashes for all audio files in the Munch-1 Urdu TTS Dataset. Instead of storing 3.28 TB of raw audio, this index stores only metadata and cryptographic hashes, enabling:

• ✅ Fast duplicate detection across 3.86M+ audio samples
• ✅ Efficient dataset exploration without downloading terabytes
• ✅ Quick metadata queries (voice distribution, text stats, etc.)
• ✅ Selective audio retrieval - download only what you need
• ✅ Storage efficiency - 99.97% space reduction (3.28 TB → ~1 GB)

🔗 Related Datasets

• Original Dataset: humair025/munch-1 - Full audio dataset (3.28 TB)
• This Index: humair025/hashed_data_munch_1 - Hashed reference (~1 GB)

---

🎯 What Problem Does This Solve?

The Challenge

The original Munch-1 dataset contains:

• 📊 3,856,500 audio-text pairs
• 💾 3.28 TB total size
• 📦 ~7,714 separate parquet files (~400 MB each)

This makes it difficult to:

• ❌ Quickly check if specific audio exists
• ❌ Find duplicate audio samples
• ❌ Explore metadata without downloading everything
• ❌ Work on limited bandwidth/storage

The Solution

This hashed index provides:

• ✅ All metadata (text, voice, timestamps) without audio bytes
• ✅ SHA-256 hashes for every audio file (unique fingerprint)
• ✅ File references (which parquet contains each audio)
• ✅ Fast queries - search 3.86M records in seconds
• ✅ Retrieve on demand - download only specific audio when needed

---

🚀 Quick Start

Installation

pip install datasets pandas

Basic Usage

from datasets import load_dataset
import pandas as pd

# Load the entire hashed index (fast - only ~1 GB!)
ds = load_dataset("humair025/hashed_data_munch_1", split="train")
df = pd.DataFrame(ds)

print(f"Total records: {len(df)}")
print(f"Unique audio hashes: {df['audio_bytes_hash'].nunique()}")
print(f"Voices: {df['voice'].unique()}")

Find Duplicates

# Check for duplicate audio
duplicates = df[df.duplicated(subset=['audio_bytes_hash'], keep=False)]

if len(duplicates) > 0:
    print(f"⚠️  Found {len(duplicates)} duplicate rows")
    print(f"   Unique audio files: {df['audio_bytes_hash'].nunique()}")
    print(f"   Redundancy: {(1 - df['audio_bytes_hash'].nunique()/len(df))*100:.2f}%")
else:
    print("✅ No duplicates found!")

Search by Voice

# Find all "ash" voice samples
ash_samples = df[df['voice'] == 'ash']
print(f"Ash voice samples: {len(ash_samples)}")

# Get file containing first ash sample
first_ash = ash_samples.iloc[0]
print(f"File: {first_ash['parquet_file_name']}")
print(f"Text: {first_ash['text']}")

Search by Text

# Find audio for specific text
query = "یہ ایک نمونہ"
matches = df[df['text'].str.contains(query, na=False)]
print(f"Found {len(matches)} matches")

Retrieve Original Audio

from datasets import load_dataset as load_original
import numpy as np
from scipy.io import wavfile
import io

def get_audio_by_hash(audio_hash, index_df):
    """Retrieve original audio bytes using the hash"""
    # Find the row with this hash
    row = index_df[index_df['audio_bytes_hash'] == audio_hash].iloc[0]
    
    # Download only the specific parquet file containing this audio
    ds = load_original(
        "humair025/munch-1",
        data_files=[row['parquet_file_name']],
        split="train"
    )
    
    # Find matching row by ID
    for audio_row in ds:
        if audio_row['id'] == row['id']:
            return audio_row['audio_bytes']
    
    return None

# Example: Get audio for first row
row = df.iloc[0]
audio_bytes = get_audio_by_hash(row['audio_bytes_hash'], df)

# Convert to WAV and play
def pcm16_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

wav_io = pcm16_to_wav(audio_bytes)
# In Jupyter: IPython.display.Audio(wav_io, rate=22050)

---

📊 Dataset Structure

Data Fields

Field	Type	Description
id	int	Original paragraph ID from source dataset
parquet_file_name	string	Source file in munch-1 dataset
text	string	Original Urdu text
transcript	string	TTS transcript (may differ from input)
voice	string	Voice used (alloy, echo, fable, onyx, nova, shimmer, coral, verse, ballad, ash, sage, amuch, dan)
audio_bytes_hash	string	SHA-256 hash of audio_bytes (64 hex chars)
audio_size_bytes	int	Size of original audio in bytes
timestamp	string	ISO timestamp of generation (nullable)
error	string	Error message if generation failed (nullable)

Example Row

{
    'id': 42,
    'parquet_file_name': 'tts_data_20251203_130314_83ab0706.parquet',
    'text': 'یہ ایک نمونہ متن ہے۔',
    'transcript': 'یہ ایک نمونہ متن ہے۔',
    'voice': 'ash',
    'audio_bytes_hash': 'a3f7b2c8e9d1f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9',
    'audio_size_bytes': 52340,
    'timestamp': '2024-12-03T13:03:14.123456',
    'error': None
}

---

🎯 Use Cases

1. Dataset Quality Analysis

# Check for duplicates
unique_ratio = df['audio_bytes_hash'].nunique() / len(df)
print(f"Unique audio ratio: {unique_ratio*100:.2f}%")

# Analyze voice distribution
voice_dist = df['voice'].value_counts()
print(voice_dist)

# Find failed generations
failed = df[df['error'].notna()]
print(f"Failed generations: {len(failed)}")

2. Efficient Data Exploration

# Browse dataset without downloading audio
print(df[['id', 'text', 'voice', 'audio_size_bytes']].head(20))

# Filter by criteria
short_audio = df[df['audio_size_bytes'] < 30000]
long_text = df[df['text'].str.len() > 200]

3. Selective Download

# Download only specific voices
ash_files = df[df['voice'] == 'ash']['parquet_file_name'].unique()
ds = load_dataset("humair025/munch-1", data_files=list(ash_files))

# Download only short audio samples
small_files = df[df['audio_size_bytes'] < 40000]['parquet_file_name'].unique()
ds = load_dataset("humair025/munch-1", data_files=list(small_files[:10]))

4. Deduplication Pipeline

# Create deduplicated subset
df_unique = df.drop_duplicates(subset=['audio_bytes_hash'], keep='first')
print(f"Original: {len(df)} rows")
print(f"Unique: {len(df_unique)} rows")
print(f"Duplicates removed: {len(df) - len(df_unique)}")

# Save unique references
df_unique.to_parquet('unique_audio_index.parquet')

5. Audio Similarity Search

# Find audio with similar hash prefixes (for clustering)
target_hash = df.iloc[0]['audio_bytes_hash']
prefix = target_hash[:8]

similar = df[df['audio_bytes_hash'].str.startswith(prefix)]
print(f"Similar audio candidates: {len(similar)}")

---

📈 Dataset Statistics

Size Comparison

Metric	Original Dataset	Hashed Index	Reduction
Total Size	3.28 TB	~1 GB	99.97%
Records	3,856,500	3,856,500	Same
Files	7,714 parquet	Consolidated	~7,700× fewer
Download Time (100 Mbps)	~73 hours	~90 seconds	~3,000×
Load Time	Minutes-Hours	Seconds	~100×
Memory Usage	Cannot fit in RAM	~2-3 GB RAM	Fits easily

Content Statistics

📊 Dataset Overview:
   Total Records: 3,856,500
   Total Files: 7,714 parquet files (~400 MB each)
   Voices: 13 (alloy, echo, fable, onyx, nova, shimmer, coral, verse, ballad, ash, sage, amuch, dan)
   Language: Urdu (primary)
   Avg Audio Size: ~50-60 KB per sample
   Avg Duration: ~3-5 seconds per sample
   Total Duration: ~3,200-4,800 hours of audio

---

🔧 Advanced Usage

Batch Analysis

# Analyze all hash files
from datasets import load_dataset

ds = load_dataset("humair025/hashed_data_munch_1", split="train")
df = pd.DataFrame(ds)

# Group by voice
voice_stats = df.groupby('voice').agg({
    'id': 'count',
    'audio_size_bytes': 'mean',
    'audio_bytes_hash': 'nunique'
}).rename(columns={
    'id': 'total_samples',
    'audio_size_bytes': 'avg_size',
    'audio_bytes_hash': 'unique_audio'
})

print(voice_stats)

Cross-Reference with Original

# Check if a hash exists in original dataset
def verify_hash_exists(audio_hash, parquet_file):
    """Verify a hash actually exists in the original dataset"""
    from datasets import load_dataset
    import hashlib
    
    ds = load_dataset(
        "humair025/munch-1",
        data_files=[parquet_file],
        split="train"
    )
    
    for row in ds:
        computed_hash = hashlib.sha256(row['audio_bytes']).hexdigest()
        if computed_hash == audio_hash:
            return True
    
    return False

# Verify first entry
first_row = df.iloc[0]
exists = verify_hash_exists(
    first_row['audio_bytes_hash'],
    first_row['parquet_file_name']
)
print(f"Hash verified: {exists}")

Export Unique Dataset

# Create a new dataset with only unique audio
df_unique = df.drop_duplicates(subset=['audio_bytes_hash'], keep='first')

# Get list of unique parquet files needed
unique_files = df_unique['parquet_file_name'].unique()

print(f"Unique audio samples: {len(df_unique)}")
print(f"Files needed: {len(unique_files)} out of {df['parquet_file_name'].nunique()}")

# Calculate space savings
original_size = len(df) * df['audio_size_bytes'].mean()
unique_size = len(df_unique) * df_unique['audio_size_bytes'].mean()
savings = (1 - unique_size/original_size) * 100

print(f"Space savings: {savings:.2f}%")

---

🛠️ How This Index Was Created

This dataset was generated using an automated pipeline:

Processing Pipeline

1. Batch Download: Download 40 parquet files at a time from source
2. Hash Computation: Compute SHA-256 for each audio_bytes field
3. Metadata Extraction: Extract text, voice, and other metadata
4. Save & Upload: Save hash file, upload to HuggingFace
5. Clean Up: Delete local cache to save disk space
6. Resume: Track processed files, skip already-processed

Pipeline Features

• ✅ Resumable: Checkpoint system tracks progress
• ✅ Memory Efficient: Processes in batches, clears cache
• ✅ Error Tolerant: Skips corrupted files, continues processing
• ✅ No Duplicates: Checks target repo to avoid reprocessing
• ✅ Automatic Upload: Streams results to HuggingFace

Technical Details

# Hash computation
import hashlib
hash = hashlib.sha256(audio_bytes).hexdigest()

# Batch size: 40 files per batch
# Processing time: ~4-6 hours for full dataset
# Output: Multiple hashed_*.parquet files

---

📊 Performance Metrics

Query Performance

import time

# Load index
start = time.time()
ds = load_dataset("humair025/hashed_data_munch_1", split="train")
df = pd.DataFrame(ds)
print(f"Load time: {time.time() - start:.2f}s")

# Query by hash
start = time.time()
result = df[df['audio_bytes_hash'] == 'target_hash']
print(f"Hash lookup: {(time.time() - start)*1000:.2f}ms")

# Query by voice
start = time.time()
result = df[df['voice'] == 'ash']
print(f"Voice filter: {(time.time() - start)*1000:.2f}ms")

Expected Performance:

• Load full dataset: 10-30 seconds
• Hash lookup: < 10 milliseconds
• Voice filter: < 50 milliseconds
• Full dataset scan: < 5 seconds

---

🔗 Integration with Original Dataset

Workflow Example

# 1. Query the index (fast)
df = pd.DataFrame(load_dataset("humair025/hashed_data_munch_1", split="train"))
target_rows = df[df['voice'] == 'ash'].head(100)

# 2. Get unique parquet files
files_needed = target_rows['parquet_file_name'].unique()

# 3. Download only needed files (selective)
from datasets import load_dataset
ds = load_dataset(
    "humair025/munch-1",
    data_files=list(files_needed),
    split="train"
)

# 4. Match by ID to get audio
for idx, row in target_rows.iterrows():
    for audio_row in ds:
        if audio_row['id'] == row['id']:
            # Process audio_bytes
            audio = audio_row['audio_bytes']
            break

---

📜 Citation

If you use this dataset in your research, please cite both the original dataset and this index:

BibTeX

@dataset{munch_hashed_index_2025,
  title={Munch-1 Hashed Index: Lightweight Reference Dataset for Urdu TTS},
  author={humair025},
  year={2025},
  publisher={Hugging Face},
  howpublished={\url{https://huggingface.co/datasets/humair025/hashed_data_munch_1}},
  note={Index of humair025/munch-1 dataset with SHA-256 audio hashes}
}

@dataset{munch_urdu_tts_2025,
  title={Munch-1: Large-Scale Urdu Text-to-Speech Dataset},
  author={humair025},
  year={2025},
  publisher={Hugging Face},
  howpublished={\url{https://huggingface.co/datasets/humair025/munch-1}}
}

APA Format

humair025. (2025). Munch-1 Hashed Index: Lightweight Reference Dataset for Urdu TTS 
[Dataset]. Hugging Face. https://huggingface.co/datasets/humair025/hashed_data_munch_1

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

MLA Format

humair025. "Munch-1 Hashed Index: Lightweight Reference Dataset for Urdu TTS." 
Hugging Face, 2025, https://huggingface.co/datasets/humair025/hashed_data_munch_1.

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

---

🤝 Contributing

Report Issues

Found a problem? Please open an issue:

• Missing hash files
• Incorrect metadata
• Hash mismatches
• Documentation improvements

Suggest Improvements

We welcome suggestions for:

• Additional metadata fields
• Better indexing strategies
• Integration examples
• Use case documentation

---

📄 License

This index dataset inherits the license from the original Munch-1 dataset:

Creative Commons Attribution 4.0 International (CC-BY-4.0)

You are free to:

• ✅ Share — copy and redistribute
• ✅ Adapt — remix, transform, build upon
• ✅ Commercial use — use commercially

Under the terms:

• 📝 Attribution — Give appropriate credit to original dataset

---

🔗 Important Links

• 🎧 Original Audio Dataset - Full 3.28 TB audio
• 📊 This Hashed Index - Lightweight reference
• 💬 Discussions - Ask questions
• 🐛 Report Issues - Bug reports

---

❓ FAQ

Q: Why use hashes instead of audio?

A: Hashes provide unique fingerprints for audio files while taking only 64 bytes vs ~50KB per audio. This enables duplicate detection and fast queries without storing massive audio files.

Q: Can I reconstruct audio from hashes?

A: No. SHA-256 is a one-way cryptographic hash. You must download the original audio from the Munch-1 dataset using the file reference provided.

Q: How accurate are the hashes?

A: SHA-256 has virtually zero collision probability. If two hashes match, the audio is identical (byte-for-byte).

Q: How do I get the actual audio?

A: Use the parquet_file_name and id fields to locate and download the specific audio from the original dataset. See examples above.

Q: Is this dataset complete?

A: Yes, this index covers all 3,856,500 rows across all 7,714 parquet files from the original Munch-1 dataset.

Q: Can I contribute?

A: Yes! Help verify hashes, report inconsistencies, or suggest improvements via discussions.

---

🙏 Acknowledgments

• Original Dataset: humair025/munch-1
• TTS Generation: OpenAI-compatible models
• Voices: 13 high-quality voices (alloy, echo, fable, onyx, nova, shimmer, coral, verse, ballad, ash, sage, amuch, dan)
• Infrastructure: HuggingFace Datasets platform
• Hashing: SHA-256 cryptographic hash function

---

📝 Version History

• v1.0.0 (December 2025): Initial release
  • Processed all 7,714 parquet files
  • 3,856,500 audio samples indexed
  • SHA-256 hashes computed for all audio
  • ~99.97% space reduction achieved

---

Last Updated: December 2025

Status: ✅ Complete

---

💡 Pro Tip: Start with this lightweight index to explore the dataset, then selectively download only the audio you need from the original Munch-1 dataset!