openevolve 0.0.1__py3-none-any.whl

openevolve/__init__.py

@@ -0,0 +1,9 @@
+"""
+OpenEvolve: An open-source implementation of AlphaEvolve
+"""
+
+__version__ = "0.1.0"
+
+from openevolve.controller import OpenEvolve
+
+__all__ = ["OpenEvolve"]

openevolve/cli.py

@@ -0,0 +1,179 @@
+"""
+Command-line interface for OpenEvolve
+"""
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+from typing import Dict, List, Optional
+
+from openevolve import OpenEvolve
+from openevolve.config import Config, load_config
+
+logger = logging.getLogger(__name__)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments"""
+    parser = argparse.ArgumentParser(description="OpenEvolve - Evolutionary coding agent")
+
+    parser.add_argument("initial_program", help="Path to the initial program file")
+
+    parser.add_argument(
+        "evaluation_file", help="Path to the evaluation file containing an 'evaluate' function"
+    )
+
+    parser.add_argument("--config", "-c", help="Path to configuration file (YAML)", default=None)
+
+    parser.add_argument("--output", "-o", help="Output directory for results", default=None)
+
+    parser.add_argument(
+        "--iterations", "-i", help="Maximum number of iterations", type=int, default=None
+    )
+
+    parser.add_argument(
+        "--target-score", "-t", help="Target score to reach", type=float, default=None
+    )
+
+    parser.add_argument(
+        "--log-level",
+        "-l",
+        help="Logging level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+    )
+
+    parser.add_argument(
+        "--checkpoint",
+        help="Path to checkpoint directory to resume from (e.g., openevolve_output/checkpoints/checkpoint_50)",
+        default=None,
+    )
+
+    parser.add_argument("--api-base", help="Base URL for the LLM API", default=None)
+
+    parser.add_argument("--primary-model", help="Primary LLM model name", default=None)
+
+    parser.add_argument("--secondary-model", help="Secondary LLM model name", default=None)
+
+    return parser.parse_args()
+
+
+async def main_async() -> int:
+    """
+    Main asynchronous entry point
+
+    Returns:
+        Exit code
+    """
+    args = parse_args()
+
+    # Check if files exist
+    if not os.path.exists(args.initial_program):
+        print(f"Error: Initial program file '{args.initial_program}' not found")
+        return 1
+
+    if not os.path.exists(args.evaluation_file):
+        print(f"Error: Evaluation file '{args.evaluation_file}' not found")
+        return 1
+
+    # Create config object with command-line overrides
+    config = None
+    if args.api_base or args.primary_model or args.secondary_model:
+        # Load base config from file or defaults
+        config = load_config(args.config)
+
+        # Apply command-line overrides
+        if args.api_base:
+            config.llm.api_base = args.api_base
+            print(f"Using API base: {config.llm.api_base}")
+
+        if args.primary_model:
+            config.llm.primary_model = args.primary_model
+            print(f"Using primary model: {config.llm.primary_model}")
+
+        if args.secondary_model:
+            config.llm.secondary_model = args.secondary_model
+            print(f"Using secondary model: {config.llm.secondary_model}")
+
+    # Initialize OpenEvolve
+    try:
+        openevolve = OpenEvolve(
+            initial_program_path=args.initial_program,
+            evaluation_file=args.evaluation_file,
+            config=config,
+            config_path=args.config if config is None else None,
+            output_dir=args.output,
+        )
+
+        # Load from checkpoint if specified
+        if args.checkpoint:
+            if not os.path.exists(args.checkpoint):
+                print(f"Error: Checkpoint directory '{args.checkpoint}' not found")
+                return 1
+            print(f"Loading checkpoint from {args.checkpoint}")
+            openevolve.database.load(args.checkpoint)
+            print(
+                f"Checkpoint loaded successfully (iteration {openevolve.database.last_iteration})"
+            )
+
+        # Override log level if specified
+        if args.log_level:
+            logging.getLogger().setLevel(getattr(logging, args.log_level))
+
+        # Run evolution
+        best_program = await openevolve.run(
+            iterations=args.iterations,
+            target_score=args.target_score,
+        )
+
+        # Get the checkpoint path
+        checkpoint_dir = os.path.join(openevolve.output_dir, "checkpoints")
+        latest_checkpoint = None
+        if os.path.exists(checkpoint_dir):
+            checkpoints = [
+                os.path.join(checkpoint_dir, d)
+                for d in os.listdir(checkpoint_dir)
+                if os.path.isdir(os.path.join(checkpoint_dir, d))
+            ]
+            if checkpoints:
+                latest_checkpoint = sorted(
+                    checkpoints, key=lambda x: int(x.split("_")[-1]) if "_" in x else 0
+                )[-1]
+
+        print(f"\nEvolution complete!")
+        print(f"Best program metrics:")
+        for name, value in best_program.metrics.items():
+            # Handle mixed types: format numbers as floats, others as strings
+            if isinstance(value, (int, float)):
+                print(f"  {name}: {value:.4f}")
+            else:
+                print(f"  {name}: {value}")
+
+        if latest_checkpoint:
+            print(f"\nLatest checkpoint saved at: {latest_checkpoint}")
+            print(f"To resume, use: --checkpoint {latest_checkpoint}")
+
+        return 0
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+
+def main() -> int:
+    """
+    Main entry point
+
+    Returns:
+        Exit code
+    """
+    return asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    sys.exit(main())

openevolve/config.py

@@ -0,0 +1,354 @@
+"""
+Configuration handling for OpenEvolve
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+
+@dataclass
+class LLMModelConfig:
+    """Configuration for a single LLM model"""
+
+    # API configuration
+    api_base: str = None
+    api_key: Optional[str] = None
+    name: str = None
+
+    # Weight for model in ensemble
+    weight: float = 1.0
+
+    # Generation parameters
+    system_message: Optional[str] = None
+    temperature: float = None
+    top_p: float = None
+    max_tokens: int = None
+
+    # Request parameters
+    timeout: int = None
+    retries: int = None
+    retry_delay: int = None
+
+
+@dataclass
+class LLMConfig(LLMModelConfig):
+    """Configuration for LLM models"""
+
+    # API configuration
+    api_base: str = "https://api.openai.com/v1"
+
+    # Generation parameters
+    system_message: Optional[str] = "system_message"
+    temperature: float = 0.7
+    top_p: float = 0.95
+    max_tokens: int = 4096
+
+    # Request parameters
+    timeout: int = 60
+    retries: int = 3
+    retry_delay: int = 5
+
+    # n-model configuration for evolution LLM ensemble
+    models: List[LLMModelConfig] = field(default_factory=lambda: [LLMModelConfig()])
+
+    # n-model configuration for evaluator LLM ensemble
+    evaluator_models: List[LLMModelConfig] = field(default_factory=lambda: [])
+
+    # Backwardes compatibility with primary_model(_weight) options
+    primary_model: str = None
+    primary_model_weight: float = None
+    secondary_model: str = None
+    secondary_model_weight: float = None
+
+    def __post_init__(self):
+        """Post-initialization to set up model configurations"""
+        # Handle backward compatibility for primary_model(_weight) and secondary_model(_weight).
+        if (self.primary_model or self.primary_model_weight) and len(self.models) < 1:
+            # Ensure we have a primary model
+            self.models.append(LLMModelConfig())
+        if self.primary_model:
+            self.models[0].name = self.primary_model
+        if self.primary_model_weight:
+            self.models[0].weight = self.primary_model_weight
+
+        if (self.secondary_model or self.secondary_model_weight) and len(self.models) < 2:
+            # Ensure we have a second model
+            self.models.append(LLMModelConfig())
+        if self.secondary_model:
+            self.models[1].name = self.secondary_model
+        if self.secondary_model_weight:
+            self.models[1].weight = self.secondary_model_weight
+
+        # If no evaluator models are defined, use the same models as for evolution
+        if not self.evaluator_models or len(self.evaluator_models) < 1:
+            self.evaluator_models = self.models.copy()
+
+        # Update models with shared configuration values
+        shared_config = {
+            "api_base": self.api_base,
+            "api_key": self.api_key,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "max_tokens": self.max_tokens,
+            "timeout": self.timeout,
+            "retries": self.retries,
+            "retry_delay": self.retry_delay,
+        }
+        self.update_model_params(shared_config)
+
+    def update_model_params(self, args: Dict[str, Any], overwrite: bool = False) -> None:
+        """Update model parameters for all models"""
+        for model in self.models + self.evaluator_models:
+            for key, value in args.items():
+                if overwrite or getattr(model, key, None) is None:
+                    setattr(model, key, value)
+
+
+@dataclass
+class PromptConfig:
+    """Configuration for prompt generation"""
+
+    template_dir: Optional[str] = None
+    system_message: str = "system_message"
+    evaluator_system_message: str = "evaluator_system_message"
+
+    # Number of examples to include in the prompt
+    num_top_programs: int = 3
+    num_diverse_programs: int = 2
+
+    # Template stochasticity
+    use_template_stochasticity: bool = True
+    template_variations: Dict[str, List[str]] = field(default_factory=dict)
+
+    # Meta-prompting
+    use_meta_prompting: bool = False
+    meta_prompt_weight: float = 0.1
+
+    # Artifact rendering
+    include_artifacts: bool = True
+    max_artifact_bytes: int = 20 * 1024  # 20KB in prompt
+    artifact_security_filter: bool = True
+
+
+@dataclass
+class DatabaseConfig:
+    """Configuration for the program database"""
+
+    # General settings
+    db_path: Optional[str] = None  # Path to store database on disk
+    in_memory: bool = True
+
+    # Evolutionary parameters
+    population_size: int = 1000
+    archive_size: int = 100
+    num_islands: int = 5
+
+    # Selection parameters
+    elite_selection_ratio: float = 0.1
+    exploration_ratio: float = 0.2
+    exploitation_ratio: float = 0.7
+    diversity_metric: str = "edit_distance"  # Options: "edit_distance", "feature_based"
+
+    # Feature map dimensions for MAP-Elites
+    feature_dimensions: List[str] = field(default_factory=lambda: ["score", "complexity"])
+    feature_bins: int = 10
+
+    # Migration parameters for island-based evolution
+    migration_interval: int = 50  # Migrate every N generations
+    migration_rate: float = 0.1  # Fraction of population to migrate
+
+    # Random seed for reproducible sampling
+    random_seed: Optional[int] = None
+
+    # Artifact storage
+    artifacts_base_path: Optional[str] = None  # Defaults to db_path/artifacts
+    artifact_size_threshold: int = 32 * 1024  # 32KB threshold
+    cleanup_old_artifacts: bool = True
+    artifact_retention_days: int = 30
+
+
+@dataclass
+class EvaluatorConfig:
+    """Configuration for program evaluation"""
+
+    # General settings
+    timeout: int = 300  # Maximum evaluation time in seconds
+    max_retries: int = 3
+
+    # Resource limits for evaluation
+    memory_limit_mb: Optional[int] = None
+    cpu_limit: Optional[float] = None
+
+    # Evaluation strategies
+    cascade_evaluation: bool = True
+    cascade_thresholds: List[float] = field(default_factory=lambda: [0.5, 0.75, 0.9])
+
+    # Parallel evaluation
+    parallel_evaluations: int = 4
+    distributed: bool = False
+
+    # LLM-based feedback
+    use_llm_feedback: bool = False
+    llm_feedback_weight: float = 0.1
+
+    # Artifact handling
+    enable_artifacts: bool = True
+    max_artifact_storage: int = 100 * 1024 * 1024  # 100MB per program
+
+
+@dataclass
+class Config:
+    """Master configuration for OpenEvolve"""
+
+    # General settings
+    max_iterations: int = 10000
+    checkpoint_interval: int = 100
+    log_level: str = "INFO"
+    log_dir: Optional[str] = None
+    random_seed: Optional[int] = None
+
+    # Component configurations
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    prompt: PromptConfig = field(default_factory=PromptConfig)
+    database: DatabaseConfig = field(default_factory=DatabaseConfig)
+    evaluator: EvaluatorConfig = field(default_factory=EvaluatorConfig)
+
+    # Evolution settings
+    diff_based_evolution: bool = True
+    allow_full_rewrites: bool = False
+    max_code_length: int = 10000
+
+    @classmethod
+    def from_yaml(cls, path: Union[str, Path]) -> "Config":
+        """Load configuration from a YAML file"""
+        with open(path, "r") as f:
+            config_dict = yaml.safe_load(f)
+        return cls.from_dict(config_dict)
+
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> "Config":
+        """Create configuration from a dictionary"""
+        # Handle nested configurations
+        config = Config()
+
+        # Update top-level fields
+        for key, value in config_dict.items():
+            if key not in ["llm", "prompt", "database", "evaluator"] and hasattr(config, key):
+                setattr(config, key, value)
+
+        # Update nested configs
+        if "llm" in config_dict:
+            llm_dict = config_dict["llm"]
+            if "models" in llm_dict:
+                llm_dict["models"] = [LLMModelConfig(**m) for m in llm_dict["models"]]
+            if "evaluator_models" in llm_dict:
+                llm_dict["evaluator_models"] = [
+                    LLMModelConfig(**m) for m in llm_dict["evaluator_models"]
+                ]
+            config.llm = LLMConfig(**llm_dict)
+        if "prompt" in config_dict:
+            config.prompt = PromptConfig(**config_dict["prompt"])
+        if "database" in config_dict:
+            config.database = DatabaseConfig(**config_dict["database"])
+        if "evaluator" in config_dict:
+            config.evaluator = EvaluatorConfig(**config_dict["evaluator"])
+
+        return config
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to a dictionary"""
+        return {
+            # General settings
+            "max_iterations": self.max_iterations,
+            "checkpoint_interval": self.checkpoint_interval,
+            "log_level": self.log_level,
+            "log_dir": self.log_dir,
+            "random_seed": self.random_seed,
+            # Component configurations
+            "llm": {
+                "models": self.llm.models,
+                "evaluator_models": self.llm.evaluator_models,
+                "api_base": self.llm.api_base,
+                "temperature": self.llm.temperature,
+                "top_p": self.llm.top_p,
+                "max_tokens": self.llm.max_tokens,
+                "timeout": self.llm.timeout,
+                "retries": self.llm.retries,
+                "retry_delay": self.llm.retry_delay,
+            },
+            "prompt": {
+                "template_dir": self.prompt.template_dir,
+                "system_message": self.prompt.system_message,
+                "evaluator_system_message": self.prompt.evaluator_system_message,
+                "num_top_programs": self.prompt.num_top_programs,
+                "num_diverse_programs": self.prompt.num_diverse_programs,
+                "use_template_stochasticity": self.prompt.use_template_stochasticity,
+                "template_variations": self.prompt.template_variations,
+                # Note: meta-prompting features not implemented
+                # "use_meta_prompting": self.prompt.use_meta_prompting,
+                # "meta_prompt_weight": self.prompt.meta_prompt_weight,
+            },
+            "database": {
+                "db_path": self.database.db_path,
+                "in_memory": self.database.in_memory,
+                "population_size": self.database.population_size,
+                "archive_size": self.database.archive_size,
+                "num_islands": self.database.num_islands,
+                "elite_selection_ratio": self.database.elite_selection_ratio,
+                "exploration_ratio": self.database.exploration_ratio,
+                "exploitation_ratio": self.database.exploitation_ratio,
+                # Note: diversity_metric fixed to "edit_distance"
+                # "diversity_metric": self.database.diversity_metric,
+                "feature_dimensions": self.database.feature_dimensions,
+                "feature_bins": self.database.feature_bins,
+                "migration_interval": self.database.migration_interval,
+                "migration_rate": self.database.migration_rate,
+                "random_seed": self.database.random_seed,
+            },
+            "evaluator": {
+                "timeout": self.evaluator.timeout,
+                "max_retries": self.evaluator.max_retries,
+                # Note: resource limits not implemented
+                # "memory_limit_mb": self.evaluator.memory_limit_mb,
+                # "cpu_limit": self.evaluator.cpu_limit,
+                "cascade_evaluation": self.evaluator.cascade_evaluation,
+                "cascade_thresholds": self.evaluator.cascade_thresholds,
+                "parallel_evaluations": self.evaluator.parallel_evaluations,
+                # Note: distributed evaluation not implemented
+                # "distributed": self.evaluator.distributed,
+                "use_llm_feedback": self.evaluator.use_llm_feedback,
+                "llm_feedback_weight": self.evaluator.llm_feedback_weight,
+            },
+            # Evolution settings
+            "diff_based_evolution": self.diff_based_evolution,
+            "allow_full_rewrites": self.allow_full_rewrites,
+            "max_code_length": self.max_code_length,
+        }
+
+    def to_yaml(self, path: Union[str, Path]) -> None:
+        """Save configuration to a YAML file"""
+        with open(path, "w") as f:
+            yaml.dump(self.to_dict(), f, default_flow_style=False)
+
+
+def load_config(config_path: Optional[Union[str, Path]] = None) -> Config:
+    """Load configuration from a YAML file or use defaults"""
+    if config_path and os.path.exists(config_path):
+        config = Config.from_yaml(config_path)
+    else:
+        config = Config()
+
+        # Use environment variables if available
+        api_key = os.environ.get("OPENAI_API_KEY")
+        api_base = os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1")
+
+        config.llm.update_model_params({"api_key": api_key, "api_base": api_base})
+
+    # Make the system message available to the individual models, in case it is not provided from the prompt sampler
+    config.llm.update_model_params({"system_message": config.prompt.system_message})
+
+    return config