add random splits to filtered data

ppb_affinity.py

@@ -3,76 +3,102 @@ import csv
 import random
 
 class ppb_affinity(datasets.GeneratorBasedBuilder):
-    VERSION = datasets.Version("1.0.2")
+    VERSION = datasets.Version("1.0.1")
     
     BUILDER_CONFIGS = [
         datasets.BuilderConfig(name="raw", description="Raw parsed PDBs dataset with critical filtrations only."),
         datasets.BuilderConfig(name="filtered", description="Raw dataset with additional cleaning and train/val/test splits."),
+        datasets.BuilderConfig(name="filtered_random", description="Filtered dataset with random 80-10-10 splits."),
     ]
     
     def _info(self):
         return datasets.DatasetInfo()
-
+    
     def _split_generators(self, dl_manager):
-        """Downloads and defines dataset splits"""
-        filepath = dl_manager.download_and_extract("filtered.csv")
-        
-        return [
-            datasets.SplitGenerator(
+        if self.config.name == "raw":
+            filepath = dl_manager.download_and_extract("raw.csv")
+            return [datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
-                gen_kwargs={"filepath": filepath, "split": "train"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"filepath": filepath, "split": "val"},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"filepath": filepath, "split": "test"},
-            ),
-
-            datasets.SplitGenerator(
-                name=datasets.NamedSplit("train_rand"),
-                gen_kwargs={"filepath": filepath, "split": "train_rand", "random_split": True},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.NamedSplit("validation_rand"),
-                gen_kwargs={"filepath": filepath, "split": "val_rand", "random_split": True},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.NamedSplit("test_rand"),
-                gen_kwargs={"filepath": filepath, "split": "test_rand", "random_split": True},
-            ),
-        ]
-
-    def _generate_examples(self, filepath, split=None, random_split=False):
-        """Generates examples, either using predefined splits or random splits"""
+                gen_kwargs={"filepath": filepath}
+            )]
+        elif self.config.name == "filtered":
+            filepath = dl_manager.download_and_extract("filtered.csv")
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={"filepath": filepath, "split": "train"},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    gen_kwargs={"filepath": filepath, "split": "val"},
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    gen_kwargs={"filepath": filepath, "split": "test"},
+                ),
+            ]
+        elif self.config.name == "filtered_random":
+            filepath = dl_manager.download_and_extract("filtered.csv")
+            # Read all rows to determine splits
+            with open(filepath, encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+            n_total = len(rows)
+            # Generate shuffled indices with fixed seed
+            indices = list(range(n_total))
+            rng = random.Random(42)  # Fixed seed for reproducibility
+            rng.shuffle(indices)
+            # Calculate split sizes
+            n_train = int(0.8 * n_total)
+            n_val = int(0.1 * n_total)
+            n_test = n_total - n_train - n_val  # Handle remainder
+            # Split indices into ranges
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.NamedSplit("train_rand"),
+                    gen_kwargs={
+                        "filepath": filepath,
+                        "shuffled_indices": indices,
+                        "split_start": 0,
+                        "split_end": n_train,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.NamedSplit("validation_rand"),
+                    gen_kwargs={
+                        "filepath": filepath,
+                        "shuffled_indices": indices,
+                        "split_start": n_train,
+                        "split_end": n_train + n_val,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.NamedSplit("test_rand"),
+                    gen_kwargs={
+                        "filepath": filepath,
+                        "shuffled_indices": indices,
+                        "split_start": n_train + n_val,
+                        "split_end": n_total,
+                    },
+                ),
+            ]
+    
+    def _generate_examples(self, filepath, split=None, shuffled_indices=None, split_start=None, split_end=None):
         with open(filepath, encoding="utf-8") as f:
             reader = csv.DictReader(f)
-            data = list(reader)
-
-        if random_split:
-            return self._generate_examples_rand(data, split)
-        
-        for idx, row in enumerate(data):
-            if row["split"] == split:
-                del row["split"]  # Remove split column from examples
-                yield idx, row
-
-    def _generate_examples_rand(self, data, split):
-        """Randomly splits the dataset into 80% train, 10% val, 10% test with a fixed seed"""
-        random.seed(42)
-        random.shuffle(data)
-
-        total = len(data)
-        train_end = int(0.8 * total)
-        val_end = train_end + int(0.1 * total)
-
-        split_map = {
-            "train_rand": data[:train_end],
-            "val_rand": data[train_end:val_end],
-            "test_rand": data[val_end:]
-        }
-
-        for idx, row in enumerate(split_map[split]):
-            yield idx, row
+            rows = list(reader)
+            if self.config.name == "raw":
+                for idx, row in enumerate(reader):
+                    yield idx, row
+            elif self.config.name == "filtered":
+                for idx, row in enumerate(reader):
+                    if row["split"] == split:
+                        del row["split"]
+                        yield idx, row
+            elif self.config.name == "filtered_random":
+                # Iterate over the range [split_start, split_end) in shuffled_indices
+                for global_idx in range(split_start, split_end):
+                    original_idx = shuffled_indices[global_idx]
+                    row = rows[original_idx]
+                    del row["split"]  # Remove original split column
+                    yield global_idx, row  # Key is global shuffled index