WIP: create splits for dataset and dataset itself

create_splits.py

@@ -0,0 +1,218 @@
+import os
+import pandas as pd
+import torch
+from torch.utils.data import Dataset, DataLoader
+from pathlib import Path
+import json
+from typing import List, Dict, Optional
+import numpy as np
+
+def create_dataset_splits(
+    data_path: str,
+    metadata_path: str,
+    output_dir: str,
+    train_ratio: float = 0.8,
+    val_ratio: float = 0.1,
+    seed: int = 42
+):
+    """
+    Create and save train/val/test splits to disk.
+
+    Args:
+        data_path: Path to the JSON file containing voice mappings
+        metadata_path: Path to the metadata CSV file
+        output_dir: Directory to save the split CSV files
+        train_ratio: Ratio of data to use for training
+        val_ratio: Ratio of data to use for validation
+        seed: Random seed for reproducibility
+    """
+    # Load raw data
+    with open(data_path, 'r') as f:
+        raw_data = json.load(f)
+
+    df_metadata = pd.read_csv(metadata_path)
+
+    # Convert to DataFrame
+    records = []
+    for path, available_models in raw_data.items():
+        df_metadata_row = df_metadata[df_metadata['path'] == path]
+        for model in available_models:
+            records.append({
+                'path': path,
+                'model': model,
+                'is_cloned_voice': model != 'commonvoice',
+                'age': df_metadata_row['age'].values[0],
+                'gender': df_metadata_row['gender'].values[0],
+                'accents': df_metadata_row['accents'].values[0],
+                'sentence': df_metadata_row['sentence'].values[0],
+            })
+
+    df = pd.DataFrame.from_records(records)
+
+    # Create deterministic split based on path
+    np.random.seed(seed)
+    unique_paths = df['path'].unique()
+    np.random.shuffle(unique_paths)
+
+    n_samples = len(unique_paths)
+    train_idx = int(n_samples * train_ratio)
+    val_idx = int(n_samples * (train_ratio + val_ratio))
+
+    # Create split DataFrames
+    splits = {
+        'train': df[df['path'].isin(unique_paths[:train_idx])],
+        'val': df[df['path'].isin(unique_paths[train_idx:val_idx])],
+        'test': df[df['path'].isin(unique_paths[val_idx:])]
+    }
+
+    # Save splits
+    output_dir = Path(output_dir)
+    output_dir.mkdir(exist_ok=True, parents=True)
+
+    # Save individual splits
+    for split_name, split_df in splits.items():
+        split_df.to_csv(output_dir / f'{split_name}.csv', index=False)
+
+    # Save split info
+    split_info = {
+        'num_samples': {
+            split_name: len(paths)
+            for split_name, paths in {
+                'train': unique_paths[:train_idx],
+                'val': unique_paths[train_idx:val_idx],
+                'test': unique_paths[val_idx:]
+            }.items()
+        },
+        'train_ratio': train_ratio,
+        'val_ratio': val_ratio,
+        'seed': seed
+    }
+
+    with open(output_dir / 'split_info.json', 'w') as f:
+        json.dump(split_info, f, indent=2)
+
+class VoiceDataset(Dataset):
+    def __init__(
+        self,
+        split_path: str,
+        clips_dir: str,
+        models: Optional[List[str]] = None
+    ):
+        """
+        Args:
+            split_path: Path to the CSV file containing the split data
+            models: List of model names to include. If None, includes all models
+        """
+        self.data = pd.read_csv(split_path)
+        self.clips_dir = clips_dir
+
+        # Filter models if specified
+        if models is not None:
+            self.data = self.data[self.data['model'].isin(models)]
+
+        # Create path to index mapping
+        self.path_to_idx = {path: idx for idx, path in enumerate(self.data['path'].unique())}
+        self.split_name = Path(split_path).stem  # Get split name from file path
+        self.original_models = [model for model in self.data['model'].unique() if model != 'commonvoice']
+
+
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        row = self.data.iloc[idx]
+        path = row['path']
+        model = row['model']
+        rel_path = os.path.join(model, path)
+        abs_path = os.path.join(self.clips_dir, rel_path)
+        return {
+            'path': abs_path,
+            'model': model,
+            'is_cloned_voice': row['is_cloned_voice'],
+        }
+
+    def summary(self) -> Dict:
+        """
+        Generate a comprehensive summary of the dataset.
+
+        Returns:
+            Dictionary containing summary statistics
+        """
+        summary = {
+            'split': self.split_name,
+            'total_samples': len(self.data),
+            'cloned_samples': len(self.data[self.data['is_cloned_voice']]),
+            'original_samples': len(self.data[~self.data['is_cloned_voice']]),
+            'unique_voices': len(self.path_to_idx),
+            'models': {
+                'available': list(self.original_models),
+                'selected': list(self.data['model'].unique()),
+            },
+            'samples_per_model': self.data['model'].value_counts().to_dict(),
+            'voices_per_model': self.data.groupby('model')['path'].nunique().to_dict(),
+        }
+
+        return summary
+
+
+    def print_summary(self):
+        """
+        Print a formatted summary of the dataset.
+
+        Args:
+            include_metadata: Whether to include metadata statistics in the summary
+        """
+        summary = self.summary()
+
+        print(f"\n=== Dataset Summary ({summary['split'].upper()} split) ===")
+        print(f"Total samples: {summary['total_samples']}")
+        print(f"Cloned samples: {summary['cloned_samples']}")
+        print(f"Original samples: {summary['original_samples']}")
+
+        print("\nModels:")
+        print(f"Available: {', '.join(summary['models']['available'])}")
+        print(f"Selected: {', '.join(summary['models']['selected'])}")
+
+        print("\nSamples per model:")
+        for model, count in summary['samples_per_model'].items():
+            print(f"  {model}: {count}")
+
+        print("\nUnique voices per model:")
+        for model, count in summary['voices_per_model'].items():
+            print(f"  {model}: {count}")
+
+
+
+# Example usage:
+if __name__ == "__main__":
+    json_file = 'files.json'
+    metadata_file = 'metadata-balanced.csv'
+    clips_dir = '.'
+    output_dir = 'splits'
+
+    # Create splits
+    create_dataset_splits(json_file, metadata_file, output_dir=output_dir)
+
+
+    # Create datasets for each split
+    train_dataset = VoiceDataset(
+        'splits/train.csv',
+        clips_dir=clips_dir,
+        models=['commonvoice', 'metavoice', 'xttsv2']
+    )
+
+    val_dataset = VoiceDataset(
+        'splits/val.csv',
+        clips_dir=clips_dir,
+        models=['commonvoice', 'metavoice', 'xttsv2']
+    )
+
+    test_dataset = VoiceDataset(
+        'splits/test.csv',
+        clips_dir=clips_dir,
+        models=['commonvoice', 'metavoice', 'xttsv2']
+    )
+
+    # Create DataLoader
+    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)