Fix filtering: use GeneratorBasedBuilder instead of ArrowBasedBuilder

permutation-groups.py

@@ -76,7 +76,7 @@ class PermutationGroupsConfig(datasets.BuilderConfig):
         self.min_len = min_len
         self.max_len = max_len
 
-class PermutationGroups(datasets.ArrowBasedBuilder):
+class PermutationGroups(datasets.GeneratorBasedBuilder):
     """Permutation groups dataset with dynamic filtering."""
     
     VERSION = datasets.Version("4.0.0")
@@ -226,14 +226,12 @@ class PermutationGroups(datasets.ArrowBasedBuilder):
                     name=datasets.Split.TRAIN,
                     gen_kwargs={
                         "files": downloaded_files["train"],
-                        "config": self.config,
                     },
                 ),
                 datasets.SplitGenerator(
                     name=datasets.Split.TEST,
                     gen_kwargs={
                         "files": downloaded_files["test"],
-                        "config": self.config,
                     },
                 ),
             ]
@@ -244,52 +242,59 @@ class PermutationGroups(datasets.ArrowBasedBuilder):
                     name=datasets.Split.TRAIN,
                     gen_kwargs={
                         "files": [],
-                        "config": self.config,
                     },
                 ),
                 datasets.SplitGenerator(
                     name=datasets.Split.TEST,
                     gen_kwargs={
                         "files": [],
-                        "config": self.config,
                     },
                 ),
             ]
     
-    def _generate_tables(self, files, config):
-        """Yield arrow tables with filtering."""
-        for file_idx, file in enumerate(files):
-            # Load the dataset
-            dataset = datasets.Dataset.from_file(file)
+    def _generate_examples(self, files):
+        """Yield examples with filtering."""
+        idx = 0
+        
+        for file_path in files:
+            # Load the arrow file
+            with pa.memory_map(file_path, 'r') as source:
+                table = pa.ipc.open_file(source).read_all()
+            
+            # Convert to pandas for easier row-wise iteration
+            df = table.to_pandas()
             
-            # Apply filters
-            def filter_fn(example):
-                # Filter by group type (if not already filtered by file selection)
-                if config.group_type and example.get("group_type") != config.group_type:
-                    return False
+            # Iterate through rows and apply filters
+            for _, row in df.iterrows():
+                # Apply filters
+                # Filter by group type (if specified)
+                if self.config.group_type and row.get("group_type") != self.config.group_type:
+                    continue
                 
                 # Filter by degree
-                if config.min_degree and example.get("group_degree", 0) < config.min_degree:
-                    return False
-                if config.max_degree and example.get("group_degree", float('inf')) > config.max_degree:
-                    return False
+                if self.config.min_degree and row.get("group_degree", 0) < self.config.min_degree:
+                    continue
+                if self.config.max_degree and row.get("group_degree", float('inf')) > self.config.max_degree:
+                    continue
                 
                 # Filter by order
-                if config.min_order and example.get("group_order", 0) < config.min_order:
-                    return False
-                if config.max_order and example.get("group_order", float('inf')) > config.max_order:
-                    return False
+                if self.config.min_order and row.get("group_order", 0) < self.config.min_order:
+                    continue
+                if self.config.max_order and row.get("group_order", float('inf')) > self.config.max_order:
+                    continue
                 
                 # Filter by sequence length
-                seq_len = example.get("sequence_length", len(example["input_sequence"].split()))
-                if seq_len < config.min_len or seq_len > config.max_len:
-                    return False
+                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:
+                    continue
                 
-                return True
-            
-            # Apply filtering
-            dataset = dataset.filter(filter_fn)
-            
-            # Get the underlying Arrow table
-            table = dataset.data.table
-            yield file_idx, table
+                # Yield the example
+                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)),
+                }
+                idx += 1