MiniZinc模型的优化

Question

I have a MiniZinc model which is supposed to find d[1 .. n] and o[1..k, 0 .. n] such that x[k] = o[k,0] + d[1]*o[k,1] + d[2]*o[k,2] ... d[n]+o[k,n] and the sum of absolute values of o[k,i]'s is minimized.

I have many different x[i] and d[1..n] should remain the same for all of them.

I have a working model which is pasted below, which finds a good solution in the n=2 case really quickly (less than a second) however, if I go to n=3 (num_dims in the code) even after an hour I get no answer except the trivial one (xi=o0), even though the problem is somewhat recursive, in that a good answer for 2 dimensions can serve as a starting point for 3 dimensions by using o0 as xi for a new 2 dimensional problem.

I have used MiniZinc before, however, I do not have a background in OR or Optimization, thus I do not really know how to optimize my model. I would be helpful for any hints on how to do that, either by adding constraints or somehow directing the search. Is there a way to debug such performance problems in MiniZinc?

My current model:

% the 1d offsets
array [1 .. num_stmts] of int : x;
x = [-10100, -10001, -10000, -9999, -9900, -101, -100, -99, -1, 1, 99, 100, 101, 9900, 9999, 10000, 10001, 10100];
int : num_stmts = 18;

% how many dimensions we decompose into
int : num_dims = 2;

% the dimension sizes
array [1 .. num_dims] of var int : dims;

% the access offsets
array [1 .. num_stmts, 1 .. num_dims] of var int : offsets;

% the cost function: make access distance (absolute value of offsets) as small as possible
var int : cost = sum (s in 1 .. num_stmts, d in 1 .. num_dims) (abs(offsets[s,d]));

% dimensions must be positive
constraint forall (d in 1 .. num_dims) (dims[d] >= 0);

% offsets * dimensions must be equal to the original offsets
constraint forall (s in 1 .. num_stmts) (
  x[s] = offsets[s,1] + sum(d in 2 .. num_dims) (offsets[s,d] * dims[d-1])
 );

% disallow dimension crossing
constraint forall (s in 1 .. num_stmts, d in 1 .. num_dims) (
  abs(offsets[s,d]) < dims[d]
 );

% all dims together need to match the array size
constraint product (d in 1..num_dims) (dims[d]) = 1300000;

solve minimize cost;

output ["dims = ", show(dims), "\n"] ++
       [ if d == 1 then show_int(6, x[s]) ++ " = " else "" endif ++ 
       " " ++ show_int(4, offsets[s, d]) ++ if d>1 then " * " ++ show(dims[d-1]) else "" endif ++
       if d == num_dims then "\n" else " + " endif  |
   s in 1 .. num_stmts, d in 1 .. num_dims];

Answer 1

Are you using the MiniZinc IDE? Have you tried using a different solver?

I was struggling with a problem of dividing n random positive integers into m groups ( m < n ) where the sum of each group was supposed to be as close as possible to some other number.

When n reached about 100 and m about 10, it took significantly longer time (30 min+) and the result was not satisfying. This was using the default Gecode (bundled) solver. By chance I went through each and everyone of the solvers and found that the COIN-OR CBC (bundled) found an optimal solution within 15 s.