Remove obsolete files and scripts from the HyVoxPopuli dataset repository

.github/workflows/ci.yml

@@ -1,62 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: [3.8, 3.9, "3.10"]
-
-    steps:
-    - uses: actions/checkout@v3
-    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python-version }}
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r requirements.txt
-        pip install pytest pytest-cov black isort
-    
-    - name: Check code formatting
-      run: |
-        black --check .
-        isort --check-only .
-    
-    - name: Run tests with coverage
-      run: |
-        pytest tests/ --cov=. --cov-report=xml
-    
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v3
-      with:
-        file: ./coverage.xml
-        fail_ci_if_error: true
-
-  validate-dataset:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.10"
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r requirements.txt
-    
-    - name: Validate dataset
-      run: |
-        python scripts/validate_dataset.py

.gitignore

@@ -19,13 +19,18 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+*.py
+*.txt
+*.toml
 
 # Ignore original data files but include Parquet files
+temp_hf_repo/*
 data/*
-!data/parquet/
-data/parquet/*
-!data/parquet/*.parquet
-!data/parquet/dataset_info.json
+examples/*
+scripts/*
+tests/*
+.github/*
+becnchmarks/*
 MANIFEST
 
 # Virtual Environment

data/parquet/dataset_info.json

@@ -1,29 +0,0 @@
-{
-  "default": {
-    "features": {
-      "audio_id": "string",
-      "audio": {
-        "path": "string",
-        "array": "float32[]",
-        "sampling_rate": "int32"
-      },
-      "raw_text": "string",
-      "normalized_text": "string",
-      "gender": "string",
-      "speaker_id": "string",
-      "is_gold_transcript": "bool",
-      "accent": "string"
-    },
-    "splits": {
-      "train": {
-        "num_examples": 498
-      },
-      "validation": {
-        "num_examples": 62
-      },
-      "test": {
-        "num_examples": 63
-      }
-    }
-  }
-}

examples/load_dataset.py

@@ -1,38 +0,0 @@
-"""Example script demonstrating how to load and use the HyVoxPopuli dataset."""
-
-import torch
-import torchaudio
-from datasets import load_dataset
-from transformers import WhisperProcessor, WhisperForConditionalGeneration
-
-def main():
-    # Load the dataset
-    dataset = load_dataset("Edmon02/hyvoxpopuli", split="train[:5]")
-    print(f"Loaded {len(dataset)} examples")
-
-    # Load Whisper model and processor
-    processor = WhisperProcessor.from_pretrained("openai/whisper-small")
-    model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
-
-    # Process an example
-    example = dataset[0]
-    print("\nExample metadata:")
-    print(f"Audio ID: {example['audio_id']}")
-    print(f"Speaker: {example['speaker_id']} (Gender: {example['gender']})")
-    print(f"Reference text: {example['normalized_text']}")
-
-    # Process audio with Whisper
-    input_features = processor(
-        example["audio"]["array"],
-        sampling_rate=example["audio"]["sampling_rate"],
-        return_tensors="pt"
-    ).input_features
-
-    # Generate tokens
-    predicted_ids = model.generate(input_features)
-    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-
-    print(f"\nWhisper transcription: {transcription}")
-
-if __name__ == "__main__":
-    main()

hyvoxpopuli.py

@@ -1,170 +0,0 @@
-"""HyVoxPopuli Dataset: A High-Quality Armenian Speech Recognition Dataset.
-
-This module implements the HyVoxPopuli dataset loader for the Hugging Face datasets library.
-The dataset contains Armenian speech recordings with expert-validated transcriptions.
-"""
-
-from collections import defaultdict
-import logging
-import os
-from typing import Any, Dict, List, Iterator, Optional, Tuple
-import json
-import csv
-
-import datasets
-from datasets.tasks import AutomaticSpeechRecognition
-
-logger = logging.getLogger(__name__)
-
-# Configure logging
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    level=logging.INFO
-)
-
-_CITATION = """\
-@dataset{hyvoxpopuli2023,
-    title = {HyVoxPopuli: Armenian Speech Recognition Dataset},
-    year = {2023},
-    publisher = {Hugging Face},
-    journal = {Hugging Face Datasets},
-    url = {https://huggingface.co/datasets/Edmon02/hyvoxpopuli}
-}
-"""
-
-_DESCRIPTION = """\
-HyVoxPopuli is a high-quality Armenian speech recognition dataset designed for training
-and evaluating automatic speech recognition (ASR) models. The dataset contains carefully
-curated audio segments paired with their transcriptions in Armenian.
-
-Features:
-- High-quality audio recordings at 16kHz sampling rate
-- Expert-validated transcriptions
-- Speaker metadata including gender and speaker ID
-- Optional accent information where applicable
-"""
-
-_HOMEPAGE = "https://huggingface.co/datasets/Edmon02/hyvoxpopuli"
-
-_LICENSE = "CC-BY-4.0"
-
-_BASE_DATA_DIR = "data/"
-_AUDIO_ARCHIVE_PATH = _BASE_DATA_DIR + "{split}/{split}_dataset.tar.gz"
-_METADATA_PATH = _BASE_DATA_DIR + "{split}.tsv"
-
-class Hyvoxpopuli(datasets.GeneratorBasedBuilder):
-    """The HyVoxPopuli dataset: A high-quality Armenian speech recognition dataset."""
-    
-    VERSION = datasets.Version("1.0.0")
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(
-            name="default",
-            version=VERSION,
-            description="Default configuration for HyVoxPopuli dataset",
-        ),
-    ]
-
-    def _info(self) -> datasets.DatasetInfo:
-        """Returns the dataset metadata."""
-        features = datasets.Features(
-            {
-                "audio_id": datasets.Value("string"),
-                "audio": datasets.Audio(sampling_rate=16_000),
-                "raw_text": datasets.Value("string"),
-                "normalized_text": datasets.Value("string"),
-                "gender": datasets.Value("string", id=None),
-                "speaker_id": datasets.Value("string"),
-                "is_gold_transcript": datasets.Value("bool"),
-                "accent": datasets.Value("string", id=None),
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-            task_templates=[
-                AutomaticSpeechRecognition(
-                    audio_column="audio",
-                    transcription_column="normalized_text",
-                )
-            ],
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
-        """Returns SplitGenerators."""
-        split_names = {
-            "train": str(datasets.Split.TRAIN),
-            "dev": str(datasets.Split.VALIDATION),
-            "test": str(datasets.Split.TEST)
-        }
-
-        # Prepare download URLs
-        audio_urls = {
-            split: [_AUDIO_ARCHIVE_PATH.format(split=split)]
-            for split in split_names.keys()
-        }
-        meta_urls = {
-            split: _METADATA_PATH.format(split=split)
-            for split in split_names.keys()
-        }
-
-        # Download and extract files
-        meta_paths = dl_manager.download_and_extract(meta_urls)
-        audio_paths = dl_manager.download(audio_urls)
-        local_extracted_audio_paths = dl_manager.extract(audio_paths)
-
-        # Create split generators
-        return [
-            datasets.SplitGenerator(
-                name=split_name,
-                gen_kwargs={
-                    "audio_archives": [dl_manager.iter_archive(path) for path in audio_paths[split]],
-                    "local_extracted_archive_path": local_extracted_audio_paths[split][0]
-                    if isinstance(local_extracted_audio_paths[split], list)
-                    else local_extracted_audio_paths[split],
-                    "metadata_path": meta_paths[split],
-                }
-            )
-            for split, split_name in split_names.items()
-        ]
-
-    def _generate_examples(
-        self,
-        audio_archives: List[Iterator[Tuple[str, Any]]],
-        local_extracted_archive_path: str,
-        metadata_path: str,
-    ) -> Iterator[Tuple[str, Dict[str, Any]]]:
-        """Yields examples as (key, example) tuples."""
-        features = ["raw_text", "normalized_text", "speaker_id", "gender", "is_gold_transcript", "accent"]
-
-        # Load metadata
-        with open(metadata_path, encoding="utf-8") as f:
-            metadata = {row["id"]: row for row in csv.DictReader(f, delimiter="\t")}
-
-        # Process audio files
-        for audio_archive in audio_archives:
-            for audio_filename, audio_file in audio_archive:
-                # Extract audio ID from filename
-                audio_id = os.path.splitext(os.path.basename(audio_filename))[0]
-                
-                # Construct audio path
-                path = os.path.join(local_extracted_archive_path, audio_filename) if local_extracted_archive_path else audio_filename
-                
-                try:
-                    # Create example dictionary
-                    example = {
-                        "audio_id": audio_id,
-                        "audio": {"path": path, "bytes": audio_file.read()},
-                    }
-                    
-                    # Add metadata fields
-                    for feature in features:
-                        example[feature] = metadata[audio_id][feature]
-                    
-                    yield audio_id, example
-                    
-                except Exception as e:
-                    logger.warning(f"Error processing audio file {audio_id}: {str(e)}")
-                    continue

pyproject.toml

@@ -1,32 +0,0 @@
-[tool.black]
-line-length = 88
-include = '\.pyx?$'
-extend-exclude = '''
-# A regex preceded with ^/ will apply only to files and directories
-# in the root of the project.
-^/external/
-'''
-
-[tool.isort]
-profile = "black"
-multi_line_output = 3
-include_trailing_comma = true
-force_grid_wrap = 0
-use_parentheses = true
-ensure_newline_before_comments = true
-line_length = 88
-
-[tool.pylint.messages_control]
-disable = [
-    "C0111",  # missing-docstring
-    "C0103",  # invalid-name
-    "C0330",  # bad-continuation
-    "C0326",  # bad-whitespace
-    "W0621",  # redefined-outer-name
-    "W0612",  # unused-variable
-    "W0611",  # unused-import
-    "R0903",  # too-few-public-methods
-]
-
-[tool.pylint.format]
-max-line-length = 88

requirements.txt

@@ -1,17 +0,0 @@
-# Core dependencies
-datasets>=2.0.0
-librosa>=0.8.0
-numpy>=1.19.0
-torch>=1.7.0
-torchaudio>=0.7.0
-transformers>=4.30.0
-jiwer>=2.5.0
-pesq>=0.0.3
-pystoi>=0.3.3
-
-# Development dependencies
-black>=22.3.0
-isort>=5.10.1
-pylint>=2.15.0
-pytest>=7.0.0
-pytest-cov>=3.0.0

scripts/convert_to_parquet.py

@@ -1,131 +0,0 @@
-"""Script to convert HyVoxPopuli dataset to Parquet format for Hugging Face."""
-import os
-import json
-import tarfile
-import pandas as pd
-from pathlib import Path
-from typing import Dict, Any
-import datasets
-from datasets import Dataset, Features, Value, Audio
-
-def read_tsv(file_path: str) -> pd.DataFrame:
-    """Read TSV file into a pandas DataFrame."""
-    return pd.read_csv(file_path, sep='\t', quoting=3)
-
-def process_audio_archive(archive_path: str) -> Dict[str, bytes]:
-    """Extract audio files from tar.gz archive."""
-    audio_files = {}
-    with tarfile.open(archive_path, 'r:gz') as tar:
-        for member in tar.getmembers():
-            if member.name.endswith('.wav'):
-                f = tar.extractfile(member)
-                if f is not None:
-                    audio_files[Path(member.name).stem] = f.read()
-    return audio_files
-
-def convert_split_to_parquet(split_name: str, base_dir: Path):
-    """Convert a single split to Parquet format."""
-    print(f"Processing {split_name} split...")
-    
-    # Read metadata
-    tsv_path = base_dir / f"{split_name}.tsv"
-    df = read_tsv(str(tsv_path))
-    
-    # Process audio files
-    archive_path = base_dir / split_name / f"{split_name}_dataset.tar.gz"
-    audio_files = process_audio_archive(str(archive_path))
-    
-    # Create dataset
-    features = Features({
-        'audio_id': Value('string'),
-        'audio': Audio(sampling_rate=16000),
-        'raw_text': Value('string'),
-        'normalized_text': Value('string'),
-        'gender': Value('string'),
-        'speaker_id': Value('string'),
-        'is_gold_transcript': Value('bool'),
-        'accent': Value('string'),
-    })
-
-    examples = []
-    for _, row in df.iterrows():
-        audio_id = row['id']
-        if audio_id in audio_files:
-            example = {
-                'audio_id': audio_id,
-                'audio': {'bytes': audio_files[audio_id], 'path': f"{audio_id}.wav"},
-                'raw_text': row['raw_text'],
-                'normalized_text': row['normalized_text'],
-                'gender': row['gender'],
-                'speaker_id': row['speaker_id'],
-                'is_gold_transcript': row['is_gold_transcript'],
-                'accent': row['accent'],
-            }
-            examples.append(example)
-    
-    # Create and save dataset
-    dataset = Dataset.from_list(examples, features=features)
-    parquet_dir = base_dir / "parquet"
-    parquet_dir.mkdir(exist_ok=True)
-    dataset.to_parquet(str(parquet_dir / f"{split_name}.parquet"))
-    
-    return len(examples)
-
-def create_dataset_info(stats: Dict[str, int]):
-    """Create dataset info JSON file."""
-    info = {
-        "default": {
-            "features": {
-                "audio_id": "string",
-                "audio": {
-                    "path": "string",
-                    "array": "float32[]",
-                    "sampling_rate": "int32"
-                },
-                "raw_text": "string",
-                "normalized_text": "string",
-                "gender": "string",
-                "speaker_id": "string",
-                "is_gold_transcript": "bool",
-                "accent": "string"
-            },
-            "splits": {
-                "train": {"num_examples": stats["train"]},
-                "validation": {"num_examples": stats["validation"]},
-                "test": {"num_examples": stats["test"]}
-            }
-        }
-    }
-    
-    return info
-
-def convert_to_parquet():
-    """Convert the dataset to Parquet format."""
-    base_dir = Path("data")
-    
-    # Process each split
-    stats = {}
-    split_mapping = {
-        "train": "train",
-        "dev": "validation",
-        "test": "test"
-    }
-    
-    for source_split, target_split in split_mapping.items():
-        stats[target_split] = convert_split_to_parquet(source_split, base_dir)
-
-    # Create and save dataset info
-    info = create_dataset_info(stats)
-    
-    parquet_dir = base_dir / "parquet"
-    with open(parquet_dir / "dataset_info.json", "w", encoding="utf-8") as f:
-        json.dump(info, f, indent=2)
-    
-    # Print statistics
-    print("\nConversion complete!")
-    print("Dataset statistics:")
-    for split, count in stats.items():
-        print(f"{split}: {count} examples")
-
-if __name__ == "__main__":
-    convert_to_parquet()

scripts/run_benchmarks.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""
-Benchmark script for HyVoxPopuli dataset.
-Evaluates different ASR models on the dataset and computes relevant metrics.
-"""
-
-import argparse
-import json
-import logging
-from pathlib import Path
-from typing import Dict, List, Optional
-
-import torch
-import torchaudio
-from datasets import load_dataset
-from transformers import (
-    Wav2Vec2ForCTC,
-    Wav2Vec2Processor,
-    WhisperForConditionalGeneration,
-    WhisperProcessor,
-)
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODELS = {
-    "wav2vec2": "facebook/wav2vec2-large-xlsr-53",
-    "whisper": "openai/whisper-large-v3",
-}
-
-def load_model_and_processor(model_name: str):
-    """Load model and processor based on model name."""
-    if model_name == "wav2vec2":
-        model = Wav2Vec2ForCTC.from_pretrained(MODELS[model_name])
-        processor = Wav2Vec2Processor.from_pretrained(MODELS[model_name])
-    elif model_name == "whisper":
-        model = WhisperForConditionalGeneration.from_pretrained(MODELS[model_name])
-        processor = WhisperProcessor.from_pretrained(MODELS[model_name])
-    else:
-        raise ValueError(f"Unsupported model: {model_name}")
-    
-    return model, processor
-
-def compute_metrics(predictions: List[str], references: List[str]) -> Dict[str, float]:
-    """Compute WER and CER metrics."""
-    from jiwer import cer, wer
-    
-    metrics = {
-        "wer": wer(references, predictions),
-        "cer": cer(references, predictions)
-    }
-    return metrics
-
-def run_benchmark(model_name: str, split: str = "test"):
-    """Run benchmark on specified model and dataset split."""
-    logger.info(f"Running benchmark for {model_name} on {split} split")
-    
-    # Load dataset
-    dataset = load_dataset("parquet", split=split)
-    
-    # Load model and processor
-    model, processor = load_model_and_processor(model_name)
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    model = model.to(device)
-    
-    predictions = []
-    references = []
-    
-    for example in dataset:
-        # Process audio
-        audio_input = processor(example["audio"], return_tensors="pt", padding=True)
-        
-        # Generate prediction
-        with torch.no_grad():
-            if model_name == "wav2vec2":
-                logits = model(audio_input.input_values.to(device)).logits
-                predicted_ids = torch.argmax(logits, dim=-1)
-                transcription = processor.decode(predicted_ids[0])
-            else:  # whisper
-                predicted_ids = model.generate(audio_input.input_features.to(device))
-                transcription = processor.decode(predicted_ids[0], skip_special_tokens=True)
-        
-        predictions.append(transcription)
-        references.append(example["text"])
-    
-    # Compute metrics
-    metrics = compute_metrics(predictions, references)
-    
-    # Save results
-    output_dir = Path("benchmarks") / model_name
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    with open(output_dir / f"{split}_results.json", "w") as f:
-        json.dump({
-            "model": MODELS[model_name],
-            "split": split,
-            "metrics": metrics,
-            "num_examples": len(dataset),
-        }, f, indent=2)
-    
-    logger.info(f"Results saved to {output_dir}/{split}_results.json")
-    return metrics
-
-def main():
-    parser = argparse.ArgumentParser(description="Run benchmarks on HyVoxPopuli dataset")
-    parser.add_argument(
-        "--model",
-        choices=["wav2vec2", "whisper"],
-        required=True,
-        help="Model to benchmark"
-    )
-    parser.add_argument(
-        "--split",
-        choices=["train", "dev", "test"],
-        default="test",
-        help="Dataset split to evaluate on"
-    )
-    
-    args = parser.parse_args()
-    metrics = run_benchmark(args.model, args.split)
-    print(f"Results for {args.model} on {args.split} split:")
-    print(json.dumps(metrics, indent=2))
-
-if __name__ == "__main__":
-    main()

scripts/validate_dataset.py

@@ -1,84 +0,0 @@
-"""Script to validate the HyVoxPopuli dataset structure and contents."""
-
-import os
-import json
-import csv
-from pathlib import Path
-from typing import Dict, List
-
-def validate_audio_files(data_dir: Path, split: str) -> List[str]:
-    """Validate audio files for a given split."""
-    errors = []
-    audio_dir = data_dir / split / f"{split}_dataset.tar.gz"
-    
-    if not audio_dir.exists():
-        errors.append(f"Missing audio archive for split {split}")
-    
-    return errors
-
-def validate_metadata(data_dir: Path, split: str) -> List[str]:
-    """Validate metadata file for a given split."""
-    errors = []
-    metadata_file = data_dir / f"{split}.tsv"
-    
-    if not metadata_file.exists():
-        errors.append(f"Missing metadata file for split {split}")
-        return errors
-    
-    required_columns = {
-        "id", "raw_text", "normalized_text", "speaker_id",
-        "gender", "is_gold_transcript", "accent"
-    }
-    
-    try:
-        with open(metadata_file, "r", encoding="utf-8") as f:
-            reader = csv.DictReader(f, delimiter="\t")
-            headers = set(reader.fieldnames or [])
-            missing_columns = required_columns - headers
-            if missing_columns:
-                errors.append(f"Missing required columns in {split}.tsv: {missing_columns}")
-    except Exception as e:
-        errors.append(f"Error reading {split}.tsv: {str(e)}")
-    
-    return errors
-
-def main():
-    """Main validation function."""
-    data_dir = Path("data")
-    splits = ["train", "dev", "test"]
-    all_errors: Dict[str, List[str]] = {}
-
-    # Validate n_files.json
-    n_files_path = data_dir / "n_files.json"
-    if not n_files_path.exists():
-        all_errors["n_files"] = ["Missing n_files.json"]
-    else:
-        try:
-            with open(n_files_path, "r") as f:
-                n_files = json.load(f)
-                if not all(split in n_files for split in splits):
-                    all_errors["n_files"] = ["Missing split information in n_files.json"]
-        except json.JSONDecodeError:
-            all_errors["n_files"] = ["Invalid JSON in n_files.json"]
-
-    # Validate each split
-    for split in splits:
-        errors = []
-        errors.extend(validate_audio_files(data_dir, split))
-        errors.extend(validate_metadata(data_dir, split))
-        if errors:
-            all_errors[split] = errors
-
-    # Print results
-    if all_errors:
-        print("\nValidation Errors:")
-        for category, errors in all_errors.items():
-            print(f"\n{category}:")
-            for error in errors:
-                print(f"  - {error}")
-        exit(1)
-    else:
-        print("\nValidation successful! Dataset structure is correct.")
-
-if __name__ == "__main__":
-    main()

setup.py

@@ -1,30 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="hyvoxpopuli",
-    version="1.0.0",
-    author="Edmon",
-    author_email="",  # Add your email
-    description="A high-quality Armenian speech recognition dataset",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://huggingface.co/datasets/Edmon02/hyvoxpopuli",
-    packages=find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: Creative Commons Attribution 4.0 International License",
-        "Operating System :: OS Independent",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-        "Topic :: Multimedia :: Sound/Audio :: Speech",
-    ],
-    python_requires=">=3.7",
-    install_requires=[
-        "datasets>=2.0.0",
-        "librosa>=0.8.0",
-        "torch>=1.7.0",
-        "torchaudio>=0.7.0",
-    ],
-)

tests/test_dataset.py

@@ -1,56 +0,0 @@
-"""Tests for the HyVoxPopuli dataset."""
-import os
-import unittest
-import tempfile
-
-import datasets
-import numpy as np
-
-
-class TestHyVoxPopuli(unittest.TestCase):
-    """Test cases for HyVoxPopuli dataset."""
-
-    @classmethod
-    def setUpClass(cls):
-        """Set up test fixtures."""
-        try:
-            cls.dataset = datasets.load_dataset("Edmon02/hyvoxpopuli", split="train[:2]")
-        except Exception as e:
-            raise unittest.SkipTest(f"Failed to load dataset: {str(e)}")
-
-    def test_dataset_features(self):
-        """Test if dataset has the correct features."""
-        expected_features = {
-            "audio_id", "audio", "raw_text", "normalized_text",
-            "gender", "speaker_id", "is_gold_transcript", "accent"
-        }
-        self.assertEqual(set(self.dataset.features.keys()), expected_features)
-
-    def test_audio_sampling_rate(self):
-        """Test if audio sampling rate is correct."""
-        self.assertEqual(self.dataset[0]["audio"]["sampling_rate"], 16000)
-
-    def test_text_fields_not_empty(self):
-        """Test if text fields are not empty."""
-        for example in self.dataset:
-            self.assertTrue(example["normalized_text"].strip())
-            if example["raw_text"]:  # raw_text might be empty for some examples
-                self.assertTrue(example["raw_text"].strip())
-
-    def test_speaker_metadata(self):
-        """Test if speaker metadata is valid."""
-        for example in self.dataset:
-            self.assertIn(example["gender"], ["male", "female"])
-            self.assertTrue(example["speaker_id"].strip())
-
-    def test_audio_array_valid(self):
-        """Test if audio arrays are valid numpy arrays."""
-        for example in self.dataset:
-            audio_array = example["audio"]["array"]
-            self.assertIsInstance(audio_array, np.ndarray)
-            self.assertEqual(audio_array.dtype, np.float32)
-            self.assertTrue(len(audio_array) > 0)
-
-
-if __name__ == "__main__":
-    unittest.main()