f

Author: codelion

examples/function_minimization/config.yaml

@@ -0,0 +1,41 @@
+# Configuration for function minimization example
+max_iterations: 100
+checkpoint_interval: 10
+log_level: "INFO"
+
+# LLM configuration
+llm:
+  primary_model: "gemini-2.0-flash-lite"
+  primary_model_weight: 0.8
+  secondary_model: "gemini-2.0-flash"
+  secondary_model_weight: 0.2
+  api_base: "https://generativelanguage.googleapis.com/v1beta/openai/"
+  temperature: 0.7
+  top_p: 0.95
+  max_tokens: 4096
+
+# Prompt configuration
+prompt:
+  system_message: "You are an expert programmer specializing in optimization algorithms. Your task is to improve a function minimization algorithm to find the global minimum of a complex function with many local minima. The function is f(x, y) = sin(x) * cos(y) + sin(x*y) + (x^2 + y^2)/20. Focus on improving the search_algorithm function to reliably find the global minimum, escaping local minima that might trap simple algorithms."
+  num_top_programs: 3
+  use_template_stochasticity: true
+
+# Database configuration
+database:
+  population_size: 50
+  archive_size: 20
+  num_islands: 3
+  elite_selection_ratio: 0.2
+  exploitation_ratio: 0.7
+
+# Evaluator configuration
+evaluator:
+  timeout: 60
+  cascade_evaluation: true
+  cascade_thresholds: [0.5, 0.75]
+  parallel_evaluations: 4
+  use_llm_feedback: false
+
+# Evolution settings
+diff_based_evolution: true
+allow_full_rewrites: false

examples/function_minimization/evaluator.py

@@ -0,0 +1,93 @@
+"""
+Evaluator for the function minimization example
+"""
+import importlib.util
+import numpy as np
+import time
+
+def evaluate(program_path):
+    """
+    Evaluate the program by running it multiple times and checking how close
+    it gets to the known global minimum.
+    
+    Args:
+        program_path: Path to the program file
+        
+    Returns:
+        Dictionary of metrics
+    """
+    # Known global minimum (approximate)
+    GLOBAL_MIN_X = -1.76
+    GLOBAL_MIN_Y = -1.03
+    GLOBAL_MIN_VALUE = -2.104
+    
+    # Load the program
+    spec = importlib.util.spec_from_file_location("program", program_path)
+    program = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(program)
+    
+    # Run multiple trials
+    num_trials = 10
+    values = []
+    distances = []
+    times = []
+    
+    for _ in range(num_trials):
+        start_time = time.time()
+        x, y, value = program.run_search()
+        end_time = time.time()
+        
+        # Calculate metrics
+        distance_to_global = np.sqrt((x - GLOBAL_MIN_X)**2 + (y - GLOBAL_MIN_Y)**2)
+        value_difference = abs(value - GLOBAL_MIN_VALUE)
+        
+        values.append(value)
+        distances.append(distance_to_global)
+        times.append(end_time - start_time)
+    
+    # Calculate metrics
+    avg_value = np.mean(values)
+    avg_distance = np.mean(distances)
+    avg_time = np.mean(times)
+    
+    # Convert to scores (higher is better)
+    value_score = 1.0 / (1.0 + abs(avg_value - GLOBAL_MIN_VALUE))  # Normalize and invert
+    distance_score = 1.0 / (1.0 + avg_distance)
+    speed_score = 1.0 / avg_time
+    
+    # Normalize speed score (so it doesn't dominate)
+    speed_score = min(speed_score, 10.0) / 10.0
+    
+    return {
+        "value_score": value_score,
+        "distance_score": distance_score,
+        "speed_score": speed_score,
+        "combined_score": 0.6 * value_score + 0.3 * distance_score + 0.1 * speed_score
+    }
+
+# Stage-based evaluation for cascade evaluation
+def evaluate_stage1(program_path):
+    """First stage evaluation with fewer trials"""
+    # Quick check to see if the program runs without errors
+    try:
+        # Load the program
+        spec = importlib.util.spec_from_file_location("program", program_path)
+        program = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(program)
+        
+        # Run a single trial
+        x, y, value = program.run_search()
+        
+        # Basic metrics
+        return {
+            "runs_successfully": 1.0,
+            "value": float(value)
+        }
+    except Exception as e:
+        print(f"Stage 1 evaluation failed: {e}")
+        return {"runs_successfully": 0.0}
+
+def evaluate_stage2(program_path):
+    """Second stage evaluation with more thorough testing"""
+    # Full evaluation as in the main evaluate function
+    return evaluate(program_path)

examples/function_minimization/initial_program.py

@@ -0,0 +1,44 @@
+# EVOLVE-BLOCK-START
+"""Function minimization example for OpenEvolve"""
+import numpy as np
+
+def search_algorithm(iterations=1000, bounds=(-5, 5)):
+    """
+    A simple random search algorithm that often gets stuck in local minima.
+    
+    Args:
+        iterations: Number of iterations to run
+        bounds: Bounds for the search space (min, max)
+        
+    Returns:
+        Tuple of (best_x, best_y, best_value)
+    """
+    best_x, best_y = 0, 0
+    best_value = evaluate_function(best_x, best_y)
+    
+    for _ in range(iterations):
+        # Simple random search
+        x = np.random.uniform(bounds[0], bounds[1])
+        y = np.random.uniform(bounds[0], bounds[1])
+        value = evaluate_function(x, y)
+        
+        if value < best_value:
+            best_value = value
+            best_x, best_y = x, y
+    
+    return best_x, best_y, best_value
+
+def evaluate_function(x, y):
+    """The complex function we're trying to minimize"""
+    return np.sin(x) * np.cos(y) + np.sin(x*y) + (x**2 + y**2)/20
+# EVOLVE-BLOCK-END
+
+# This part remains fixed (not evolved)
+def run_search():
+    x, y, value = search_algorithm()
+    return x, y, value
+
+if __name__ == "__main__":
+    x, y, value = run_search()
+    print(f"Found minimum at ({x}, {y}) with value {value}")
+    # The global minimum is around (-1.76, -1.03) with value -2.104