intermediate values

[TheSimplyRed]

Hi,
I have a function to minimize that contains log(x) and f(x)/x.
Is it normal that during iterations ipopt uses 0 even if I have x_L > 0?
Thanks

[svigerske]

Ipopt by default relaxes variable bounds slightly. You can turn this off via option bound_relax_factor: https://coin-or.github.io/Ipopt/OPTIONS.html#OPT_bound_relax_factor

[TheSimplyRed]

Hi,
I have X_L > 1e-30, I used AddIpoptNumOption(nlp, (char*)"bound_relax_factor", 0); but I still got -2.2511314263125530e-19 as value.
In my function I have log(x).
Why Ipopt uses values outside my limits? Is there another option to add?
Thanks

[TheSimplyRed]

With Print_Level I have

DenseVector "original x_L unscaled" with 46 elements:
original x_L unscaled[    1]= 9.9999999999999995e-08
original x_L unscaled[    2]= 0.0000000000000000e+00
original x_L unscaled[    3]= 1.0000000000000000e-70
original x_L unscaled[    4]= 1.0000000000000000e-70
original x_L unscaled[    5]= 1.0000000000000000e-70
original x_L unscaled[    6]= 1.0000000000000000e-70
original x_L unscaled[    7]= 1.0000000000000000e-70
original x_L unscaled[    8]= 1.0000000000000000e-70
original x_L unscaled[    9]= 1.0000000000000000e-70
original x_L unscaled[   10]= 1.0000000000000000e-70
original x_L unscaled[   11]= 1.0000000000000000e-70
original x_L unscaled[   12]= 1.0000000000000000e-70
original x_L unscaled[   13]= 1.0000000000000000e-70
original x_L unscaled[   14]= 1.0000000000000000e-70
original x_L unscaled[   15]= 1.0000000000000000e-70
original x_L unscaled[   16]= 1.0000000000000000e-70
original x_L unscaled[   17]= 1.0000000000000000e-70
original x_L unscaled[   18]= 1.0000000000000000e-70
original x_L unscaled[   19]= 9.9999999999999995e-08
original x_L unscaled[   20]= 0.0000000000000000e+00
original x_L unscaled[   21]= 9.9999999999999998e-13
original x_L unscaled[   22]= 9.9999999999999998e-13
original x_L unscaled[   23]= 9.9999999999999998e-13
original x_L unscaled[   24]= 1.0000000000000001e-30
original x_L unscaled[   25]= 1.0000000000000001e-30
original x_L unscaled[   26]= 1.0000000000000001e-30
original x_L unscaled[   27]= 1.0000000000000001e-30
original x_L unscaled[   28]= 1.0000000000000001e-30
original x_L unscaled[   29]= 1.0000000000000001e-30
original x_L unscaled[   30]= 0.0000000000000000e+00
original x_L unscaled[   31]= 0.0000000000000000e+00
original x_L unscaled[   32]= 0.0000000000000000e+00
original x_L unscaled[   33]= 0.0000000000000000e+00
original x_L unscaled[   34]= 0.0000000000000000e+00
original x_L unscaled[   35]= 0.0000000000000000e+00
original x_L unscaled[   36]= 0.0000000000000000e+00
original x_L unscaled[   37]= 0.0000000000000000e+00
original x_L unscaled[   38]= 0.0000000000000000e+00
original x_L unscaled[   39]= 0.0000000000000000e+00
original x_L unscaled[   40]= 0.0000000000000000e+00
original x_L unscaled[   41]= 0.0000000000000000e+00
original x_L unscaled[   42]= 0.0000000000000000e+00
original x_L unscaled[   43]= 0.0000000000000000e+00
original x_L unscaled[   44]= 0.0000000000000000e+00
original x_L unscaled[   45]= 0.0000000000000000e+00
original x_L unscaled[   46]= 1.4285714285714285e-01

and

DenseVector "modified x_L scaled" with 46 elements:
modified x_L scaled[    1]= 9.9999999999999995e-08
modified x_L scaled[    2]= 0.0000000000000000e+00
modified x_L scaled[    3]= 1.0000000000000000e-70
modified x_L scaled[    4]= 1.0000000000000000e-70
modified x_L scaled[    5]= 1.0000000000000000e-70
modified x_L scaled[    6]= 1.0000000000000000e-70
modified x_L scaled[    7]= 1.0000000000000000e-70
modified x_L scaled[    8]= 1.0000000000000000e-70
modified x_L scaled[    9]= 1.0000000000000000e-70
modified x_L scaled[   10]= 1.0000000000000000e-70
modified x_L scaled[   11]= 1.0000000000000000e-70
modified x_L scaled[   12]= 1.0000000000000000e-70
modified x_L scaled[   13]= 1.0000000000000000e-70
modified x_L scaled[   14]= 1.0000000000000000e-70
modified x_L scaled[   15]= 1.0000000000000000e-70
modified x_L scaled[   16]= 1.0000000000000000e-70
modified x_L scaled[   17]= 1.0000000000000000e-70
modified x_L scaled[   18]= 1.0000000000000000e-70
modified x_L scaled[   19]= 9.9999999999999995e-08
modified x_L scaled[   20]= 0.0000000000000000e+00
modified x_L scaled[   21]= 9.9999999999999998e-13
modified x_L scaled[   22]= 9.9999999999999998e-13
modified x_L scaled[   23]= 9.9999999999999998e-13
modified x_L scaled[   24]= 1.0000000000000001e-30
modified x_L scaled[   25]= 1.0000000000000001e-30
modified x_L scaled[   26]= 1.0000000000000001e-30
modified x_L scaled[   27]= 1.0000000000000001e-30
modified x_L scaled[   28]= 1.0000000000000001e-30
modified x_L scaled[   29]= 1.0000000000000001e-30
modified x_L scaled[   30]= 0.0000000000000000e+00
modified x_L scaled[   31]= 0.0000000000000000e+00
modified x_L scaled[   32]= 0.0000000000000000e+00
modified x_L scaled[   33]= 0.0000000000000000e+00
modified x_L scaled[   34]= 0.0000000000000000e+00
modified x_L scaled[   35]= 0.0000000000000000e+00
modified x_L scaled[   36]= 0.0000000000000000e+00
modified x_L scaled[   37]= 0.0000000000000000e+00
modified x_L scaled[   38]= 0.0000000000000000e+00
modified x_L scaled[   39]= 0.0000000000000000e+00
modified x_L scaled[   40]= 0.0000000000000000e+00
modified x_L scaled[   41]= 0.0000000000000000e+00
modified x_L scaled[   42]= 0.0000000000000000e+00
modified x_L scaled[   43]= 0.0000000000000000e+00
modified x_L scaled[   44]= 0.0000000000000000e+00
modified x_L scaled[   45]= 0.0000000000000000e+00
modified x_L scaled[   46]= 1.4285714285714285e-01

same values.
I'm confused, during one iteration x[24] <0 that caused a restoration phase failed.

[svigerske]

Would be good if you could debug a bit to check where this happens within Ipopt.

Maybe it is some floating point rounding issue. Increasing the lower bound by a few more magnitudes might help.

[TheSimplyRed]

What about
c scaling provided d scaling provided

I saw that c scaling is for equality constraints and d scaling is for inequality. Is is possible to disable it to make it unscaled? Can this help? or it will be worst for convergence?

[svigerske]

You can set option nlp_scaling_method none to disable scaling of the constraints. It may not be necessary. But I don't see what it has to do with variable bounds.

[TheSimplyRed]

It has nothing to do with variable bounds, I wanted to test it to see if it will converge or not (better or faster)

[TheSimplyRed]

In iteration 78, 1 Slack too small, adjusting variable bound

after this iteration x[24] < 0 , I increased X_L from 1e-30 to 1e-20;
I have an other set of variables with X_L = 1e-70 and it seems ok for this set.

[svigerske]

You could try this change:

--- a/src/Algorithm/IpIpoptCalculatedQuantities.cpp
+++ b/src/Algorithm/IpIpoptCalculatedQuantities.cpp
@@ -471,7 +471,7 @@ Index IpoptCalculatedQuantities::CalculateSafeSlack(
       // but we want slack corrections also if (and especially if) slacks are at 0
       // (otherwise the barrier_obj becomes inf and there are asserts that say that this shouldn't happen)
       // so we ensure that s_min is at least positive
-      if( s_min == 0.0 )
+//      if( s_min == 0.0 )
       {
          s_min = std::numeric_limits<Number>::min();
       }

That should reduce adjusting variable bounds to an absolute minimum, but can cause other numerical issues.

Section 3.5 of the implementation paper gives a bit background on this.

[TheSimplyRed]

I don't have an Intel compiler, I'm using binaries downloaded from here.
Do you have a tutorial on how to build binaries using visual studio 2019?

[svigerske]

Build instructions are part of the docu: https://coin-or.github.io/Ipopt/INSTALL.html

[andrea5w]

You might want to look at your optimization model. If the optimizer pushes the iterate to the limit, it usually means that the objective is improving that way and it seems that the "true" optimal solution would have the optimal variable value at 0. If that variable appears in a log term, this term will go to + or - infinity, which somewhat of a strange constraint function. Maybe reformulating the problem might help.

Also, from a precision point of view, 1e-10 and 1e-30 are not really different, particularly because Ipopt is an interior point method and the optimal variable values are never found up to that precision. Again, if it makes a difference in your optimization problem whether you set the lower bound to 1e-8 or 1e-30, then there is something strange going on with your model.

[TheSimplyRed]

For another set of variables we need even smaller values 1e-66. The solution that I have is to replace X by exp(X).
But I wanted to put all my variables on the same range 0 to 1 for better/faster convergence.
Actually here are the ranges for different kind of variables (A,B,C,D)
A [ 0 , 1000000] re scaled to [0, 1]
B [-100, 0] re scaled to [0, 1]
C ]0, 1] if I use exponential it becomes [-150, 0]
D [0, 5000] re scaled to [0, 1]

For C it is important to have a precision of 1e-66, so according to your answer, I have no other choice than to use the exponential.