openevolve-fixed/examples/algotune/README.md

OpenEvolve AlgoTune Optimization Report

Executive Summary

This report documents a comprehensive optimization journey using OpenEvolve on the AlgoTune benchmark suite. Through systematic experimentation with model configurations, prompt engineering, and evolutionary parameters, we achieved significant performance improvements across 8 algorithmic tasks.

Final Results:

• Best AlgoTune Score: 1.984x (harmonic mean across 8 successful tasks)
• Major Breakthroughs: JAX optimization discovery (321x speedup), FFT convolution (256x), parameter optimization (3.2x)
• Total Evolution Time: ~200 minutes for full benchmark

The Optimization Journey

Phase 1: Initial Baseline (Generic Hints)

• AlgoTune Score: 1.381x
• Used basic library mentions without implementation details
• Key limitation: Failed to discover complex optimizations like JAX JIT compilation

Phase 2: Manual Optimization Discovery

Through manual analysis, we discovered several key optimizations:

• JAX JIT compilation for polynomial_real (362x theoretical speedup)
• FFT convolution for signal processing tasks
• Parameter optimization (dtype, interpolation order)
• Hardware-specific optimizations for Apple M4

Phase 3: Specific Hints Implementation

• AlgoTune Score: 1.886x
• Added detailed implementation hints based on manual discoveries
• Achieved best theoretical performance but raised "overfitting" concerns

Phase 4: The Balance - Generic Hints with Smart Configuration

• Final AlgoTune Score: 1.984x (across successful tasks)
• Balanced approach: Library guidance without implementation details
• Optimized configurations for different optimization types

Task-by-Task Optimization Discoveries

1. polynomial_real: JAX JIT Compilation Discovery

Result: 321.01x speedup ✨

• Optimization: JAX JIT compilation with @jax.jit
• Key Requirements Discovered:
  • Functions must be defined outside classes for JIT compatibility
  • strip_zeros=False parameter crucial for JIT compilation
  • jnp.roots() instead of np.roots()
• Configuration Needed: Extended timeout (600s) for compilation, sequential evaluation
• Code Pattern:

@jax.jit
def _solve_roots_jax(coefficients):
    real_roots = jnp.real(jnp.roots(coefficients, strip_zeros=False))
    return jnp.sort(real_roots)[::-1]

2. convolve2d_full_fill: FFT Algorithm Discovery

Result: 256.15x speedup

• Optimization: scipy.signal.fftconvolve instead of direct convolution
• Algorithm Change: O(N⁴) → O(N²log N) complexity
• Additional Optimization: float32 dtype for memory efficiency
• Discovery: This was consistently found across all runs (generic hints sufficient)

3. affine_transform_2d: Parameter Optimization Breakthrough

Result: 3.22x speedup

• Optimization: Combined order=0 (nearest neighbor) + float32
• Key Insight: Lower interpolation orders provide dramatic speedups
• Enhancement Strategy: Specific parameter guidance in hints worked perfectly
• Previous Generic Result: Only 1.004x (failed to discover optimization)

4. fft_cmplx_scipy_fftpack: Algorithm Enhancement

Result: 2.20x speedup

• Optimization: Enhanced FFT implementation patterns
• Improvement: 77% better than generic hints (1.24x → 2.20x)

5. eigenvectors_complex: Stable Performance

Result: 1.48x speedup

• Optimization: Consistent eigenvalue computation improvements
• Note: Similar performance across all configurations

6. fft_convolution: Incremental Gains

Result: 1.38x speedup

• Optimization: FFT-based convolution optimizations
• Improvement: 24% better than baseline

7. lu_factorization: Consistent Optimization

Result: 1.19x speedup

• Optimization: LAPACK-based factorization improvements
• Note: Maintained consistent performance across runs

8. psd_cone_projection: Eigenvalue Optimization

Result: 1.94x speedup

• Optimization: Optimized positive semidefinite projection algorithms

Critical Success Factors

1. Model Configuration

Ensemble Strategy: Gemini Flash 2.5 (80%) + Pro (20%)

• Flash Model: Fast iterations, good for exploration
• Pro Model: Enhanced reasoning for complex optimizations
• Balance: Cost-effective with maintained quality

2. Context and Sampling Configuration

llm:
  max_tokens: 128000  # Large context for rich learning
  
prompt:
  num_top_programs: 5      # Quality examples
  num_diverse_programs: 5  # Exploration diversity

• Large Context (128k tokens): Essential for complex optimization discovery
• Balanced Sampling: 5 top + 5 diverse programs optimal for learning

3. Strategic Hint Engineering

The Golden Rule: Libraries YES, Implementation Details NO

✅ Effective Hints:

• **JAX** - JIT compilation for numerical computations that can provide 100x+ speedups
  JAX offers drop-in NumPy replacements (jax.numpy) that work with JIT compilation
  Works best with pure functions (no side effects) and may require code restructuring

• Lower-order interpolation: Try order=0,1,2,3 - lower orders can provide dramatic speedups

❌ Overly Specific (Avoided):

# Too specific - gives away solution
• Use jnp.roots(coefficients, strip_zeros=False) 
• Functions should be defined outside classes for JIT compatibility

4. Task-Specific Configuration Tuning

For JAX Compilation Tasks:

evaluator:
  timeout: 600  # Extended for compilation
  parallel_evaluations: 1  # Avoid conflicts

For Standard Tasks:

evaluator:
  timeout: 200
  parallel_evaluations: 4  # Faster throughput

Key Learnings

1. Optimization Type Categories

Different optimizations require different approaches:

Library Optimizations (JAX, Numba):

• Need architectural guidance (functions vs methods)
• Require specific parameter hints (strip_zeros=False)
• Long compilation times need extended timeouts

Algorithm Optimizations (FFT):

• Discoverable with generic hints about complexity
• Benefit from mentioning alternative approaches
• Generally faster to discover and implement

Parameter Optimizations (dtype, order):

• Need directional guidance ("try lower orders")
• Require specific value ranges
• Balance between exploration and guidance

2. Configuration Impact Analysis

Critical Discoveries:

• Context Size: 128k tokens significantly improved optimization discovery
• Model Ensemble: Diversity crucial for complex reasoning tasks
• Timeout Tuning: Different tasks need different evaluation timeouts
• Sequential vs Parallel: JAX requires sequential evaluation to avoid conflicts

3. The Hint Specificity Spectrum

Too Generic: System cannot discover complex optimizations

"Try different approaches" → Failed to find JAX

Perfect Balance: Library guidance with structural hints

"JAX JIT compilation - works best with pure functions" → Success

Too Specific: System doesn't learn, just copies

"Use jnp.roots(coeffs, strip_zeros=False)" → No learning

Configuration Best Practices

1. Model Selection Strategy

llm:
  models:
    - name: "google/gemini-2.5-flash"
      weight: 0.8  # Primary workhorse
    - name: "google/gemini-2.5-pro" 
      weight: 0.2  # Enhanced reasoning

2. Optimal Sampling Configuration

prompt:
  num_top_programs: 5      # Quality over quantity
  num_diverse_programs: 5  # Sufficient exploration
  include_artifacts: true  # Learning from failures

3. Task-Specific Timeout Strategy

• Standard tasks: 200s evaluator timeout
• Compilation tasks (JAX/Numba): 600s+ evaluator timeout
• Complex algorithms: Consider extended iteration timeouts

4. Effective Hint Structure

PERFORMANCE OPTIMIZATION OPPORTUNITIES:
• **[Library]** - High-level capability description
  Technical requirements without implementation details
  
PROBLEM-SPECIFIC OPTIMIZATION HINTS:
• Parameter exploration guidance
• Algorithmic approach suggestions
• Performance vs accuracy tradeoffs

Technical Implementation Details

JAX Optimization Requirements

The most complex optimization discovered required specific architectural patterns:

1. Function Extraction: JIT functions must be defined outside classes
2. Parameter Specification: strip_zeros=False for deterministic shapes
3. Data Flow: Pure functional programming patterns
4. Compilation Management: Extended timeouts and sequential evaluation

Evolution Pattern Analysis

Successful optimization discovery followed this pattern:

1. Initial Failures: Programs fail with specific error messages
2. Error Learning: System incorporates error feedback into next generation
3. Breakthrough: Correct pattern discovered, dramatic speedup achieved
4. Refinement: Further iterations optimize the successful pattern

Conclusion

This comprehensive optimization journey demonstrates OpenEvolve's remarkable capability to discover complex algorithmic optimizations when provided with appropriate guidance and configuration. Key insights:

1. Human-AI Collaboration: The most effective approach combines human domain knowledge (library suggestions) with AI exploration (implementation discovery)

2. Configuration Criticality: Success heavily depends on properly tuned configurations for context size, model ensemble, sampling strategy, and task-specific parameters

3. Hint Engineering Art: The balance between guidance and exploration is crucial - too little guidance fails to discover optimizations, too much guidance prevents learning

4. Scalable Discovery: OpenEvolve can consistently discover optimizations across diverse algorithmic domains when properly configured

5. Future Potential: With continued refinement of hint strategies and configuration optimization, even more complex algorithmic breakthroughs are possible

Final AlgoTune Score: 1.984x represents not just performance improvement, but a validated methodology for AI-assisted algorithmic optimization that can be applied to broader domains beyond this benchmark.

---

This report represents the culmination of extensive experimentation with OpenEvolve's evolutionary code optimization capabilities on the AlgoTune benchmark suite, providing a roadmap for future AI-assisted algorithmic discovery.