Search code examples
pythonmathematical-optimizationgekko

Python GEKKO Unexpected Behavior with Constraints

I've been playing around with GEKKO for solving flow optimizations and I have come across behavior that is confusing me.

Context:

Sources --> [mixing and delivery] --> Sinks

I have multiple sources (where my flow is coming from), and multiple sinks (where my flow goes to). For a given source (e.g., SOURCE_1), the total flow to the resulting sinks must equal to the volume from SOURCE_1. This is my idea of conservation of mass where the 'mixing' plant blends all the source volumes together.

Constraint Example (DOES NOT WORK AS INTENDED):

When I try to create a constraint for the two SINK volumes, and the one SOURCE volume:

m.Equation(volume_sink_1[i] + volume_sink_2[i] == max_volumes_for_source_1)

I end up with weird results. With that, I mean, it's not actually optimal, it ends up assigning values very poorly. I am off from the optimal by at least 10% (I tried with different max volumes).

Constraint Example (WORKS BUT I DON'T GET WHY):

When I try to create a constraint for the two SINK volumes, and the one SOURCE volume like this:

m.Equation(volume_sink_1[i] + volume_sink_2[i] <= max_volumes_for_source_1 * 0.999999)

With this, I get MUCH closer to the actual optimum to the point where I can just treat it as the optimum. Please note that I had to change it to a less than or equal to and also multiply by 0.999999 which was me messing around with it nonstop and eventually leading to that.

Also, please note that this uses practically all of the source (up to 99.9999% of it) as I would expect. So both formulations make sense to me but the first approach doesn't work.

The only thing I can think of for this behavior is that it's stricter to solve for == than <=. That doesn't explain to me why I have to multiply by 0.999999 though.

Why is this the case? Also, is there a way for me to debug occurrences like this easier?

Solution

  • This same improvement occurs with complementary constraints for conditional statements when using s1*s2<=0 (easier to solve) versus s1*s2==0 (harder to solve).

    if statement

    complementary

    From the research papers I've seen, the justification is that the solver has more room to search to find the optimal solution even if it always ends up at s1*s2==0. It sounds like your problem may have multiple local minima as well if it converges to a solution, but it isn't the global optimum.

    If you can post a complete and minimal problem that demonstrates the issue, we can give more specific suggestions.