remove dataloader

create_splits.py

@@ -1,4 +1,5 @@
 import os
+import pprint
 import pandas as pd
 import torch
 from torch.utils.data import Dataset, DataLoader
@@ -8,7 +9,6 @@ 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,
@@ -19,50 +19,30 @@ def create_dataset_splits(
     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)
+    df = 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)
+    # We will be splitting on the filename. This ensures that a cloned voice is always with the same original voice in a given split, and not split between train/val/test.
+    unique_filenames = df['filename'].unique()
+    np.random.shuffle(unique_filenames)
+
+    n_samples = len(unique_filenames)
     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:])]
+        'train': df[df['filename'].isin(unique_filenames[:train_idx])],
+        'val': df[df['filename'].isin(unique_filenames[train_idx:val_idx])],
+        'test': df[df['filename'].isin(unique_filenames[val_idx:])]
     }
 
     # Save splits
@@ -74,145 +54,35 @@ def create_dataset_splits(
         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
+    split_info = {}
+    split_info['metadata_path'] = metadata_path
+    split_info['seed'] = seed
+    split_info['ratios'] = {
+        'train': train_ratio,
+        'val': val_ratio,
+        'test': round(1 - train_ratio - val_ratio, 2),
     }
-
-    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(),
+    for split_name, split_df in splits.items():
+        split_info[split_name] = {
+            'total_num_samples': len(split_df),
+            'original_samples': len(split_df[split_df['is_cloned_voice'] == False]),
+            'cloned_samples': len(split_df[split_df['is_cloned_voice'] == True]),
+            'sources': split_df['source'].value_counts().to_dict(),
+            'voices_per_source': split_df.groupby('source')['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}")
+    pprint.pprint(split_info)
 
+    with open(output_dir / 'split_info.json', 'w') as f:
+        json.dump(split_info, f, indent=2)
 
 
 # Example usage:
 if __name__ == "__main__":
-    json_file = 'files.json'
-    metadata_file = 'metadata-balanced.csv'
+    # json_file = 'files.json'
+    metadata_file = 'metadata-valid.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)
+    create_dataset_splits(metadata_file, output_dir=output_dir)