Constraint output of the optimization

[lthUniBonn]

Hi there,

I've been checking out more of the optimization output, as the output showed successful termination and violated lower bounds of constraints. I'm not sure if this is a problem in my implementation, but from the output I get, it seems plausible to me that the problem might be the self.constraints[con_name]value[j] taking the last resulting constraints instead of the constraints matching the chosen variable values.
Using the detailed output for each iteration and printing the values and resulting constraints in the eval function I get the output below.

• the resulting objective value matches the value printed next to the last iteration (3), as well as the variable values match the eval function output directly above Iteration 3 (marked with **) - this would mean that the resulting constraints should also be the same as the constraints in that line.
• the constraints in the output however seem to match the last evaluation of the eval function (marked with !)
• to test this I called the eval function again with the optimizer variable output (last two lines marked with ***) - and again the resulting objective and constraints match (**) and not (!).

Hope this is understandable and you can tell me, where the problem lies.
Cheers,
Lavinia

# [4 x_vals]                                                 [4 constraint values]
[0.18686518 0.03       0.43633231 0.15950488 0.19      ] [-1.14083888e+01  1.00000000e-06  8.24609623e-01  0.00000000e+00]
[0.18686418 0.030001   0.43633231 0.15950488 0.19      ] [-1.14082888e+01  1.00000000e-06  8.24609623e-01  0.00000000e+00]
[0.18686418 0.03       0.43633331 0.15950488 0.19      ] [-1.14084237e+01  1.00000000e-06  8.24611041e-01  0.00000000e+00]
[0.18686418 0.03       0.43633231 0.15950588 0.19      ] [-1.14083112e+01  1.00000000e-06  8.24609623e-01  0.00000000e+00]
[0.07491426 0.03       0.43633231 0.15       0.19      ] [-1.37009064e-02  1.00000000e-06  8.50172480e-01  0.00000000e+00]
     ITER =    2     OBJ = -0.29674829E+00
      0.7491E-01
      0.3000E-01
      0.4363E+00
      0.1500E+00
[0.07491526 0.03       0.43633231 0.15       0.19      ] [-1.38009064e-02  1.00000000e-06  8.50170480e-01  0.00000000e+00]
[0.07491426 0.030001   0.43633231 0.15       0.19      ] [-1.37009064e-02  1.00000000e-06  8.50172480e-01  0.00000000e+00]
[0.07491426 0.03       0.43633331 0.15       0.19      ] [-1.38190582e-02  1.00000000e-06  8.50172480e-01  0.00000000e+00]
[0.07491426 0.03       0.43633231 0.150001   0.19      ] [-1.37206605e-02  1.00000000e-06  8.50172480e-01  0.00000000e+00]
**[0.07477725 0.03       0.43633231 0.15       0.19      ] [5.21734000e-12 1.00000000e-06 8.50446499e-01 0.00000000e+00]
**     ITER =    3     OBJ = -0.29587438E+00
**      0.7478E-01
**      0.3000E-01
**      0.4363E+00
**      0.1500E+00
[0.07477825 0.03       0.43633231 0.15       0.19      ] [-9.99999948e-05  1.00000000e-06  8.50444499e-01  0.00000000e+00]
[0.07477725 0.030001   0.43633231 0.15       0.19      ] [5.21734000e-12 1.00000000e-06 8.50446499e-01 0.00000000e+00]
[0.07477725 0.03       0.43633331 0.15       0.19      ] [-1.18151748e-04  1.00000000e-06  8.50446499e-01  0.00000000e+00]
![0.07477725 0.03       0.43633231 0.150001   0.19      ] [-1.97540889e-05  1.00000000e-06  8.50446499e-01  0.00000000e+00]


Optimization Problem -- Pumping cycle power
================================================================================
    Objective Function: eval_fun_pyopt

    Solution: 
--------------------------------------------------------------------------------
    Total Time:                    6.9030
       User Objective Time :       2.5258
       User Sensitivity Time :     4.3683
       Interface Time :            0.0083
       Opt Solver Time:            0.0006
    Calls to Objective Function :       6
    Calls to Sens Function :            4


**   Objectives
      Index  Name            Value          Optimum
          0  obj    -2.958744E-01     0.000000E+00

**   Variables (c - continuous, i - integer, d - discrete)
      Index  Name   Type      Lower Bound            Value      Upper Bound     Status
          0  x0_0      c     3.000000E-02     7.477725E-02     5.000000E-01           
          1  x1_0      c     3.000000E-02     3.000000E-02     5.000000E-01          l
          2  x2_0      c     4.363323E-01     4.363323E-01     5.235988E-01          l
          3  x3_0      c     1.500000E-01     1.500000E-01     2.500000E-01          l

!   Constraints (i - inequality, e - equality)
      Index  Name Type          Lower           Value           Upper    Status  Lagrange Multiplier (N/A)
          0  g0    i   0.000000E+00   -1.975409E-05    1.000000E+20         L    9.00000E+100
          1  g1    i   0.000000E+00    1.000000E-06    1.000000E+20              9.00000E+100
          2  g2    i   0.000000E+00    8.504465E-01    1.000000E+20              9.00000E+100
          3  g3    i   0.000000E+00    0.000000E+00    1.000000E+20         l    9.00000E+100

--------------------------------------------------------------------------------

Optimization terminated successfully.    (Exit mode 0)
            Current function value: -0.2958744134895037

***Optimizer eval function results:  [-0.2958744134895037]
***cons: [5.21734000e-12 1.00000000e-06 8.50446499e-01 0.00000000e+00]

[marcomangano]

Hello!
Just to clarify, the variables and constraints lists you are printing come directly from your user-defined function evaluation, right?
It does look like the final printout is inconsistent, we need to take a look at the code to understand what is going on.

We usually rely on the optimizer specific output files and/or the history file to keep track of the variables, function, and constraint values.
I would recommend to use the history file data in this case, as SLSQP output file does not include a lot of information.
Anyway, this remains a potentially misleading output, could you please open an issue (using the same info above) so we can better keep track of it?

[lthUniBonn]

Yes, I just included a print statement in my definition of the objective function.

So do you mean a look at my code the produces this output for this? I could try to reproduce this behavior in simpler code (than what I use now - including some flight simulations and everything ;) and then post that code if that's what you mean?
The history file I can get more easily I think.

So then I'll open an issue on this and then append the History file output/code snippets when I have them.

[marcomangano]

No don't worry, I referred to pyOptSparse source code, this should not be related to your script.
I think that what you posted above (and maybe the related history file) are enough to explain the issue.

The optimum printout you brought up the last time was an easy fix, here we might need some more refactoring to get this working properly - that's why it is better if we keep track of the discussion in a dedicated Issue.
Again, I think this went unnoticed because we usually don't usually check the output on the terminal. Also, most of the optimization cases I have experience of (using other optimizers) have small differences in the last few iterations.
I think your case just makes this printout bug more evident!

Until this is fixed, I suggest you turn on the history and access the database once the optimization is completed with:

from pyoptsparse import History
[....]
optHist = History("<yourHistFileName>")
histValues = optHist.getValues()

then you can access histValues as a big dictionary - see the class documentation for structure and API info.

[marcomangano]

Actually, don't worry about opening the issue, #244 also covers this. I will add a link to this discussion, you can add further comments or keep track of the bug fix from there.

[lthUniBonn]

Sounds great, I'll check out the History file and see to include any more relevant parts (here).

You're right, my problem is not really nice any smooth - So it's basically made to find this bug ;)
Great, then I'll see where the issue goes. Thanks!