of 1 /1
Diﬀerentiable Convex Optimization Layers Akshay Agrawal, Brandon Amos, Shane Barratt, Stephen Boyd, Steven Diamond, and J. Zico Kolter Neural Information Processing Systems, 2019 = argmin + ; subject to (; ) ≤ 0 ; =0 Convex optimization layers A convex optimization problem can be viewed as a function mapping a pa- rameter θ R p to a solution x ? (θ ); this map is sometimes diﬀerentiable. Prior work has shown how to diﬀerentiate through convex cone programs. We show how to diﬀerentiate through high-level descriptions of convex opti- mization programs, speciﬁed in a domain-speciﬁc language for convex opti- mization. We implement our method in CVXPY, TensorFlow 2.0, and PyTorch. Domain-speciﬁc languages (DSLs) DSLs for convex optimization make it easy to specify, solve convex problems Modern DSLs (CVXPY, CVXR, Convex.jl, CVX) based on disciplined convex programming (DCP) . DCP is a library of functions (atoms) with known curvature and monotonicity, and a composition rule for combining them. p 0 DSL Front End Analyzer LP QP SDP CFP Back Ends S i S 2 S 1 ... ... S k Rewriting System p n Solver Solution map We represent a parametrized disciplined convex program as the composition R s C : The canonicalizer C converts a DCP-compliant program to the problem data for a convex cone program The solver s solves a convex cone program The retriever R retrieves a solution for the original program We mildly restrict DCP to ensure that C and R are aﬃne. This means we can diﬀerentiate through the DSL, without explicitly backpropagating through it. Disciplined parametrized programming We introduce disciplined parametrized programming (DPP). DPP programs have the form minimize f 0 (x, θ ) subject to f i (x, θ ) ˜ f i (x, θ ), i =1,...,m 1 , g i (x, θ )=˜ g i (x, θ ), i =1,...,m 2 , θ R p is a parameter, f i are convex, ˜ f i are concave g i and ˜ g i are aﬃne DPP is a subset of DCP that does parameter-dependent analysis: parameters are treated as aﬃne the product of a parameter-aﬃne and parameter-free expression is aﬃne DPP guarantees that C and R are aﬃne. Diﬀerentiation The adjoint of the derivative of a disciplined parametrized program is D T S (θ )= D T C (θ )D T s(A, b, c)D T Rx ? ). Because C and R are aﬃne, D T C and D T R are easy to compute. We use prior work to diﬀerentiate through s . cvxpylayers Available at www.github.com/cvxgrp/cvxpylayers. Specify a problem using CVXPY 1.1: 1 import cvxpy as cp 2 3 m, n = 20, 10 4 x = cp .Variable((n, 1)) 5 F = cp .Parameter((m, n)) 6 g = cp .Parameter((m, 1)) 7 lambd = cp .Parameter((1, 1), nonneg=True) 8 objective_fn = cp .norm(F @ x - g) + lambd * cp .norm(x) 9 constraints = [x >= 0] 10 problem = cp .Problem( cp .Minimize(objective_fn), constraints) 11 assert problem.is_dpp() Convert CVXPY problem to a PyTorch layer: 1 from cvxpylayers. torch import CvxpyLayer 2 3 layer = CvxpyLayer(problem, parameters=[F, g, lambd], variables=[x]) Diﬀerentiate: 1 import torch 2 3 F_t = torch .randn(m, n, requires_grad=True) 4 g_t = torch .randn(m, 1, requires_grad=True) 5 lambd_t = torch .rand(1, 1, requires_grad=True) 6 x_star , = layer(F_t, g_t, lambd_t) 7 x_star. sum ().backward() Experiments Figure 1: Gradients (black lines) of the logistic test loss with respect to the training data. Figure 2: Per-iteration cost while learn- ing an ADP policy for stochastic con- trol. References  A. Agrawal, S. Barratt, S. Boyd, E. Busseti, and W. Moursi. Diﬀerentiating through a cone program. In: Journal of Applied and Numerical Optimiza- tion 1.2 (2019), pp. 107–115.  M. Grant, S. Boyd, and Y. Ye. Disciplined convex programming. In: Global optimization. Springer, 2006, pp. 155–210.
• Author

others
• Category

## Documents

• view

4

0

Embed Size (px)

### Transcript of Di erentiable Convex Optimization Layers€¦ · • DSLs for convex optimization make it easy to...

• Differentiable Convex Optimization LayersAkshay Agrawal, Brandon Amos, Shane Barratt, Stephen Boyd, Steven Diamond, and J. Zico KolterNeural Information Processing Systems, 2019

𝑥⋆ 𝜃 = argmin+

𝑓 𝑥; 𝜃

subject to 𝑔(𝑥; 𝜃) ≤ 0ℎ 𝑥; 𝜃 = 0

Convex optimization layers

• A convex optimization problem can be viewed as a function mapping a pa-rameter θ ∈ Rp to a solution x?(θ); this map is sometimes differentiable.

• Prior work has shown how to differentiate through convex cone programs.

• We show how to differentiate through high-level descriptions of convex opti-mization programs, specified in a domain-specific language for convex opti-mization.

• We implement our method in CVXPY, TensorFlow 2.0, and PyTorch.

Domain-specific languages (DSLs)

• DSLs for convex optimization make it easy to specify, solve convex problems

• Modern DSLs (CVXPY, CVXR, Convex.jl, CVX) based on disciplined convexprogramming (DCP) .

• DCP is a library of functions (atoms) with known curvature and monotonicity,and a composition rule for combining them.

p0

DSL Front End Analyzer

LP

QP

SDP

CFP

Back Ends

Si

S2

S1

......

Sk

Rewriting System

pn

Solver

Solution map

We represent a parametrized disciplined convex program as the compositionR ◦ s ◦ C:

• The canonicalizer C converts a DCP-compliant program to the problem datafor a convex cone program

• The solver s solves a convex cone program

• The retriever R retrieves a solution for the original program

We mildly restrict DCP to ensure that C and R are affine. This means we candifferentiate through the DSL, without explicitly backpropagating through it.

Disciplined parametrized programming

We introduce disciplined parametrized programming (DPP). DPP programshave the form

minimize f0(x, θ)

subject to fi(x, θ) ≤ f̃i(x, θ), i = 1, . . . ,m1,gi(x, θ) = g̃i(x, θ), i = 1, . . . ,m2,

• θ ∈ Rp is a parameter,• fi are convex, f̃i are concave

• gi and g̃i are affine

DPP is a subset of DCP that does parameter-dependent analysis:

• parameters are treated as affine

• the product of a parameter-affine and parameter-free expression is affine

DPP guarantees that C and R are affine.

DifferentiationThe adjoint of the derivative of a disciplined parametrized program is

DTS(θ) = DTC(θ)DTs(A, b, c)DTR(x̃?).

Because C and R are affine, DTC and DTR are easy to compute. We use priorwork to differentiate through s .

cvxpylayers

Available at www.github.com/cvxgrp/cvxpylayers.

Specify a problem using CVXPY 1.1:

1 import cvxpy as cp

2

3 m, n = 20, 10

4 x = cp.Variable ((n, 1))

5 F = cp.Parameter ((m, n))

6 g = cp.Parameter ((m, 1))

7 lambd = cp.Parameter ((1, 1), nonneg=True)

8 objective_fn = cp.norm(F @ x - g) + lambd * cp.norm(x)

9 constraints = [x >= 0]

10 problem = cp.Problem(cp.Minimize(objective_fn), constraints)

11 assert problem.is_dpp ()

Convert CVXPY problem to a PyTorch layer:

1 from cvxpylayers.torch import CvxpyLayer

2

3 layer = CvxpyLayer(problem , parameters =[F, g, lambd], variables =[x])

Differentiate:

1 import torch

2

3 F_t = torch.randn(m, n, requires_grad=True)

4 g_t = torch.randn(m, 1, requires_grad=True)

5 lambd_t = torch.rand(1, 1, requires_grad=True)

6 x_star , = layer(F_t , g_t , lambd_t)

7 x_star.sum().backward ()

Experiments

8 6 4 2 0 2 4 6 88

6

4

2

0

2

4

6

8traintest

Figure 1: Gradients (black lines) of thelogistic test loss with respect to thetraining data.

0 20 40 60 80 100iteration

0.9

1.0

1.1

1.2

1.3

1.4

1.5

aver

age

cost

Figure 2: Per-iteration cost while learn-ing an ADP policy for stochastic con-trol.

References

 A. Agrawal, S. Barratt, S. Boyd, E. Busseti, and W. Moursi. Differentiatingthrough a cone program. In: Journal of Applied and Numerical Optimiza-tion 1.2 (2019), pp. 107–115.

 M. Grant, S. Boyd, and Y. Ye. Disciplined convex programming. In: Globaloptimization. Springer, 2006, pp. 155–210.