Optimization algorithm for single objective, mixed integer, constrained programming?

Question

I have an optimization problem that can hardly be solved by analytic nor numeric solvers, as I'm not able to provide the derivatives for it. Therefore im looking for a solution using heuristic or genetic algorithms.

My problem consists of the following:

• single objective
• large scale, but app. less than 10.000 variables
• mixed integer (MIP) (variables mainly decimals, a few are boolean/integer variables)
• constrained (variable-boundary constraints, equality and inequality constraints, app. the same amount as variables)

So my questions are:

1. Is there a paper that takes all the points into account (especially mixed integer programming) in a heuristic/genetic algorithm?

2. Is there a good way to achieve mixed integer programming in a heuristic/genetic algorithm?

3. How does one handle equality constraints in a heuristic/genetic algorithm the best way?

4. Are there any (open source) libraries out there that could be promising?

---

My expirience so far with my problem implementing in the MOEA-Framework using the algorithmtypes NSGAII (and some of its derivatives) or a plain stupid random number generator is that, when using equality constraints or a MIP problem, the GA does not find a solution, even not when allowing alot of generations and a large populationsize for a really small problem.

Answer 1

Have you tried on sciPy/numPy? it has a command which performs simulated annealing. The only thing you must do is convert constraints to differences and sum them to the objective function. Look at this:

Min Z=x1^2+x2^2

subject to:

x1+x2>=2

Here's my python code:

#import modules
import numpy as np
from scipy import optimize

#define Constraint 1
def diffC1(x1,x2):
    return max(x1+x2-2,0)

#penalization value
M=10000.

#define your objective function (with Constraint 1 inserted)
def f(X):
    x1,x2=X
    print x1,x2
    return x1**2+x2**2+M*(diffC1(x1,x2))
#initialize x1=2 and x2=2
X0=np.array([2., 2.])

#try your function
f(X0)

#solve!
np.random.seed(555)   # Seeded to allow replication.
res = optimize.anneal(f, X0, schedule="boltzmann",
                          full_output=True, maxiter=10000,
                           dwell=250, disp=True)

#evaluate your achieved objective function value
f(res[0])