关于scipy.optimize.minimize收敛指标nit、nfev、njev的解读及相关问题咨询

First, let’s recap your example optimizer output for context:

----------------------------------------
 message: Optimization terminated successfully
 success: True
  status: 0
     fun: -0.2498255944127068
       x: [ 6.087e-02  7.000e-02  7.000e-02  7.000e-02  7.000e-02
            7.000e-02  7.000e-02  7.000e-02]
     nit: 6
     jac: [-4.197e-02 -8.534e-02 -2.353e-02 -1.421e-02 -8.549e-02
           -5.721e-02 -1.725e-02 -4.846e-03]
    nfev: 54
    njev: 6

Great—now let’s break down each of your questions using this concrete example:

Question 1: Why are there far more function evaluations than Jacobian evaluations? #

The key here is how the SLSQP solver computes the Jacobian when you don’t provide an analytical version (which is your case here).

SLSQP defaults to using forward finite differences to approximate the Jacobian. For an 8-variable problem like yours, this requires:

• 1 "base" evaluation of the objective function at the current iteration’s point
• 8 additional evaluations, each with one variable slightly perturbed to estimate the partial derivative for that variable

That’s 9 function evaluations per Jacobian calculation. Looking at your numbers: njev=6 (6 Jacobian computations) × 9 = 54, which exactly matches your nfev=54—a perfect alignment!

If you want to cut down on function evaluations, you can implement an analytical Jacobian (a function that directly calculates the partial derivatives of your objective) and pass it to minimize via the jac parameter. This would make nfev drop to roughly match nit, since you won’t need all those finite difference checks.

Question 2: Do these metrics indicate solution stability or convergence speed? #

Let’s split this into two parts:

• Convergence speed: Definitely. nit (number of iterations) is a direct measure of how quickly the solver reached the optimum. Your nit=6 means it took only 6 steps to converge—this is very efficient, which suggests your initial guess was good, your problem is well-conditioned, or your constraints aren’t overly restrictive.
• Solution stability: These metrics don’t directly tell you if the solution is stable (i.e., if small changes to the initial guess or problem parameters would lead to the same optimum). However, they can give indirect hints:
  • If nit is extremely large, or nfev is way higher than expected, it might signal a rough objective landscape or ill-conditioned problem, which could make the solution less stable.
  • To properly test stability, you should run the optimizer with different initial guesses (x0 values) and see if you consistently end up with the same x and fun values.

Your success=True and status=0 are the most direct signs that the solver found a valid optimum, but stability requires extra testing beyond these metrics.

Question3: What can we learn from these metrics alone, and what else should we dive into? #

What the metrics tell you directly:

1. Convergence efficiency: nit=6 is efficient—your problem didn’t require many iterations to converge.
2. Jacobian computation method: The ratio nfev/njev=9 confirms you’re using finite differences for the Jacobian (since it matches the number of variables +1).
3. Resource usage: Higher nfev means the solver spent more time evaluating your objective function, which is critical to know if your objective is computationally expensive.

What else to explore for a deeper understanding:

• Jacobian values (jac array): The absolute values in jac show how sensitive the objective function is to each variable. Larger values mean the objective changes more when that variable is perturbed. For example, your first variable has a jac value of ~-0.042, which is much larger than the last variable’s ~-0.0048—so the objective is far more sensitive to changes in the first variable.
• Active constraints: Looking at your x array, variables 2-7 are all stuck at 7.000e-02—this suggests those variables are hitting a constraint (lower or upper bound). You should check your constraint definitions to confirm if this is expected, or if it’s limiting your ability to reach a better optimum.
• Objective landscape: To understand the landscape better, you can:
  • Plot the objective function along the directions of the most sensitive variables (using the Jacobian as a guide).
  • Test multiple initial guesses to see if you find the same optimum (to check for local vs. global minima).
  • Compute the Hessian (either analytically or via finite differences) to confirm the optimum is a local minimum (positive definite Hessian).
• Solver status codes: If you encounter non-zero status codes later, you can refer to the scipy.optimize.minimize documentation to understand what they mean (e.g., status 1 might indicate the maximum number of iterations was reached before convergence).

备注：内容来源于stack exchange，提问作者kehunter