12ismp Qpblur

QPBLUR: A Regularized Active-Set Method for
Sparse Convex Quadratic Programming

Christopher Maes and Michael Saunders
Gurobi Optimization
SOL and ICME, Stanford University
ISMP 2012
21st International Symposium on Mathematical Programming
TUB, Berlin, August 1924, 2012
1 QPBLUR overview
2 Active-set methods for quadratic programming
3 Regularization
4 Bound-Constrained Lagrangian method (BCL)
5 Computational results
6 Contributions and future work
Christopher Maes and Michael Saunders QPBLUR: A Regularized Active-Set Method for Convex QP 1 / 32
QPBLUR overview
QPBLUR overview
Convex Quadratic Program (H R
nn
, A R
mn
, H _ 0)
minimize
x
c
T
x +
1
2
x
T
Hx
subject to Ax = b, x u
H
M
A
T
M
A
M
A
M
= cols of A corresponding to Moving variables
QPBLUR overview
Convex Quadratic Program (H R
nn
, A R
mn
, H _ 0)
minimize
x, y
c
T
x +
1
2
x
T
Hx +

2
|x|
2
2
+

2
|y|
2
2
subject to Ax +y = b, x u
H
M
+I A
T
M
A
M
I
Regularization makes KKT system nonsingular
We use augmented Lagrangian to remove , y
References
Regularization for LP, QP
PDQ1 (S 1996), OSL (S, Tomlin 1996), PDCO (S 1998 . . . )
HOPDM (Altman, Gondzio 1999)
Friedlander and Orban 2012
Greif, Moulding and Orban 2012
Augmented Lagrangian methods
LANCELOT (Conn, Gould, Toint 1992)
Optimal QP algorithms (Dostal 2009)
QP bibliography and forthcoming book
ftp://ftp.numerical.rl.ac.uk/pub/qpbook/qpbook.bib
Computational Quadratic Programming (Gould, Toint 2012)
References
Hanh Huynh (QPBLU)
A Large-scale Quadratic Programming Solver Based on Block-LU
Updates of the KKT system
SCCM, Stanford University, Sep 2008
Christopher Maes (QPBLUR)
A Regularized Active-set Method for Sparse Convex Quadratic
Programming
ICME, Stanford University, Nov 2010
Elizabeth Wong (icQP)
Active-Set Methods for Quadratic Programming
Dept of Mathematics, UC San Diego, Jun 2011
Active-set methods for quadratic
programming
Nullspace method (SQOPT)
SQOPT: a nullspace (reduced-gradient) method
minimize c
T
x +
1
2
x
T
Hx subject to Ax = b, x u
moving variables nonmoving variables
AP = B S N

degrees of freedom
Nullspace method (SQOPT)
SQOPT: a nullspace (reduced-gradient) method
minimize c
T
x +
1
2
x
T
Hx subject to Ax = b, x u
moving variables nonmoving variables
AP = B S N

degrees of freedom
Limitations of SQOPT
All active-set methods solve for a search direction in the moving
variables M

H
M
A
T
M
A
M
x
M
y
r
1
r
2
Reduced-gradient method uses a specic ordering (Gill et al. 1990):

A
M
=
B S
H
BB
B
T
H
BS
B S
H
SB
S
T
H
SS
Reduced Hessian is the Schur complement of blue block:

Z
T
M
H
M
Z
M
= H
SS
(. . . )(. . . )
1
(. . . )
T
Best when degrees of freedom small (say < 2000)
Likely to be dense Need to work with original KKT system
variables M

H
M
A
T
M
A
M
x
M
y
r
1
r
2

A
M
=
B S
H
BB
B
T
H
BS
B S
H
SB
S
T
H
SS

Z
T
M
H
M
Z
M
= H
SS
(. . . )(. . . )
1
(. . . )
T
variables M

H
M
A
T
M
A
M
x
M
y
r
1
r
2

A
M
=
B S
H
BB
B
T
H
BS
B S
H
SB
S
T
H
SS

Z
T
M
H
M
Z
M
= H
SS
(. . . )(. . . )
1
(. . . )
T
Fullspace method (QPBLU)
QPBLU uses block-LU updates to the KKT factors (Huynh 2008)
K
0
=
H
0
A
T
0
A
0
= L
0
D
0
L
0
T
or L
0
U
0
To change moving variables, work with bordered system:
K
0
V
V
T
D
L
0
Z
T
I
U
0
Y
C
Inertia-controlling method of (Gill 2007) keeps K

0
nonsingular
Quasi-Newton updates to H
0
handled same way
Y , Z sparse, C dense but small ( no. of updates to K
0
)
L
0
, U
0
from a sparse direct solver
K
0
=
H
0
A
T
0
A
0
= L
0
D
0
L
0
T
or L
0
U
0
K
0
V
V
T
D
L
0
Z
T
I
U
0
Y
C

0
nonsingular
0
handled same way
0
)
L
0
, U
0
K
0
=
H
0
A
T
0
A
0
= L
0
D
0
L
0
T
or L
0
U
0
K
0
V
V
T
D
L
0
Z
T
I
U
0
Y
C

0
nonsingular
0
handled same way
0
)
L
0
, U
0
Limitations of QPBLU
Theoretically, inertia-controlling method ensures K
0
nonsingular
Singular (or nearly singular) K
0
is a diculty in practice
Must detect singularity (need rank-revealing factorization)
LUSOL, MA48, MA27, MA57 have threshold rook pivoting
but tight threshold dense factors
KKT repair complicated (and costly)
Regularization
Primal and dual regularization
For convex QP, small , > 0 nonsingular KKT systems:
H
M
+I A
T
M
A
M
I
Primal regularization
minimize
x
(x) +
1
2
|x|
2
2
subject to Ax = b, x u
Under certain conditions, optimal x unaltered for

(Friedlander and Tseng 2007)

Dual regularization
minimize
x, y
(x) +
1
2
|y|
2
2
subject to Ax +y = b, x u
Regularization in interior methods for LP and QP
Fixed regularization
PDQ1 (S 1996), OSL (S & Tomlin 1996), PDCO (S 2002 . . . )
minimize
x, y
c
T
x +
1
2
|x|
2
+
1
2
|y|
2
Ax +y = b, x u
Indenite LDL
T
on KKT is stable if , suciently large
Dynamic regularization
HOPDM (Altman and Gondzio 1999)
Smaller perturbation via dynamic proximal point terms:
1
2
(x x
k
)
T
R
p
(x x
k
),
1
2
(y y
k
)
T
R
d
(y x
y
)
Regularization in interior methods for LP and QP
Fixed regularization
PDQ1 (S 1996), OSL (S & Tomlin 1996), PDCO (S 2002 . . . )
minimize
x, y
c
T
x +
1
2
|x|
2
+
1
2
|y|
2
Ax +y = b, x u
Indenite LDL
T
on KKT is stable if , suciently large
Dynamic regularization
HOPDM (Altman and Gondzio 1999)
Smaller perturbation via dynamic proximal point terms:
1
2
(x x
k
)
T
R
p
(x x
k
),
1
2
(y y
k
)
T
R
d
(y x
y
)
QPBLUR version 1
Sequence of regularized QPs with
k
,
k
0
minimize
x, y
c
T
x +
1
2
x
T
Hx +
1
2
k
|x|
2
2
+
1
2
k
|y|
2
2
subject to Ax +
k
y = b, x u
KKT systems
H
M
+
k
I A
T
M
A
M

k
I
x
M
y
g
M
+A
T
M
y
0
QPs strictly convex

Always feasible (no Phase 1)
KKTs nonsingular for any set M (any A
M
)
Use any sparse LU or LDL
T
solver (black-box)
Use QPBLUs block-LU updates without change
Bound-Constrained Lagrangian method
(BCL)
LANCELOT
A BCL method for constrained NLP (Conn, Gould, Toint 1992)
minimize (x) subject to c(x) = 0, x u
Augmented Lagrangian (Hestenes 1969, Powell 1969, Bertsekas 1982)
/(x, y, ) = (x) y
T
c(x) +
1
2
|c(x)|
2
2
Subproblem: minimize /(x, y, ) st x u
Solve to get x (optimality tol 0)
If |c( x)| < , update y (feasibility tol 0)
else increase
Repeat
BCL method keeps <
LANCELOT
/(x, y, ) = (x) y
T
c(x) +
1
2
|c(x)|
2
2
else increase
Repeat
BCL method keeps <
LANCELOT
/(x, y, ) = (x) y
T
c(x) +
1
2
|c(x)|
2
2
else increase
Repeat
BCL method keeps <
QPBLUR version 2: Regularized BCL for QP
Sequence of regularized BCL subproblems (, y, changing)
minimize
x, r
c
T
x +
1
2
x
T
Hx +
1
2
|x|
2
2
+ y
T
r +
1
2
|r|
2
2
subject to Ax +r = b, x u
Regularized BCL method
Solve subproblem to get x, r, z (optimality tol
)
If | r| < , update y y + r (feasibility tol
)
else increase
Stop if | r|
and
( x) A
T
y z
Repeat (
)
QPBLUR version 2: Regularized BCL for QP
Sequence of regularized BCL subproblems (, y, changing)
minimize
x, r
c
T
x +
1
2
x
T
Hx +
1
2
|x|
2
2
+ y
T
r +
1
2
|r|
2
2
Regularized BCL method
Solve subproblem to get x, r, z (optimality tol
)
If | r| < , update y y + r (feasibility tol
)
else increase
Stop if | r|
and
( x) A
T
y z
Repeat (
)
Active-set method for BCL subproblem
Larger KKT system
H
M
+I A
T
M
I I
A
M
I
x
M
r
y
g
M
+A
T
M
y
y r +y
0
Eliminate r
H
M
+I A
T
M
A
M

1
x
M
y
g
M
+A
T
M
y
1
( y y) +r
Same KKT matrix as before (1/ ), but dierent rhs

Start from any active set (any submatrix A
M
)
Any sparse LU or LDL
T
linear solver
Block-LU updates without change
QPBLUR software
Matlab and Fortran 95 versions
bclsolve: Outer BCL algorithm
regularqp: Regularized BCL subproblem solver
May be used as bound-constrained LS solver
(avoids forming A
T
A; a sparse version of LSSOL)
Block-LU updates and sparse linear solver interface (Hunyh 2008)
LUSOL, MA57, PARDISO (parallel), SuperLU, UMFPACK
Computational results
QPs with many degrees of freedom
CUTEr (Constraint and Unconstrained Test Environment revisited)
20 convex QPs with 1000 or more degrees of freedom
Compare QPBLUR to SQOPT
10
3
10
4
0
2
4
6
8
10
12
14
16
18
20
p
#

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p

n
nS
0
10
20
30
40
50
60
70
80
90
100
%

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p
Problem A H m n dof SQOPT QPBLUR
AUG2DC 10000 20200 10200 2024(10622) 0.5( 3)
AUG2DCQP 10000 20200 9994 2283(14296) 236(10441)
AUG3DCQP 10000 20200 17677 3537(22071) 391(11554)
CVXQP2 10000 20200 2186 127( 8770) 692( 7714)
DTOC3 2998 4499 1499 9.2( 1830) 0.1( 2)
MOSARQP2 700 2500 1640 6.2( 2610) 3.2( 878)
STCQP2 4095 8193 3970 180( 8080) 6.9( 132)
CPU seconds (# of itns)
Maros and Meszaros convex QPs
Test set of 138 convex quadratic programs (1999)
Created to test interior-point QP solver BPMPD
Includes reference optimal objective value
Most problems have only a few degrees of freedom
10
0
10
1
10
2
10
3
10
4
0
10
20
30
40
50
60
70
80
90
100
110
120
130
p
#

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p

n
nS
0
10
20
30
40
50
60
70
80
90
100
%

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p
Excluded 8 problems (CUTEr errors, disastrous ll-in)
QPBLUR solves 128/130 problems
Plot of (
r
,
r
):
r
=
Axs
1+(x,s)
r
=
[
Q
[
1+
[
B
[
10
16
10
15
10
14
10
13
10
12
10
11
10
10
10
9
10
10
10
9
10
8
10
7
10
6
10
5
10
4
10
3
10
2
10
1
10
0
Relative (reference) objective and infeasibility
Primal infeasibility
O
b
j
e
c
t
i
v
e

r
e
f
e
r
e
n
c
e
QPBLUR solves 128/130 problems
QPBLUR versus SQOPT (time)
10
0
10
1
10
2
10
3
10
4
0
10
20
30
40
50
60
70
80
90
100
x
P
e
r
c
e
n
t
a
g
e

o
f

p
r
o
b
l
e
m
s

w
i
t
h
i
n

a

f
a
c
t
o
r

x

o
f

t
h
e

b
e
s
t

QPBLUR
SQOPT
Comparison with LANCELOT on QPs
LANCELOT solves the NLP
minimize
x
(x)
subject to c(x) = 0, x u
by solving BCL subproblems
minimize
x
(x) y
T
k
c(x) +
1
2
k
|c(x)|
2
2
subject to x u
LANCELOT uses SBMIN subproblem solver:
trust-region with gradient-projection method
CG with band preconditioner (MA57 optional)
QPBLUR uses the same outer algorithm (BCL)
adjusting primal regularization each BCL iteration
Comparison with LANCELOT on QPs
20 convex CUTEr QPs with many degrees of freedom
LANCELOT option quadratic-problem YES
QPBLUR versus LANCELOT (time)
10
0
10
1
10
2
10
3
0
10
20
30
40
50
60
70
80
90
100
Performance profile (CPU time) on 19 CUTEr QPs with many degrees of freedom

QPBLUR
LANCELOT
QPBLUR inside SNOPT
SNOPTs SQP method for NLPs (using rst derivatives)
minimize
x
(x) subject to
x
c(x)
Ax
u
QP subproblems
minimize
x
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
)
subject to linearized constraints + bounds
Warm start QPBLUR with (x, y) and active set from previous QP
Block-LU KKT updates handle quasi-Newton H
k
= G
T
k
G
k
as well as active-set changes
If QP infeasible, revert to SQOPT (elastic bounds on linearized
constraints)
QPBLUR inside SNOPT
minimize
x
(x) subject to
x
c(x)
Ax
u
QP subproblems
minimize
x
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
)
k
= G
T
k
G
k
constraints)
QPBLUR inside SNOPT
minimize
x
(x) subject to
x
c(x)
Ax
u
QP subproblems
minimize
x
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
)
k
= G
T
k
G
k
constraints)
QPBLUR inside SNOPT
minimize
x
(x) subject to
x
c(x)
Ax
u
QP subproblems
minimize
x
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
)
k
= G
T
k
G
k
constraints)
QPBLUR inside SNOPT
minimize
x
(x) subject to
x
c(x)
Ax
u
QP subproblems
minimize
x
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
)
k
= G
T
k
G
k
constraints)
Nonlinear CUTEr problems
92 problems with 2000 or more degrees of freedom (m n)
10
3
10
4
0
10
20
30
40
50
60
70
80
90
p
#

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p

n
nS
0
10
20
30
40
50
60
70
80
90
100
%

o
f

p
r
o
b
l
e
m
s

l
a
r
g
e
r

t
h
a
n

p
QPBLUR using UMFPACK
SNOPT-QPBLUR versus SNOPT-SQOPT (time)
10 20 30 40 50 60 70 80
0
10
20
30
40
50
60
70
80
90
100
x
%

o
f

p
r
o
b
l
e
m
s

w
i
t
h

a

f
a
c
t
o
r

x

o
f

t
h
e

b
e
s
t
Performance profile (time) for 92 CUTEr problems with 2000 or more superbasics

QPBLUR
SQOPT
Functions (x), c(x), , c
i
(x) can be expensive
SNOPT-QPBLUR versus SNOPT-SQOPT (functions)
1 2 3 4 5 6 7 8 9 10
0
10
20
30
40
50
60
70
80
90
100
x
%

o
f

p
r
o
b
l
e
m
s

w
i
t
h
i
n

a

f
a
c
t
o
r

x

o
f

t
h
e

b
e
s
t
Performance profile (evaluations) for 92 CUTEr problems with 2000 or more superbasics

QPBLUR
SQOPT
JANNSON3 problem
minimize
1
2
x
4
1
+
1
2
x
2
2
+ (1 x
2
1
) +
2n
i=1
(x
i
1)
2
+ d
1
x
1
+ d
2
x
2
x
2
1
x
2
d
1
x
1
d
2
x
2
subject to
2n
i=1
x
i
1 = 0,
2n
i=1
x
2
1
0.75 0
(x
2
)
T
x
1
+ (x
1
)
T
x
2
(x
1
)
T
x
2
1/(5n) 0
(x
2
)
T
x
1
+ (x
1
)
T
x
2
(x
1
)
T
x
2
1/(5n) 0
1 x
i
1, i = 1, . . . , 2n
20000 variables, 3 nonlinear constraints, 1 linear constraint + bounds
19999 degrees of freedom at solution
SNOPT-QPBLUR solved the problem in
8 major iterations
2 or 3 BCL iterations per major
1 QPBLUR iteration per BCL subproblem
10 seconds
Contributions and future work
Contributions
Active-set method + KKT systems allows many degrees of
freedom
Block-LU updates allow any black-box LU (preferably with
separate L and U)
Regularization ensures nonsingular KKT systems
BCL algorithm (sequence of regularized QP subproblems)
moderates the perturbation to the original problem
QPBLUR takes full advantage of convexity to permit a
simplied algorithm (for each QP subproblem)
No need for Phase 1
No need to control inertia (no KKT repair)
No danger of cycling in the presence of degeneracy
(trivial step-length procedure, bounds satised exactly)
Can warm start from any point and any active set
Contributions
Active-set method + KKT systems allows many degrees of
freedom
Block-LU updates allow any black-box LU (preferably with
separate L and U)
Regularization ensures nonsingular KKT systems
BCL algorithm (sequence of regularized QP subproblems)
moderates the perturbation to the original problem
QPBLUR takes full advantage of convexity to permit a
simplied algorithm (for each QP subproblem)
No need for Phase 1
No need to control inertia (no KKT repair)
No danger of cycling in the presence of degeneracy
(trivial step-length procedure, bounds satised exactly)
Can warm start from any point and any active set
Future work (SNOPT-QPBLUR integration)
Handle elastic mode without reverting to SQOPT
minimize
x, r
(x) + |r|
1
subject to
x
c(x) +r
Ax
u
minimize
x, s, r
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
) + |r|
1
subject to c
k
+J
k
(x x
k
) s +r = 0

x
s
Ax
u
Use SQOPT when dof small, switch to QPBLUR (or icQP!)
Make SNOPT aware of primal regularization
minimize
x, r
(x) + |r|
2
2
subject to
x
c(x) +r
Ax
u
minimize
x, s, r
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
) + |r|
2
2
subject to c
k
+J
k
(x x
k
) s +r = 0

x
s
Ax
u
minimize
x, r
(x) + |r|
2
2
subject to
x
c(x) +r
Ax
u
minimize
x, s, r
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
) + |r|
2
2
subject to c
k
+J
k
(x x
k
) s +r = 0

x
s
Ax
u
minimize
x, r
(x) + |x|
2
2
subject to
x
c(x) +r
Ax
u
minimize
x, s, r
k
+g
T
k
(x x
k
) +
1
2
(x x
k
)
T
H
k
(x x
k
) + |x|
2
2
subject to c
k
+J
k
(x x
k
) s +r = 0

x
s
Ax
u
Future work (QPBLUR)
Relax stopping criterion based on
dual optimality condition of original QP?
Detailed sparse solver performance study:
LUSOL, MA57, PARDISO, SuperLU, UMFPACK, MUMPS
Block-LDL
T
updates (take advantage of symmetry)
Develop gradient projection subproblem solver
(allow for multiple changes to the active-set)
References
Hanh Huynh (QPBLU)
A Large-scale Quadratic Programming Solver Based on Block-LU Updates of
the KKT system
A Regularized Active-set Method for Sparse Convex Quadratic Programming
Philip Gill and Elizabeth Wong
SQIC = SQOPT + icQP
Reduced-gradient method or Block-LU updates of KKT
Convex and nonconvex QP
Aiming to handle 2nd derivatives in SNOPT
One day: SQICr = SQOPT + icQP + QPBLUR??
Funding: COMSOL, ONR, ARL, DOE
References
Hanh Huynh (QPBLU)
the KKT system
SQIC = SQOPT + icQP
References
Hanh Huynh (QPBLU)
the KKT system
SQIC = SQOPT + icQP
References
Hanh Huynh (QPBLU)
the KKT system
SQIC = SQOPT + icQP
Extra slides
28 Infeasible problems
Infeasible LP test problems (Netlib lpi xxx)
Results from April 2009 (Ban saddle point systems meeting)
0 5 10 15 20 25 30
0
0.5
1
1.5
2
2.5
3
3.5
4
x 10
4
Problem
I
t
e
r
a
t
i
o
n
s
10
12
1
Quickly changing the active-set
Typical active-set methods add/delete a constraint per iteration.
k
0
constraints active at x
0
and k
constraints active at x
Require at least [k
0
k
[ iterations
Gradient projection on bound constrained problems
x
k+1
= project x
k
(x
k
) onto x : x u
Dene active-set via constraints active at x
k+1
Optimize in subspace of free variables
Allows for large changes to the active-set
Apply Gradient projection to BCL subproblem: minimize
xu
/(x, y, )
Solve same regularized KKT system to accurately optimize in
subspace
If active-set changes dramatically refactor KKT; otherwise use
BLU updates
Regularized QP subproblem
Bound-constrained subproblem
minimize
x
c
T
x +
1
2
x
T
H
x + y
T
(b Ax) +
1
2
1/2
(b Ax)
2
2
subject to x u
with H
~ 0, D
~ 0 and diagonal
Linearly constrained subproblem
minimize
x, r
c
T
x +
1
2
x
T
H
x + y
T
r +
1
2
r
T
D
r
Prefer to work with constrained problem for numerical reasons
Can always satisfy Ax +r = b, x u
Bound-constrained subproblem
minimize
x
c
T
x +
1
2
x
T
H
x + y
T
(b Ax) +
1
2
1/2
(b Ax)
2
2
subject to x u
with H
~ 0, D
~ 0 and diagonal
Linearly constrained subproblem
minimize
x, r
c
T
x +
1
2
x
T
H
x + y
T
r +
1
2
r
T
D
r
Prefer to work with constrained problem for numerical reasons
Can always satisfy Ax +r = b, x u
Active-set method for QP subproblem
Yields larger KKT system
H
M
A
T
M
D
I
A
M
I
x
M
r
y
g
M
+A
T
M
y
y D
r +y
0
Eliminate r and we have
H
M
A
T
M
A
M
D
1
x
M
y
g
M
+A
T
M
y
D
1
( y y) +r
KKT systems always nonsingular

Can start from any set M (any matrix A
M
)
Can use any sparse LU or LDL
T
factorization
Solver for sparse least squares problems
Method for sparse least squares problems
that avoids forming H = A
T
A
Sparse version of LSSOL
Tikhonov regularized bound-constrained least squares
minimize
x
|b Ax|
2
2
+ |x|
2
2
subject to x u
minimize
x, r
1
2
x
T
x +
1
2
r
T
r
Can solve weighted LS problems with covariance matrix W ~ 0
T
A
minimize
x
|b Ax|
2
2
+ |x|
2
2
subject to x u
minimize
x, r
1
2
x
T
x +
1
2
r
T
r
T
A
minimize
x
|b Ax|
2
2
+ |x|
2
2
subject to x u
minimize
x, r
1
2
x
T
x +
1
2
r
T
r

12ismp Qpblur

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

12ismp Qpblur

Uploaded by

Copyright:

Available Formats

QPBLUR: A Regularized Active-Set Method for

Sparse Convex Quadratic Programming

Reduced-gradient method uses a specic ordering (Gill et al. 1990):

Reduced Hessian is the Schur complement of blue block:

Reduced-gradient method uses a specic ordering (Gill et al. 1990):

Reduced Hessian is the Schur complement of blue block:

Reduced-gradient method uses a specic ordering (Gill et al. 1990):

Reduced Hessian is the Schur complement of blue block:

Inertia-controlling method of (Gill 2007) keeps K

Inertia-controlling method of (Gill 2007) keeps K

Inertia-controlling method of (Gill 2007) keeps K

(Friedlander and Tseng 2007)

QPs strictly convex

Same KKT matrix as before (1/ ), but dierent rhs

Eliminate r and we have

KKT systems always nonsingular

You might also like