Request: stopping at a threshold score

[theahura]

Currently, open evolve implements an early stopping mechanism through the use of a patience value in a passed in config. Patience will kill an evolution if there is no score improvement above some threshold for N steps.

Another form of early stopping that is valuable is stopping once a certain score is reached. For example, you could imagine a distance score that you want to eventually converge to 0, and you want to keep running openevolve until the distance hits 0. In such a case, further iterations once the score is 0 is wasteful. This additional early stopping mechanism interacts with patience -- you could imagine wanting to stop early if the patience threshold is hit OR if the ideal score is hit, whichever happens first -- but you cannot directly use patience for this purpose without incurring some wasted computation cycles.

I think implementing early stopping in this way would require modifying parts of the config as well as the process_parallel.py file. I'm happy to take a stab at this, but would love some guidance about where to look / what needs changing

[codelion]

The target score stopping mechanism is implemented and should be working via the CLI:

# Stop when target score of 0.95 is reached
python openevolve-run.py program.py evaluator.py --config config.yaml --target-score 0.95

# Works with existing patience mechanism too
python openevolve-run.py program.py evaluator.py --config config.yaml --target-score 0.95 --iterations 1000

[theahura]

o sweet so to make the changes I want we just have to add this to the config then?

[theahura]

@codelion this does not work quite as expected.

Two issues.

• First, if no iterations value is passed in, it will use the default, which is set to 10k steps. This is obviously a lot, but its not the same as not having any iteration max limit at all
  https://github.com/codelion/openevolve/blob/main/openevolve/controller.py#L243

• Second, if a target score is passed in, it will look at the average of all numeric scores instead of the combined_score to evaluate the final result, resulting in it ending early (https://github.com/codelion/openevolve/blob/main/openevolve/process_parallel.py#L596)

[codelion]

thanks for checking this and yes it is a bug, happy to review a fix PR.

[theahura]

Here's a pass: #286

[yuxuan-z19]

I might be missing something, but I’m confused about the handling of combined_score here.

If combined_score is already present in child_program.metrics, the first branch will pick it up directly. However, if it’s not present and early_stopping_metric is set to "combined_score", the code falls back to safe_numeric_average(child_program.metrics), which is the same behavior as the final else branch for a missing custom metric.

In other words, the "combined_score" case does not appear to introduce any distinct logic compared to the default fallback. Is there an intended semantic difference here that I’m overlooking, or is this effectively redundant with the else branch?

if early_stopping_enabled and child_program.metrics:
    # Get the metric to track for early stopping
    current_score = None
    if self.config.early_stopping_metric in child_program.metrics:
        current_score = child_program.metrics[self.config.early_stopping_metric]
    elif self.config.early_stopping_metric == "combined_score":
        # Default metric not found, use safe average (standard pattern)
        current_score = safe_numeric_average(child_program.metrics)
    else:
        # User specified a custom metric that doesn't exist
        logger.warning(
            f"Early stopping metric '{self.config.early_stopping_metric}' not found, using safe numeric average"
        )
        current_score = safe_numeric_average(child_program.metrics)