liblaf.peach.optim.scipy ¶

@override
def init[X](self, problem: BaseProblem[X], model_state: X, params: Vector) -> State:
    """Initialize SciPy state from the starting parameters."""
    res: OptimizeResult = OptimizeResult({"x": params})  # ty:ignore[too-many-positional-arguments]
    return self.State(res)

@override
def minimize[X](
    self, problem: BaseProblem[X], model_state: X, params: Vector
) -> Solution:
    """Run `scipy.optimize.minimize` against a Peach problem."""
    problem: Problem[X] = cast("Problem[X]", problem)
    opt_state: ScipyState = self.init(problem, model_state, params)
    wrapper: _ProblemWrapper[X] = _ProblemWrapper(problem, model_state=model_state)
    fun, jac = (
        (wrapper.fun, wrapper.grad)
        if wrapper.value_and_grad is None
        else (wrapper.value_and_grad, True)
    )
    opt_state.__wrapped__ = scipy.optimize.minimize(
        fun=fun,
        x0=opt_state.params,
        method=self.method,
        jac=jac,
        hessp=wrapper.hessp,
        tol=self.tol,
        callback=self._wraps_callback(wrapper, opt_state),
        options=self.options,
    )  # ty:ignore[no-matching-overload]
    result: Result = (
        Result.SUCCESS if opt_state["success"] else Result.UNKNOWN_ERROR
    )
    solution: ScipyOptimizer.Solution = self.postprocess(
        problem, model_state, opt_state, result
    )
    return solution

@override
def postprocess[X](
    self, problem: BaseProblem[X], model_state: X, opt_state: State, result: Result
) -> Solution:
    """Build the SciPy optimizer solution object."""
    return Solution(result=result, state=opt_state, stats=self.Stats())

def step[X](self, problem: BaseProblem[X], model_state: X, opt_state: S) -> None:
    """Advance the optimizer by one step.

    Implementations should mutate `model_state` and `opt_state` with any
    accepted parameter, gradient, or diagnostic updates.
    """
    raise NotImplementedError

def terminate[X](
    self, problem: BaseProblem[X], model_state: X, opt_state: S
) -> tuple[bool, Result]:
    """Return whether optimization should stop and why."""
    raise NotImplementedError

def __getitem__(self, key: str) -> Any:
    """Return an item from the wrapped SciPy result."""
    return self.__wrapped__[key]

def __iter__(self) -> Iterator[str]:
    """Iterate over keys in the wrapped SciPy result."""
    yield from self.__wrapped__

def __len__(self) -> int:
    """Return the number of keys in the wrapped SciPy result."""
    return len(self.__wrapped__)