Main Content

Warm Start quadprog

Open Live Script

This example shows how a warm start object increases the speed of the solution in a large, dense quadratic problem. Create a scaled problem with N variables and 10N linear inequality constraints. Set N to 1000.

rng default % For reproducibility
N = 1000;
rng default
A = randn([10*N,N]);
b = 5*ones(size(A,1),1);
f = sqrt(N)*rand(N,1);
H = (4+N/10)*eye(N) + randn(N);
H = H + H';
Aeq = [];
beq = [];
lb = -ones(N,1);
ub = -lb;

Create a warm start object for quadprog, starting from zero.

opts = optimoptions('quadprog','Algorithm','active-set');
x0 = zeros(N,1);
ws = optimwarmstart(x0,opts);

Solve the problem, and time the result.

tic
[ws1,fval1,eflag1,output1,lambda1] = quadprog(H,f,A,b,Aeq,beq,lb,ub,ws);
Minimum found that satisfies the constraints.

Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

<stopping criteria details>

toc
Elapsed time is 9.221035 seconds.

The solution has several active linear inequality constraints, and no active bounds.

nnz(lambda1.ineqlin)
ans = 211

nnz(lambda1.lower)
ans = 0

nnz(lambda1.upper)
ans = 0

The solver takes a few hundred iterations to converge.

output1.iterations
ans = 216

Change one random objective to twice its original value.

idx = randi(N);
f(idx) = 2*f(idx);

Solve the problem with the new objective, starting from the previous warm start solution.

tic
[ws2,fval2,eflag2,output2,lambda2] = quadprog(H,f,A,b,Aeq,beq,lb,ub,ws1);
Minimum found that satisfies the constraints.

Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

<stopping criteria details>

toc
Elapsed time is 1.490214 seconds.

The solver takes much less time to solve the new problem.

The new solution has about the same number of active constraints.

nnz(lambda2.ineqlin)
ans = 214

nnz(lambda2.lower)
ans = 0

nnz(lambda2.upper)
ans = 0

The new solution is near the previous solution.

norm(ws2.X - ws1.X)
ans = 0.0987

norm(ws2.X)
ans = 2.4229

The difference in speed is largely due to the solver taking many fewer iterations.

output2.iterations
ans = 29

See Also

|

Related Topics