save best prgoram

Author: codelion

openevolve/controller.py

@@ -33,6 +33,12 @@ class OpenEvolve:
     
     Orchestrates the evolution process, coordinating between the prompt sampler,
     LLM ensemble, evaluator, and program database.
+    
+    Features:
+    - Tracks the absolute best program across evolution steps
+    - Ensures the best solution is not lost during the MAP-Elites process
+    - Always includes the best program in the selection process for inspiration
+    - Maintains detailed logs and metadata about improvements
     """
 
     def __init__(
@@ -238,6 +244,11 @@ async def run(
                 iteration_time = time.time() - iteration_start
                 self._log_iteration(i, parent, child_program, iteration_time)
 
+                # Specifically check if this is the new best program
+                if self.database.best_program_id == child_program.id:
+                    logger.info(f"🌟 New best solution found at iteration {i+1}: {child_program.id}")
+                    logger.info(f"Metrics: {', '.join(f'{name}={value:.4f}' for name, value in child_program.metrics.items())}")
+                
                 # Save checkpoint
                 if (i + 1) % self.config.checkpoint_interval == 0:
                     self._save_checkpoint(i + 1)
@@ -255,17 +266,25 @@ async def run(
                 logger.error(f"Error in iteration {i+1}: {str(e)}")
                 continue
 
-        # Get the best program
-        best_program = self.database.get_best_program()
+        # Get the best program using our tracking mechanism
+        best_program = None
+        if self.database.best_program_id:
+            best_program = self.database.get(self.database.best_program_id)
+            logger.info(f"Using tracked best program: {self.database.best_program_id}")
+        
+        # Fallback to calculating best program if tracked program not found
+        if best_program is None:
+            best_program = self.database.get_best_program()
+            logger.info("Using calculated best program (tracked program not found)")
 
         if best_program:
             logger.info(
                 f"Evolution complete. Best program has metrics: "
                 f"{', '.join(f'{name}={value:.4f}' for name, value in best_program.metrics.items())}"
             )
 
-            # Save the best program
-            self._save_best_program(best_program)
+            # Save the best program (using our tracked best program)
+            self._save_best_program()
 
             return best_program
         else:
@@ -322,13 +341,25 @@ def _save_checkpoint(self, iteration: int) -> None:
 
         logger.info(f"Saved checkpoint at iteration {iteration} to {checkpoint_path}")
 
-    def _save_best_program(self, program: Program) -> None:
+    def _save_best_program(self, program: Optional[Program] = None) -> None:
         """
         Save the best program
         
         Args:
-            program: Best program
+            program: Best program (if None, uses the tracked best program)
         """
+        # If no program is provided, use the tracked best program from the database
+        if program is None:
+            if self.database.best_program_id:
+                program = self.database.get(self.database.best_program_id)
+            else:
+                # Fallback to calculating best program if no tracked best program
+                program = self.database.get_best_program()
+                
+        if not program:
+            logger.warning("No best program found to save")
+            return
+            
         best_dir = os.path.join(self.output_dir, "best")
         os.makedirs(best_dir, exist_ok=True)
 
@@ -345,4 +376,16 @@ def _save_best_program(self, program: Program) -> None:
             import json
             json.dump(program.metrics, f, indent=2)
 
+        # Also save metadata about the best program
+        meta_path = os.path.join(best_dir, "best_program_info.json")
+        with open(meta_path, "w") as f:
+            import json
+            json.dump({
+                "id": program.id,
+                "generation": program.generation,
+                "timestamp": program.timestamp,
+                "parent_id": program.parent_id,
+                "metrics": program.metrics
+            }, f, indent=2)
+        
         logger.info(f"Saved best program to {code_path} with metrics to {metrics_path}")

openevolve/database.py

@@ -58,6 +58,7 @@ class ProgramDatabase:
     
     The database implements a combination of MAP-Elites algorithm and
     island-based population model to maintain diversity during evolution.
+    It also tracks the absolute best program separately to ensure it's never lost.
     """
 
     def __init__(self, config: DatabaseConfig):
@@ -76,6 +77,9 @@ def __init__(self, config: DatabaseConfig):
         # Archive of elite programs
         self.archive: Set[str] = set()
 
+        # Track the absolute best program separately
+        self.best_program_id: Optional[str] = None
+        
         # Load database from disk if path is provided
         if config.db_path and os.path.exists(config.db_path):
             self.load(config.db_path)
@@ -112,6 +116,9 @@ def add(self, program: Program) -> str:
         # Update archive
         self._update_archive(program)
 
+        # Update the absolute best program tracking
+        self._update_best_program(program)
+        
         # Save to disk if configured
         if self.config.db_path:
             self._save_program(program)
@@ -160,6 +167,10 @@ def get_best_program(self, metric: Optional[str] = None) -> Optional[Program]:
         if not self.programs:
             return None
 
+        # If no specific metric and we have a tracked best program, return it
+        if metric is None and self.best_program_id and self.best_program_id in self.programs:
+            return self.programs[self.best_program_id]
+        
         if metric:
             # Sort by specific metric
             sorted_programs = sorted(
@@ -174,6 +185,13 @@ def get_best_program(self, metric: Optional[str] = None) -> Optional[Program]:
                 key=lambda p: sum(p.metrics.values()) / max(1, len(p.metrics)),
                 reverse=True
             )
+            
+            # Update the best program tracking if we found a better program
+            if sorted_programs and (self.best_program_id is None or 
+                                  sorted_programs[0].id != self.best_program_id):
+                old_id = self.best_program_id
+                self.best_program_id = sorted_programs[0].id
+                logger.info(f"Updated best program tracking: {self.best_program_id} ")
 
         return sorted_programs[0] if sorted_programs else None
 
@@ -236,6 +254,7 @@ def save(self, path: Optional[str] = None) -> None:
             "feature_map": self.feature_map,
             "islands": [list(island) for island in self.islands],
             "archive": list(self.archive),
+            "best_program_id": self.best_program_id,
         }
 
         with open(os.path.join(save_path, "metadata.json"), "w") as f:
@@ -263,6 +282,7 @@ def load(self, path: str) -> None:
             self.feature_map = metadata.get("feature_map", {})
             self.islands = [set(island) for island in metadata.get("islands", [])]
             self.archive = set(metadata.get("archive", []))
+            self.best_program_id = metadata.get("best_program_id")
 
         # Load programs
         programs_dir = os.path.join(path, "programs")
@@ -425,6 +445,39 @@ def _update_archive(self, program: Program) -> None:
         if self._is_better(program, worst_program):
             self.archive.remove(worst_program.id)
             self.archive.add(program.id)
+            
+    def _update_best_program(self, program: Program) -> None:
+        """
+        Update the absolute best program tracking
+        
+        Args:
+            program: Program to consider as the new best
+        """
+        # If we don't have a best program yet, this becomes the best
+        if self.best_program_id is None:
+            self.best_program_id = program.id
+            logger.debug(f"Set initial best program to {program.id}")
+            return
+        
+        # Compare with current best program
+        current_best = self.programs[self.best_program_id]
+        
+        # Update if the new program is better
+        if self._is_better(program, current_best):
+            old_id = self.best_program_id
+            self.best_program_id = program.id
+            logger.info(f"New best program {program.id} replaces {old_id}")
+            
+            # Log improvement in metrics
+            if program.metrics and current_best.metrics:
+                improvements = []
+                for metric, value in program.metrics.items():
+                    if metric in current_best.metrics:
+                        diff = value - current_best.metrics[metric]
+                        improvements.append(f"{metric}: {diff:+.4f}")
+                
+                if improvements:
+                    logger.info(f"Metric improvements: {', '.join(improvements)}")
 
     def _sample_parent(self) -> Program:
         """
@@ -466,13 +519,21 @@ def _sample_inspirations(
         """
         inspirations = []
 
+        # Always include the absolute best program if available and different from parent
+        if self.best_program_id is not None and self.best_program_id != parent.id:
+            best_program = self.programs[self.best_program_id]
+            inspirations.append(best_program)
+            logger.debug(f"Including best program {self.best_program_id} in inspirations")
+        
         # Add top programs as inspirations
         top_n = max(1, int(n * self.config.elite_selection_ratio))
         top_programs = self.get_top_programs(n=top_n)
-        inspirations.extend(top_programs)
+        for program in top_programs:
+            if program.id not in [p.id for p in inspirations] and program.id != parent.id:
+                inspirations.append(program)
 
         # Add diverse programs
-        if len(self.programs) > n:
+        if len(self.programs) > n and len(inspirations) < n:
             # Sample from different feature cells
             feature_coords = self._calculate_feature_coords(parent)