ez-optimize 0.1.0

A drop-in for scipy optimize that allows keyword args (x0={'x': 1, 'y': 2}) and more

ez-optimize

Author: Quinn Marsh
GitHub: https://github.com/qthedoc/ez-optimize/
PyPI: https://pypi.org/project/ez-optimize/

ez-optimize makes optimization easy and intuitive. It is a lightweight wrapper for SciPy's optimize that offer a drop-in replacements for SciPy's minimize function with enhanced features like keyword-based parameter definitions and quick switching between minimization and maximization.

The Ironman suit for optimization.

Why ez-optimize?

1. Keyword-Based Optimization (e.g.: x0={'x': 1, 'y': 2})

By default, optimization uses arrays x0=[1, 2]. However sometimes it's more intuitive to use named parameters x0={'x': 1, 'y': 2}. ez-optimize allows you to define parameters as dictionaries. Then under the hood, ez-optimize automatically flattens parameters (and wraps your function) for SciPy while restoring the original structure in results. Keyword-based optimization is especially useful in complex systems like aerospace or energy models where parameters have meaningful names representing physical quantities.

2. Switch to Maximize with direction='max'

By default, optimization minimizes the objective function. To maximize, you typically need to write a negated version of your function. With ez-optimize, simply set direction='max' and the library will automatically negates your function under the hood.

Examples

Example 1: Minimizing the Rosenbrock Function with Array Mode

import numpy as np
from ez_optimize import minimize

def rosenbrock_2d(x, y, a, b):
    return (a - x)**2 + b * (y - x**2)**2

x0 = {'x': 1.3, 'y': 0.7}

result = minimize(rosenbrock_2d, x0, method='BFGS')

print(f"Optimal x: {result.x_original}")
print(f"Optimal value: {result.fun}")

Optimal x: {'x': 1.0, 'y': 1.0}
Optimal value: 0.0

Example 2: Using OptimizationProblem for Advanced Manual Control

For more control, use the OptimizationProblem class directly. This also serves as a look under the hood for how minimize works.:

from ez_optimize import OptimizationProblem
from scipy.optimize import minimize as scipy_minimize

def objective(a, b, c):
    return a**2 + b**2 + c**2

x0 = {'a': 1.0, 'b': 2.0, 'c': 3.0}
bounds = {'a': (0, 5), 'b': (0, 5), 'c': (0, 5)}

# Define the optimization problem
problem = OptimizationProblem(objective, x0, method='SLSQP', bounds=bounds)

# Run SciPy method directly, passing in the arguments prepared by the OptimizationProblem
scipy_result = scipy_minimize(**problem.scipy.get_minimize_args())

# Use the OptimizationProblem to interpret the result back into our structured format
result = problem.scipy.interpret_result(scipy_result)

print(f"Optimal parameters: {result.x_original}")
print(f"Optimal value: {result.fun}")

Optimal parameters: {'a': 0.0, 'b': 0.0, 'c': 0.0}
Optimal value: 0.0

Fundumentally Why?

Lets be honest, there is good reason optimization typically uses arrays and always minimizes... it makes the math simple and efficient. For example, optimizing in a vector space allows the hessian to be represented as a matrix. However, this level of optimization isn't always necessary like with black-box functions that have no gradient or hessian. In those cases, the convenience of defining keyword-based parameters and easy switching between min/max can outweigh the mathematical perfection of array-based optimization.

Acknowledgments

Inspired by better_optimize by Jesse Grabowski, licensed under MIT.

Contributing

Contributions Welcome! Report bugs, request features, or improve documentation via GitHub issues or pull requests.