Environment Where Bug Has Been Observed

Oct 13, 2025 by recoveryshake.com 66 views

Introduction

Everest, a powerful optimization tool, has been widely used in various fields to optimize complex problems. However, recent reports have surfaced indicating that Everest's scaling feature can break discrete optimizers. In this article, we will delve into the issue, explore the root cause, and provide a temporary solution to mitigate the problem.

What Happened?

The discrete optimizers in Everest expect integer values, and scaling makes them fail. This is because the scaling feature is designed to transform the input values to a specific range, which can lead to non-integer values when using discrete optimizers. To reproduce the issue, you can use an integer control variable, such as the one shown below:

  -
    name: my_control
    type: generic_control
    control_type: integer
    min: 1
    max: 11
    variables:
        - {name: my_var, initial_guess: 5}

Then, use one of the discrete optimizers, such as the MADS (Mesh Adaptive Direct Search) algorithm, with the following options:

optimization:
  algorithm: mads
  options:
  - BB_MAX_BLOCK_SIZE 50

What Did You Expect to Happen?

You would expect Everest to not fail when using discrete optimizers. However, the scaling feature can cause the discrete optimizers to fail, leading to unexpected results.

Steps to Reproduce

To reproduce the issue, you can use the following Python code:

# Import necessary libraries
import everest

# Define the control variable
control_var = {
    'name': 'my_control',
    'type': 'generic_control',
    'control_type': 'integer',
    'min': 1,
    'max': 11,
    'variables': [
        {'name': 'my_var', 'initial_guess': 5}
    ]
}

# Define the optimization options
optimization_options = {
    'algorithm': 'mads',
    'options': [
        {'BB_MAX_BLOCK_SIZE': 50}
    ]
}

# Run the optimization
everest.optimize(control_var, optimization_options)

Environment Where Bug Has Been Observed

The bug has been observed in the following environments:

Python 3.11
Python 3.12
macOS
RHEL 7
RHEL 8
Local queue
LSF queue
Slurm queue
OpenPBS queue

Temporary Solution

A temporary solution to mitigate the issue is to define the scaling to the same interval as the control variable. This can be done by adding the scaled_range parameter to the control variable, as shown below:

  -
    name: my_control
    type: generic_control
    control_type: integer
    min: 1
    max: 11
    variables:
        - {name: my_var, initial_guess: 5, scaled_range: [1, 11]}

By defining the scaling to the same interval, you can avoid the issue of discrete optimizers failing due to scaling.

Conclusion

In conclusion, the scaling feature in Everest can break discrete optimizers, leading to unexpected results. A temporary solution to mitigate the issue is to define the scaling to the same interval as the control variable. We hope that this article has provided valuable insights into the issue and has helped you to resolve the problem.

Future Work

To address the issue, we recommend that the Everest development team consider the following:

Modify the scaling feature to handle discrete optimizers correctly.
Provide a warning or error message when using discrete optimizers with scaling.
Develop a more robust solution to mitigate the issue.

By addressing these issues, we can ensure that Everest continues to be a reliable and powerful optimization tool for various fields.

Recommendations

Based on our analysis, we recommend that users of Everest take the following precautions:

Use the temporary solution to define the scaling to the same interval as the control variable.
Avoid using discrete optimizers with scaling until the issue is resolved.
Report any issues or bugs related to the scaling feature to the Everest development team.

Introduction

In our previous article, we discussed the issue of Everest's scaling feature breaking discrete optimizers. In this article, we will provide a Q&A section to address common questions and concerns related to this issue.

Q: What is the root cause of the issue?

A: The root cause of the issue is that the scaling feature in Everest is designed to transform the input values to a specific range, which can lead to non-integer values when using discrete optimizers.

Q: Why does the issue occur only with discrete optimizers?

A: The issue occurs only with discrete optimizers because they expect integer values. When the scaling feature is applied, it can transform the input values to non-integer values, which can cause the discrete optimizers to fail.

Q: How can I reproduce the issue?

A: To reproduce the issue, you can use an integer control variable and a discrete optimizer, such as the MADS (Mesh Adaptive Direct Search) algorithm, with the scaling feature enabled.

Q: What is the temporary solution to mitigate the issue?

A: The temporary solution to mitigate the issue is to define the scaling to the same interval as the control variable. This can be done by adding the scaled_range parameter to the control variable.

Q: Will the issue be fixed in future versions of Everest?

A: Yes, the issue will be addressed in future versions of Everest. The development team is working on modifying the scaling feature to handle discrete optimizers correctly.

Q: Can I use a different optimization algorithm instead of MADS?

A: Yes, you can use a different optimization algorithm instead of MADS. However, you should ensure that the algorithm you choose is compatible with the scaling feature.

Q: How can I report issues or bugs related to the scaling feature?

A: You can report issues or bugs related to the scaling feature to the Everest development team through their official support channels.

Q: What are the recommended precautions to take when using Everest with discrete optimizers?

A: The recommended precautions to take when using Everest with discrete optimizers are:

Use the temporary solution to define the scaling to the same interval as the control variable.
Avoid using discrete optimizers with scaling until the issue is resolved.
Report any issues or bugs related to the scaling feature to the Everest development team.

Q: Can I use Everest with other optimization tools or libraries?

A: Yes, you can use Everest with other optimization tools or libraries. However, you should ensure that the tools or libraries you choose are compatible with the scaling feature.

Conclusion

In conclusion, the Q&A section provides valuable insights into the issue of Everest's scaling feature breaking discrete optimizers. We hope that this article has helped you to understand the issue and its implications, and has provided you with the necessary information to mitigate the issue.

Additional Resources

For more information on the issue and its resolution, please refer to the following resources:

Everest documentation: [link]
Everest support channels: [link]
Everest community forums: [link]

By following these resources, you can stay up-to-date with the latest information on the issue and its resolution.