Add cluster-balanced PyTorch sampler to dataset card

README.md

@@ -51,6 +51,114 @@ This artifact-only rebuild does not rerun Foldseek or MMseqs2. It enforces and
 verifies the published cluster labels plus optional external sequence
 verification edges when supplied.
 
+## Cluster-Balanced PyTorch Sampling
+
+The training split can be loaded with `streaming=False` and sampled as one
+random row per sequence-cluster group per epoch. Chain mode groups by
+`sequence_cluster_30`. Complex mode defaults to one sample per member sequence
+cluster from `sequence_clusters_30`; set `complex_grouping="cluster_set"` to
+sample one row per unique complex cluster signature instead.
+
+```python
+import collections
+import random
+from typing import Any, Mapping, Optional
+
+from datasets import load_dataset
+from torch.utils.data import DataLoader, Dataset
+
+
+DEFAULT_REPO_ID = "Synthyra/PDB-Chain-Complex-Benchmark-Rigor"
+
+
+class PDBClusteredDataset(Dataset):
+    """One randomly selected row per sequence-cluster group per epoch."""
+
+    def __init__(
+        self,
+        repo_id: str = DEFAULT_REPO_ID,
+        mode: str = "chains",
+        split: str = "train",
+        seed: int = 0,
+        epoch: int = 0,
+        cluster_key: Optional[str] = None,
+        complex_grouping: str = "member_cluster",
+        load_kwargs: Optional[Mapping[str, Any]] = None,
+    ) -> None:
+        mode_to_config = {
+            "single": "chains",
+            "chains": "chains",
+            "complex": "complexes",
+            "complexes": "complexes",
+        }
+        self.config = mode_to_config[mode]
+        self.seed = int(seed)
+        self.cluster_key = cluster_key or (
+            "sequence_cluster_30" if self.config == "chains" else "sequence_clusters_30"
+        )
+        self.complex_grouping = complex_grouping
+        self.dataset = load_dataset(
+            repo_id,
+            self.config,
+            split=split,
+            streaming=False,
+            **dict(load_kwargs or {}),
+        )
+        self.groups = self._build_groups()
+        self.group_keys = sorted(self.groups)
+        self.set_epoch(epoch)
+
+    def _group_keys_for_value(self, value: Any) -> tuple[tuple[str, ...], ...]:
+        if self.config == "chains":
+            return ((str(value),),)
+
+        clusters = tuple(sorted({str(cluster) for cluster in value if str(cluster)}))
+        if not clusters:
+            raise ValueError("complex row has no sequence cluster labels")
+        if self.complex_grouping == "cluster_set":
+            return (clusters,)
+        if self.complex_grouping == "member_cluster":
+            return tuple((cluster,) for cluster in clusters)
+        raise ValueError("complex_grouping must be 'member_cluster' or 'cluster_set'")
+
+    def _build_groups(self) -> dict[tuple[str, ...], list[int]]:
+        groups = collections.defaultdict(list)
+        for row_idx, value in enumerate(self.dataset[self.cluster_key]):
+            for key in self._group_keys_for_value(value):
+                groups[key].append(row_idx)
+        if not groups:
+            raise ValueError("dataset split contains no rows")
+        return dict(groups)
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = int(epoch)
+        rng = random.Random(self.seed + self.epoch)
+        self.indices = [rng.choice(self.groups[key]) for key in self.group_keys]
+
+    def __len__(self) -> int:
+        return len(self.indices)
+
+    def __getitem__(self, index: int) -> Mapping[str, Any]:
+        return self.dataset[self.indices[index]]
+
+
+def identity_collate(batch: list[Mapping[str, Any]]) -> list[Mapping[str, Any]]:
+    return batch
+
+
+chains = PDBClusteredDataset(mode="single", split="train", seed=42)
+complexes = PDBClusteredDataset(mode="complex", split="train", seed=42)
+
+chains_loader = DataLoader(chains, batch_size=8, shuffle=False, collate_fn=identity_collate)
+complex_loader = DataLoader(complexes, batch_size=2, shuffle=False, collate_fn=identity_collate)
+
+for epoch in range(3):
+    chains.set_epoch(epoch)
+    complexes.set_epoch(epoch)
+    first_chain_batch = next(iter(chains_loader))
+    first_complex_batch = next(iter(complex_loader))
+```
+
 ## Build Metadata
 
 ```json