OpenMDAO：ScipyOptimizeDriver与pyOptSparseDriver对比及SLSQP差异咨询

Great question! I’ve worked with both drivers extensively on engineering optimization problems, especially using the SLSQP optimizer, so let me break down the critical distinctions beyond the failure point handling and optimizer method differences you already noted:

• Sparse Matrix Efficiency
  pyOptSparseDriver is built from the ground up to leverage sparse matrix structures. When your problem has sparse gradients or constraints (super common in engineering like finite element models), it passes these sparse matrices directly to SLSQP, cutting down memory usage and speeding up linear algebra operations dramatically. ScipyOptimizeDriver, by contrast, converts all sparse inputs to dense matrices by default—for large-scale sparse problems, this can lead to massive memory bloat and slow convergence with SLSQP.

• Native Parallel Evaluation Support
  pyOptSparseDriver includes out-of-the-box parallelization for function and constraint evaluations via the num_processes parameter. This is a game-changer for computationally expensive objectives, as SLSQP can leverage parallelism to reduce overall runtime. ScipyOptimizeDriver has no native parallel support; you’d have to implement custom parallelization (e.g., using multiprocessing with Scipy’s callback system) which adds complexity and doesn’t integrate as smoothly with SLSQP’s internal step logic.

• Granular Convergence Control & Debugging
  With pyOptSparse’s SLSQP interface, you get fine-grained control over convergence thresholds—beyond just maxiter and ftol, you can adjust parameters like constraint violation tolerances (ACC), step size limits, and even switch between different linear solvers for the QP subproblems. It also provides detailed debug logs that track sparse matrix updates, constraint slack values, and penalty adjustments at each iteration. Scipy’s SLSQP implementation has far fewer configurable parameters, and its output is much more high-level, making it harder to diagnose convergence stalls or unexpected behavior.

• Robust Failure Point Recovery
  While you noted pyOptSparse handles failed evaluations better, the specifics matter: it lets you define custom recovery strategies (e.g., returning a penalized objective value, retrying with a smaller step, or marking the point as infeasible) directly in the driver setup. Scipy’s SLSQP will terminate immediately if it encounters a NaN/Inf from your objective or constraints—you have to handle all failure cases manually in your evaluation function, which adds boilerplate and can break the optimizer’s step logic if not done perfectly.

• Memory Footprint for Large-Scale Problems
  For problems with thousands of variables or constraints, pyOptSparse’s sparse-aware design keeps memory usage manageable. I once worked on a structural optimization problem with ~6k sparse constraints: ScipyOptimizeDriver ran out of 32GB of RAM trying to process dense matrices, while pyOptSparseDriver with SLSQP handled it with under 8GB of memory.

• Optimizer Customization
  pyOptSparse allows you to tweak low-level SLSQP behavior that’s locked down in Scipy. For example, you can enable sparse finite difference approximations to reduce gradient computation time, adjust how constraints are scaled, or even replace the default QP solver with a custom implementation. Scipy’s SLSQP wraps the original Fortran code with minimal exposed configuration, leaving little room for customization.

内容的提问来源于stack exchange，提问作者rJonatan