Update add_mating_data.py

add_mating_data.py

@@ -15,13 +15,14 @@ from pathlib import Path
 
 import chess
 import chess.engine
+import psutil
 from tqdm import tqdm
 
 from athena.datasets.chessbenchmate.utils.bagz import BagReader, BagWriter
 from athena.datasets.chessbenchmate.utils.constants import CODERS
 
 ENGINE_PATH = "models/stockfish"
-ENGINE_LIMIT = chess.engine.Limit(time=1.0)
+ENGINE_LIMIT = chess.engine.Limit(time=0.05)
 
 # Global variable for each worker process
 engine = None
@@ -44,6 +45,13 @@ def close_worker():
         except Exception:
             pass
 
+def print_memory_usage(description=""):
+    """Print current and total available memory usage."""
+    process = psutil.Process(os.getpid())
+    memory_mb = process.memory_info().rss / 1024 / 1024
+    total_mem_mb = psutil.virtual_memory().total / 1024 / 1024
+    print(f"{description}Memory usage: {memory_mb:.2f} MB / {total_mem_mb:.2f} MB total", flush=True)
+
 
 def annotate_single_record(record: bytes) -> bytes:
     """Annotate a single record with mate-in-N information."""
@@ -112,36 +120,6 @@ def stockfish_evaluate(
     return win_prob, mate_label
 
 
-def batch_annotate_records(records_batch):
-    """Annotate a batch of records for better performance."""
-    global engine
-    results = []
-
-    for record in records_batch:
-        try:
-            fen, move_str, _, _ = CODERS["action_value_with_mate"].decode(record)
-            board = chess.Board(fen)
-            win_prob, mate_label = stockfish_evaluate(board, chess.Move.from_uci(move_str), engine)
-
-            # Validate outputs
-            assert 0.0 <= win_prob <= 1.0, f"Invalid win probability: {win_prob}"
-            valid_mate_label = (
-                mate_label == "#"
-                or mate_label == "-"
-                or (isinstance(mate_label, int) and abs(mate_label) <= 100)
-            )
-            assert valid_mate_label, f"Invalid mate label: {mate_label}"
-
-            results.append(
-                CODERS["action_value_with_mate"].encode((fen, move_str, win_prob, mate_label))
-            )
-        except Exception as e:
-            print(f"Error in batch processing: {e}")
-            raise
-
-    return results
-
-
 def add_mate_annotations(bag_path: Path) -> None:
     """Annotate a .bag file with mate-in-N information in-place."""
     if not bag_path.exists():
@@ -156,7 +134,7 @@ def add_mate_annotations(bag_path: Path) -> None:
         return
 
     # Create temporary file for writing
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".bag") as temp_file:
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".bag", dir=bag_path.parent) as temp_file:
         temp_path = temp_file.name
 
     try:
@@ -166,33 +144,18 @@ def add_mate_annotations(bag_path: Path) -> None:
             f"Processing {len(records)} records from {bag_path.name} using {cpu_count()} processes"
         )
 
-        # Choose between single record and batch processing
-        use_batch_processing = True
-        batch_size = 10  # Adjust based on testing
-
-        if use_batch_processing:
-            # Batch processing approach
-            batches = [records[i : i + batch_size] for i in range(0, len(records), batch_size)]
-
-            with Pool(processes=cpu_count(), initializer=init_worker) as pool:
-                for batch_results in tqdm(
-                    pool.imap(batch_annotate_records, batches),
-                    total=len(batches),
-                    unit="batch",
-                    desc=f"Annotating {bag_path.name}",
-                ):
-                    for annotated_record in batch_results:
-                        writer.write(annotated_record)
-        else:
-            # Single record processing approach
-            with Pool(processes=cpu_count(), initializer=init_worker) as pool:
-                for annotated_record in tqdm(
-                    pool.imap(annotate_single_record, records),
-                    total=len(records),
-                    unit="record",
-                    desc=f"Annotating {bag_path.name}",
-                ):
-                    writer.write(annotated_record)
+    
+        # Single record processing approach
+        with Pool(processes=cpu_count(), initializer=init_worker) as pool:
+            for i, annotated_record in tqdm(enumerate(
+                pool.imap(annotate_single_record, records)),
+                total=len(records),
+                unit="record",
+                desc=f"Annotating {bag_path.name}",
+            ):
+                writer.write(annotated_record)
+                if i % 10000 == 0:
+                    print_memory_usage(f"Processed {i} records. ")
 
         writer.close()
 
@@ -209,20 +172,31 @@ def add_mate_annotations(bag_path: Path) -> None:
 
 
 def main():
-    """Main entry point to parse command line arguments to add mating data to chessbench."""
-    # Test with a small file first
-    test_bag_path = Path("src/athena/datasets/chessbenchmate/data/test/action_value_data.bag")
-    add_mate_annotations(test_bag_path)
-
-    # Process all training files
+    """Main entry point to process .bag files with optional SLURM array division."""
     data_dir = Path("src/athena/datasets/chessbenchmate/data/train")
-    bag_files = list(data_dir.glob("*.bag"))
-    print(f"Found {len(bag_files)} bag files in {data_dir}")
-
-    for bag_file in tqdm(bag_files, total=len(bag_files), desc="Processing all bags"):
+    bag_files = sorted(list(data_dir.glob("*.bag")))
+    num_files = len(bag_files)
+    print(f"Found {num_files} bag files in {data_dir}")
+
+    # Detect SLURM environment variables
+    slurm_task_id = int(os.environ.get("SLURM_ARRAY_TASK_ID", "0"))
+    slurm_array_size = int(os.environ.get("SLURM_ARRAY_TASK_COUNT", "1"))
+
+    # Divide files evenly among SLURM array tasks
+    chunk_size = (num_files + slurm_array_size - 1) // slurm_array_size
+    start = slurm_task_id * chunk_size
+    end = min(start + chunk_size, num_files)
+    my_files = bag_files[start:end]
+
+    print(
+        f"[Job {slurm_task_id}/{slurm_array_size}] Processing {len(my_files)} files "
+        f"from index {start} to {end - 1}"
+    )
+
+    for bag_file in tqdm(my_files, total=len(my_files), desc=f"Job {slurm_task_id}"):
         add_mate_annotations(bag_file)
 
-    print("All files processed successfully!")
+    print(f"[Job {slurm_task_id}] Completed {len(my_files)} files successfully.")
 
 
 if __name__ == "__main__":