Merge branch 'main' into feat/MLX-kernel-optimization

Author: codelion

examples/function_minimization/evaluator.py

@@ -5,8 +5,9 @@
 import importlib.util
 import numpy as np
 import time
-import multiprocessing
+import concurrent.futures
 import traceback
+import signal
 
 
 def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=5):
@@ -22,31 +23,13 @@ def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=5):
     Returns:
         Result of the function or raises TimeoutError
     """
-
-    def wrapper(queue, func, args, kwargs):
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(func, *args, **kwargs)
         try:
-            result = func(*args, **kwargs)
-            queue.put(("success", result))
-        except Exception as e:
-            queue.put(("error", e))
-
-    queue = multiprocessing.Queue()
-    process = multiprocessing.Process(target=wrapper, args=(queue, func, args, kwargs))
-    process.start()
-    process.join(timeout=timeout_seconds)
-
-    if process.is_alive():
-        process.terminate()
-        process.join()
-        raise TimeoutError(f"Function timed out after {timeout_seconds} seconds")
-
-    if queue.empty():
-        raise TimeoutError("Function ended without returning a result")
-
-    status, result = queue.get()
-    if status == "error":
-        raise result
-    return result
+            result = future.result(timeout=timeout_seconds)
+            return result
+        except concurrent.futures.TimeoutError:
+            raise TimeoutError(f"Function timed out after {timeout_seconds} seconds")
 
 
 def safe_float(value):
@@ -107,15 +90,27 @@ def evaluate(program_path):
                 # Run with timeout
                 result = run_with_timeout(program.run_search, timeout_seconds=5)
 
-                # Check if we got a tuple of 3 values
-                if not isinstance(result, tuple) or len(result) != 3:
+                # Handle different result formats
+                if isinstance(result, tuple):
+                    if len(result) == 3:
+                        x, y, value = result
+                    elif len(result) == 2:
+                        # Assume it's (x, y) and calculate value
+                        x, y = result
+                        # Calculate the function value since it wasn't returned
+                        value = np.sin(x) * np.cos(y) + np.sin(x * y) + (x**2 + y**2) / 20
+                        print(f"Trial {trial}: Got 2 values, calculated function value: {value}")
+                    else:
+                        print(
+                            f"Trial {trial}: Invalid result format, expected tuple of 2 or 3 values but got {len(result)}"
+                        )
+                        continue
+                else:
                     print(
-                        f"Trial {trial}: Invalid result format, expected tuple of 3 values but got {type(result)}"
+                        f"Trial {trial}: Invalid result format, expected tuple but got {type(result)}"
                     )
                     continue
 
-                x, y, value = result
-
                 end_time = time.time()
 
                 # Ensure all values are float
@@ -264,15 +259,25 @@ def evaluate_stage1(program_path):
             # Run a single trial with timeout
             result = run_with_timeout(program.run_search, timeout_seconds=5)
 
-            # Check if we got a tuple of 3 values
-            if not isinstance(result, tuple) or len(result) != 3:
-                print(
-                    f"Stage 1: Invalid result format, expected tuple of 3 values but got {type(result)}"
-                )
+            # Handle different result formats
+            if isinstance(result, tuple):
+                if len(result) == 3:
+                    x, y, value = result
+                elif len(result) == 2:
+                    # Assume it's (x, y) and calculate value
+                    x, y = result
+                    # Calculate the function value since it wasn't returned
+                    value = np.sin(x) * np.cos(y) + np.sin(x * y) + (x**2 + y**2) / 20
+                    print(f"Stage 1: Got 2 values, calculated function value: {value}")
+                else:
+                    print(
+                        f"Stage 1: Invalid result format, expected tuple of 2 or 3 values but got {len(result)}"
+                    )
+                    return {"runs_successfully": 0.0, "error": "Invalid result format"}
+            else:
+                print(f"Stage 1: Invalid result format, expected tuple but got {type(result)}")
                 return {"runs_successfully": 0.0, "error": "Invalid result format"}
 
-            x, y, value = result
-
             # Ensure all values are float
             x = safe_float(x)
             y = safe_float(y)

examples/function_minimization/requirements.txt

@@ -0,0 +1 @@
+scipy

openevolve/controller.py

@@ -24,6 +24,10 @@
     parse_evolve_blocks,
     parse_full_rewrite,
 )
+from openevolve.utils.format_utils import (
+    format_metrics_safe,
+    format_improvement_safe,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -332,7 +336,7 @@ async def run(
                     logger.info(
                         f"🌟 New best solution found at iteration {i+1}: {child_program.id}"
                     )
-                    logger.info(f"Metrics: {_format_metrics(child_program.metrics)}")
+                    logger.info(f"Metrics: {format_metrics_safe(child_program.metrics)}")
 
                 # Save checkpoint
                 if (i + 1) % self.config.checkpoint_interval == 0:
@@ -396,7 +400,7 @@ async def run(
         if best_program:
             logger.info(
                 f"Evolution complete. Best program has metrics: "
-                f"{_format_metrics(best_program.metrics)}"
+                f"{format_metrics_safe(best_program.metrics)}"
             )
 
             # Save the best program (using our tracked best program)
@@ -424,30 +428,13 @@ def _log_iteration(
             child: Child program
             elapsed_time: Elapsed time in seconds
         """
-        # Calculate improvement
-        improvement = {}
-        for metric, value in child.metrics.items():
-            if metric in parent.metrics:
-                # Only calculate diff for numeric values
-                if (
-                    isinstance(value, (int, float))
-                    and isinstance(parent.metrics[metric], (int, float))
-                    and not isinstance(value, bool)
-                    and not isinstance(parent.metrics[metric], bool)
-                ):
-                    try:
-                        diff = value - parent.metrics[metric]
-                        improvement[metric] = diff
-                    except (TypeError, ValueError):
-                        # Skip non-numeric metrics
-                        pass
-
-        improvement_str = _format_improvement(improvement)
+        # Calculate improvement using safe formatting
+        improvement_str = format_improvement_safe(parent.metrics, child.metrics)
 
         logger.info(
             f"Iteration {iteration+1}: Child {child.id} from parent {parent.id} "
             f"in {elapsed_time:.2f}s. Metrics: "
-            f"{_format_metrics(child.metrics)} "
+            f"{format_metrics_safe(child.metrics)} "
             f"(Δ: {improvement_str})"
         )
 
@@ -503,7 +490,7 @@ def _save_checkpoint(self, iteration: int) -> None:
 
             logger.info(
                 f"Saved best program at checkpoint {iteration} with metrics: "
-                f"{_format_metrics(best_program.metrics)}"
+                f"{format_metrics_safe(best_program.metrics)}"
             )
 
         logger.info(f"Saved checkpoint at iteration {iteration} to {checkpoint_path}")

openevolve/database.py

@@ -15,6 +15,7 @@
 
 from openevolve.config import DatabaseConfig
 from openevolve.utils.code_utils import calculate_edit_distance
+from openevolve.utils.metrics_utils import safe_numeric_average
 
 logger = logging.getLogger(__name__)
 
@@ -244,7 +245,7 @@ def get_best_program(self, metric: Optional[str] = None) -> Optional[Program]:
             # Sort by average of all numeric metrics as fallback
             sorted_programs = sorted(
                 self.programs.values(),
-                key=lambda p: _safe_avg_metrics(p.metrics),
+                key=lambda p: safe_numeric_average(p.metrics),
                 reverse=True,
             )
             if sorted_programs:
@@ -298,7 +299,7 @@ def get_top_programs(self, n: int = 10, metric: Optional[str] = None) -> List[Pr
             # Sort by average of all numeric metrics
             sorted_programs = sorted(
                 self.programs.values(),
-                key=lambda p: _safe_avg_metrics(p.metrics),
+                key=lambda p: safe_numeric_average(p.metrics),
                 reverse=True,
             )
 
@@ -543,7 +544,7 @@ def _calculate_feature_coords(self, program: Program) -> List[int]:
                 if not program.metrics:
                     bin_idx = 0
                 else:
-                    avg_score = _safe_avg_metrics(program.metrics)
+                    avg_score = safe_numeric_average(program.metrics)
                     bin_idx = min(int(avg_score * self.feature_bins), self.feature_bins - 1)
                 coords.append(bin_idx)
             elif dim in program.metrics:
@@ -595,8 +596,8 @@ def _is_better(self, program1: Program, program2: Program) -> bool:
             return program1.metrics["combined_score"] > program2.metrics["combined_score"]
 
         # Fallback to average of all numeric metrics
-        avg1 = _safe_avg_metrics(program1.metrics)
-        avg2 = _safe_avg_metrics(program2.metrics)
+        avg1 = safe_numeric_average(program1.metrics)
+        avg2 = safe_numeric_average(program2.metrics)
 
         return avg1 > avg2
 
@@ -614,7 +615,7 @@ def _update_archive(self, program: Program) -> None:
 
         # Otherwise, find worst program in archive
         archive_programs = [self.programs[pid] for pid in self.archive]
-        worst_program = min(archive_programs, key=lambda p: _safe_avg_metrics(p.metrics))
+        worst_program = min(archive_programs, key=lambda p: safe_numeric_average(p.metrics))
 
         # Replace if new program is better
         if self._is_better(program, worst_program):
@@ -821,7 +822,7 @@ def _enforce_population_limit(self) -> None:
         # Sort by average metric (worst first)
         sorted_programs = sorted(
             all_programs,
-            key=lambda p: sum(p.metrics.values()) / max(1, len(p.metrics)) if p.metrics else 0.0,
+            key=lambda p: safe_numeric_average(p.metrics),
         )
 
         # Remove worst programs, but never remove the best program
@@ -916,9 +917,7 @@ def migrate_programs(self) -> None:
 
             # Sort by fitness (using combined_score or average metrics)
             island_programs.sort(
-                key=lambda p: p.metrics.get(
-                    "combined_score", sum(p.metrics.values()) / max(1, len(p.metrics))
-                ),
+                key=lambda p: p.metrics.get("combined_score", safe_numeric_average(p.metrics)),
                 reverse=True,
             )
 
@@ -963,9 +962,7 @@ def get_island_stats(self) -> List[dict]:
 
             if island_programs:
                 scores = [
-                    p.metrics.get(
-                        "combined_score", sum(p.metrics.values()) / max(1, len(p.metrics))
-                    )
+                    p.metrics.get("combined_score", safe_numeric_average(p.metrics))
                     for p in island_programs
                 ]
 

openevolve/evaluator.py

@@ -18,6 +18,7 @@
 from openevolve.config import EvaluatorConfig
 from openevolve.llm.ensemble import LLMEnsemble
 from openevolve.utils.async_utils import TaskPool, run_in_executor
+from openevolve.utils.format_utils import format_metrics_safe
 
 logger = logging.getLogger(__name__)
 
@@ -123,24 +124,9 @@ async def evaluate_program(
                         metrics[f"llm_{name}"] = value * self.config.llm_feedback_weight
 
                 elapsed = time.time() - start_time
-
-                # Safe formatting of metrics to prevent formatting errors
-                def safe_format_metric_value(value):
-                    """Safely format a metric value for logging."""
-                    try:
-                        if isinstance(value, (int, float)) and not isinstance(value, bool):
-                            import math
-
-                            if math.isnan(value) or math.isinf(value):
-                                return str(value)
-                            return f"{value:.4f}"
-                        else:
-                            return str(value)
-                    except (ValueError, TypeError):
-                        return str(value)
-
-                metrics_str = ", ".join(
-                    f"{name}={safe_format_metric_value(value)}" for name, value in metrics.items()
+                logger.info(
+                    f"Evaluated program{program_id_str} in {elapsed:.2f}s: "
+                    f"{format_metrics_safe(metrics)}"
                 )
 
                 logger.info(f"Evaluated program{program_id_str} in {elapsed:.2f}s: {metrics_str}")