Update loading script to v5.0.0 with all 10 groups and dynamic filtering

permutation-groups.py

@@ -1,41 +1,12 @@
 import datasets
 import json
 import os
-import pyarrow as pa
+import pandas as pd
 
 _DESCRIPTION = "Permutation composition datasets with dynamic filtering by group degree, order, and sequence length."
 _HOMEPAGE = "https://huggingface.co/datasets/BeeGass/permutation-groups"
 _LICENSE = "MIT"
 
-# TEMPORARY: Define the actual file structure explicitly
-# TODO: Revert to wildcard patterns once datasets library supports them properly
-_DATA_FILES = {
-    "symmetric_superset": {
-        "train": ["data-00000-of-00003.arrow", "data-00001-of-00003.arrow", "data-00002-of-00003.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    },
-    "alternating_superset": {
-        "train": ["data-00000-of-00003.arrow", "data-00001-of-00003.arrow", "data-00002-of-00003.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    },
-    "cyclic_superset": {
-        "train": ["data-00000-of-00001.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    },
-    "dihedral_superset": {
-        "train": ["data-00000-of-00001.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    },
-    "psl25_data": {
-        "train": ["data-00000-of-00001.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    },
-    "f20_data": {
-        "train": ["data-00000-of-00001.arrow"],
-        "test": ["data-00000-of-00001.arrow"]
-    }
-}
-
 class PermutationGroupsConfig(datasets.BuilderConfig):
     def __init__(
         self, 
@@ -52,7 +23,8 @@ class PermutationGroupsConfig(datasets.BuilderConfig):
         Configuration for loading permutation groups.
         
         Args:
-            group_type: Type of group (symmetric, alternating, cyclic, dihedral, psl25, f20)
+            group_type: Type of group (symmetric, alternating, cyclic, dihedral, klein, 
+                       quaternion, elementary_abelian, psl, frobenius, mathieu)
             min_degree: Minimum group degree to include
             max_degree: Maximum group degree to include
             min_order: Minimum group order to include
@@ -79,10 +51,14 @@ class PermutationGroupsConfig(datasets.BuilderConfig):
 class PermutationGroups(datasets.GeneratorBasedBuilder):
     """Permutation groups dataset with dynamic filtering."""
     
-    VERSION = datasets.Version("4.0.0")
+    VERSION = datasets.Version("5.0.0")
     
-    # Define available group types
-    GROUP_TYPES = ["symmetric", "alternating", "cyclic", "dihedral", "psl25", "f20"]
+    # Define all available group types
+    GROUP_TYPES = [
+        "symmetric", "alternating", "cyclic", "dihedral", 
+        "klein", "quaternion", "elementary_abelian", "psl", 
+        "frobenius", "mathieu"
+    ]
     
     BUILDER_CONFIGS = []
     
@@ -105,66 +81,6 @@ class PermutationGroups(datasets.GeneratorBasedBuilder):
         )
     )
     
-    # Keep backwards compatibility configs
-    LEGACY_GROUPS = {
-        "s3": ("symmetric", 3, 3), "s4": ("symmetric", 4, 4), "s5": ("symmetric", 5, 5),
-        "s6": ("symmetric", 6, 6), "s7": ("symmetric", 7, 7), "s8": ("symmetric", 8, 8),
-        "s9": ("symmetric", 9, 9), "s10": ("symmetric", 10, 10),
-        "a3": ("alternating", 3, 3), "a4": ("alternating", 4, 4), "a5": ("alternating", 5, 5),
-        "a6": ("alternating", 6, 6), "a7": ("alternating", 7, 7), "a8": ("alternating", 8, 8),
-        "a9": ("alternating", 9, 9), "a10": ("alternating", 10, 10),
-        "c3": ("cyclic", 3, 3), "c4": ("cyclic", 4, 4), "c5": ("cyclic", 5, 5),
-        "c6": ("cyclic", 6, 6), "c7": ("cyclic", 7, 7), "c8": ("cyclic", 8, 8),
-        "c9": ("cyclic", 9, 9), "c10": ("cyclic", 10, 10), "c12": ("cyclic", 12, 12),
-        "c15": ("cyclic", 15, 15), "c20": ("cyclic", 20, 20), "c25": ("cyclic", 25, 25),
-        "c30": ("cyclic", 30, 30),
-        "z3": ("cyclic", 3, 3), "z4": ("cyclic", 4, 4), "z5": ("cyclic", 5, 5), "z6": ("cyclic", 6, 6),
-        "d3": ("dihedral", 3, 3), "d4": ("dihedral", 4, 4), "d5": ("dihedral", 5, 5),
-        "d6": ("dihedral", 6, 6), "d7": ("dihedral", 7, 7), "d8": ("dihedral", 8, 8),
-        "d9": ("dihedral", 9, 9), "d10": ("dihedral", 10, 10), "d12": ("dihedral", 12, 12),
-        "d15": ("dihedral", 15, 15), "d20": ("dihedral", 20, 20),
-    }
-    
-    for name, (group_type, min_deg, max_deg) in LEGACY_GROUPS.items():
-        # Simple name (e.g., "s5")
-        BUILDER_CONFIGS.append(
-            PermutationGroupsConfig(
-                name=name,
-                description=f"Legacy config for {name.upper()}",
-                group_type=group_type,
-                min_degree=min_deg,
-                max_degree=max_deg,
-            )
-        )
-        # Old style name (e.g., "s5_data")
-        BUILDER_CONFIGS.append(
-            PermutationGroupsConfig(
-                name=f"{name}_data",
-                description=f"Legacy config for {name.upper()}",
-                group_type=group_type,
-                min_degree=min_deg,
-                max_degree=max_deg,
-            )
-        )
-    
-    # Add legacy configs for special groups
-    BUILDER_CONFIGS.extend([
-        PermutationGroupsConfig(
-            name="psl25_data",
-            description="Legacy config for PSL(2,5)",
-            group_type="psl25",
-            min_degree=6,
-            max_degree=6,
-        ),
-        PermutationGroupsConfig(
-            name="f20_data",
-            description="Legacy config for F20",
-            group_type="f20",
-            min_degree=5,
-            max_degree=5,
-        ),
-    ])
-    
     DEFAULT_CONFIG_NAME = "symmetric"
     
     def _info(self):
@@ -185,137 +101,110 @@ class PermutationGroups(datasets.GeneratorBasedBuilder):
     def _split_generators(self, dl_manager):
         # Determine which datasets to load
         if self.config.group_type:
-            if self.config.group_type in ["psl25", "f20"]:
-                # PSL25 and F20 are stored as individual datasets
-                datasets_to_load = [f"{self.config.group_type}_data"]
-            else:
-                # Load the superset for this group type
-                datasets_to_load = [f"{self.config.group_type}_superset"]
+            # Load the superset for this group type
+            datasets_to_load = [f"{self.config.group_type}_superset"]
         else:
             # Load all supersets
-            datasets_to_load = ["symmetric_superset", "alternating_superset", 
-                              "cyclic_superset", "dihedral_superset", 
-                              "psl25_data", "f20_data"]
+            datasets_to_load = [
+                "symmetric_superset", "alternating_superset", 
+                "cyclic_superset", "dihedral_superset",
+                "klein_superset", "quaternion_superset",
+                "elementary_abelian_superset", "psl_superset",
+                "frobenius_superset", "mathieu_superset"
+            ]
         
-        # TEMPORARY: Build explicit file URLs instead of using wildcards
-        # TODO: Revert to wildcard pattern once supported:
-        # data_urls = {
-        #     "train": f"data/{dataset_name}/train/data-*-of-*.arrow",
-        #     "test": f"data/{dataset_name}/test/data-*-of-*.arrow",
-        # }
+        # Build file URLs using wildcards
         train_urls = []
         test_urls = []
         
         for dataset_name in datasets_to_load:
-            if dataset_name in _DATA_FILES:
-                # Build full URLs for each file
-                for filename in _DATA_FILES[dataset_name]["train"]:
-                    train_urls.append(f"data/{dataset_name}/train/{filename}")
-                for filename in _DATA_FILES[dataset_name]["test"]:
-                    test_urls.append(f"data/{dataset_name}/test/{filename}")
+            train_urls.append(f"data/{dataset_name}/train/data-*.arrow")
+            test_urls.append(f"data/{dataset_name}/test/data-*.arrow")
         
         # Download files
-        if train_urls and test_urls:
-            downloaded_files = dl_manager.download({
-                "train": train_urls,
-                "test": test_urls
-            })
-            
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": downloaded_files["train"],
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": downloaded_files["test"],
-                    },
-                ),
-            ]
-        else:
-            # Return empty splits if no files found
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": [],
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": [],
-                    },
-                ),
-            ]
+        downloaded_files = dl_manager.download({
+            "train": train_urls,
+            "test": test_urls
+        })
+        
+        # Flatten the lists of files
+        train_files = []
+        test_files = []
+        
+        for file_list in downloaded_files["train"]:
+            if isinstance(file_list, list):
+                train_files.extend(file_list)
+            else:
+                train_files.append(file_list)
+                
+        for file_list in downloaded_files["test"]:
+            if isinstance(file_list, list):
+                test_files.extend(file_list)
+            else:
+                test_files.append(file_list)
+        
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "files": train_files,
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "files": test_files,
+                },
+            ),
+        ]
     
     def _generate_examples(self, files):
         """Yield examples with filtering."""
         idx = 0
-        total_examined = 0
-        total_filtered_out = 0
         
         for file_path in files:
-            # Load the dataset file using datasets library
-            dataset = datasets.Dataset.from_file(file_path)
+            # Load the Arrow file
+            table = datasets.table.read_table(file_path)
             
-            # Convert to pandas for easier row-wise iteration
-            df = dataset.to_pandas()
+            # Convert to pandas for easier filtering
+            df = table.to_pandas()
             
-            # Iterate through rows and apply filters
-            for _, row in df.iterrows():
-                total_examined += 1
-                
-                # Apply filters
-                # Filter by group type (if specified)
-                if self.config.group_type and row.get("group_type") != self.config.group_type:
-                    total_filtered_out += 1
-                    continue
-                
-                # Filter by degree
-                if self.config.min_degree and row.get("group_degree", 0) < self.config.min_degree:
-                    total_filtered_out += 1
-                    continue
-                if self.config.max_degree and row.get("group_degree", float('inf')) > self.config.max_degree:
-                    total_filtered_out += 1
-                    continue
-                
-                # Filter by order
-                if self.config.min_order and row.get("group_order", 0) < self.config.min_order:
-                    total_filtered_out += 1
-                    continue
-                if self.config.max_order and row.get("group_order", float('inf')) > self.config.max_order:
-                    total_filtered_out += 1
-                    continue
-                
-                # Filter by sequence length
-                seq_len = row.get("sequence_length", len(row["input_sequence"].split()))
-                if seq_len < self.config.min_len or seq_len > self.config.max_len:
-                    total_filtered_out += 1
-                    continue
-                
-                # Yield the example
+            # Apply filters
+            mask = pd.Series([True] * len(df))
+            
+            # Filter by group type (if specified in config)
+            if self.config.group_type:
+                mask &= (df["group_type"] == self.config.group_type)
+            
+            # Filter by degree
+            if self.config.min_degree is not None:
+                mask &= (df["group_degree"] >= self.config.min_degree)
+            if self.config.max_degree is not None:
+                mask &= (df["group_degree"] <= self.config.max_degree)
+            
+            # Filter by order
+            if self.config.min_order is not None:
+                mask &= (df["group_order"] >= self.config.min_order)
+            if self.config.max_order is not None:
+                mask &= (df["group_order"] <= self.config.max_order)
+            
+            # Filter by sequence length
+            if self.config.min_len is not None:
+                mask &= (df["sequence_length"] >= self.config.min_len)
+            if self.config.max_len is not None:
+                mask &= (df["sequence_length"] <= self.config.max_len)
+            
+            # Apply mask
+            filtered_df = df[mask]
+            
+            # Yield filtered examples
+            for _, row in filtered_df.iterrows():
                 yield idx, {
                     "input_sequence": row["input_sequence"],
                     "target": row["target"],
-                    "group_type": row.get("group_type", ""),
-                    "group_degree": int(row.get("group_degree", 0)),
-                    "group_order": int(row.get("group_order", 0)),
-                    "sequence_length": int(row.get("sequence_length", seq_len)),
+                    "group_type": row["group_type"],
+                    "group_degree": int(row["group_degree"]),
+                    "group_order": int(row["group_order"]),
+                    "sequence_length": int(row["sequence_length"]),
                 }
-                idx += 1
-        
-        # Log a warning if all examples were filtered out
-        if idx == 0 and total_examined > 0:
-            import warnings
-            warnings.warn(
-                f"All {total_examined} examples were filtered out with the current configuration:\n"
-                f"  group_type={self.config.group_type}\n"
-                f"  degree_range=[{self.config.min_degree}, {self.config.max_degree}]\n"
-                f"  order_range=[{self.config.min_order}, {self.config.max_order}]\n"
-                f"  length_range=[{self.config.min_len}, {self.config.max_len}]\n"
-                f"This might be expected if the requested configuration doesn't exist in the dataset."
-            )
+                idx += 1