Back To Proximal Algorithms Home.

Table of Contents

1. Lasso
2. Matrix decomposition
3. Multi-period portfolio optimization
4. Stochastic optimization

We can always use the following Matlab code to calculate the proximal operator:

  function x = prox_f_cvx(v, lambda, f, A)
  % For testing purposes.
      [n T] = size(v);
      cvx_begin quiet
          variable x(n,T)
          minimize(f(x,A) + (1/(2*lambda))*square_pos(norm(x - v,'fro')))
          subject to
              x <= 1;
              x >= -1;
      cvx_end
  end

7.1 Lasso

Lasso is short of Least Absoluate Shrinkage and Selection Operator. The problem is :

7.1.1 Proximal gradient method

It carries out variable selection (by the l1 heuristic), and model fitting (by the least square). Consider the splitting :

With the gradient and proximal operator:

The proximal gradient method will be :

The proximal gradient method is also called ISTA (iterative shrinkage-thresholding algorithm), while the accelerated version is known as FISTA (fast ISTA), the fast version is basicly adding a momentum. As the proximal gradient method can be interpreted as seperately optimize f and g.

• We can further accelerate the algorithm by parallex matrix-vector multiplication.
• Or even use the Gram matrix as mentioned in Chapter “Evaluating Proximal Operator”.
• If we want solution for multiply $\gamma$, we can use the solution of the largest $\gamma$ as warm starting.

7.1.2 ADMM

f is quadratic function, we can use the tricks as before:

• Reuse of factorization.
• Warm start with previous gradient, if use an iterative method.
• if n much smaller, we can precompute the Gram matrix.

7.1.3 Test

Here we should pay attention to the update of x. With $A\in \mathbb{R}^{m \times n}$, if m larger than n, we should use the expression upper. While in the case when m is smaller than n, we can reform the process to accelerate:

Using this in the original equation we have:

we will have the corresponding code in matlab as :

   L = chol(speye(m) + lambda*(A*A'), 'lower');
   L = sparse(L); U = sparse(L');
   q = Atb + rho*(z - u);
   x = lambda*(q - lambda*(A'*(U \ ( L \ (A*q) ))));

The original codes could be found here, or in my github page. The result run times are :

• CVX time elapsed: 25.06 seconds.
• Proximal gradient time elapsed: 0.35 seconds.
• Fast prox gradient time elapsed: 0.17 seconds.
• ADMM time elapsed: 0.04 seconds.

7.2 Matrix decomposition

The problem is to decompose matrix A into a sum of components $X_{i}$

The function $\phi(X)$ can usually be seen as ‘penalties’, to drive $X_{i}$ to have our objective properties.

• Squared Frobenius norm: \(\phi(X) = \|X\|_{F}^{2} = \sum_{i,j}X_{i,j}^{2}\), to encourage X to be small.
• Entrywise l1 norm: \(\phi(X) = \|X\|_{1} = \sum_{i,j}\mid X_{i,j}\mid\), to encourage X to be sparse.
• Sum-column-norm: \(\phi(X) = \sum_{j}\|x_{j}\|_{2}\), to encourage column sparsity. (can be interpreted as group lasso regulization)
• Elementwise constraints: $X_{i,j}\in C_{i,j}$, for instant, we want to fixed some entries (fixed sparse pattern).
• Separable convex function: $\phi(X) = \sum_{i=1}^{m}\sum_{j=1}^{n}\phi_{i,j}(X_{i,j})$. For instant, constrain the subblock of the matrix.
• Semidefinite cone constraint: $X \succeq 0$.
• Nuclear norm: $\phi(X) = |X|_{*} = tr(X^{T}X)$, encourage X to be low rank.

For an example, take $\phi_{1}$ be the Squred Frobenius norm,$\phi_{2}$ be the entrywise l1 norm, $\phi_{3}$ be the Nuclear norm, the problem can be reformed into:

So we will decompose A into a sum of a small matrix $X_{1}$, a sparse matrix $X_{2}$, and a low rank matrix $X_{3}$.

7.2.1 ADMM

Consider the splitting:

where $X = (X_{1}, …, X_{N})$, and :

f is to evulate the objective function, and g is to project onto $\mathcal{C}$: the feasible set. The projection is fairly simple, which is similar to a translation of centroid:

So the final algorithms looks as follows:

7.2.2 Test

Take the former example : $\phi_{1}$ be the Squred Frobenius norm,$\phi_{2}$ be the entrywise l1 norm, $\phi_{3}$ be the Nuclear norm. Note $B=\bar X^{k} - (1/N)A + U^{k}$ So our updates of X is:

Corresponding codes are:

  X_1 = (1/(1+lambda))*(X_1 - B);
  X_2 = prox_l1(X_2 - B, lambda*g2);
  X_3 = prox_matrix(X_3 - B, lambda*g3, @prox_l1);

where prox_matrix is defined as :

  function [ Vout ] = prox_matrix(X, eta, prox_l1)
    [U,S,V] = svd(X);    %  X= U*S*V'
    Spos = prox_l1(S, eta);
    Vout = U * Spos * V';
  end

We get the output :

  CVX (vs true):
  |V| = 0.31;  |X_1| = 26.23
  nnz(S) = 49; nnz(X_2) = 53
  rank(L) = 4; rank(X_3) = 4

  ADMM (vs true):
  |V| = 0.31;  |X_1| = 26.18
  nnz(S) = 49; nnz(X_2) = 52
  rank(L) = 4; rank(X_3) = 4

  ADMM vs CVX solutions (in Frobenius norm):
  X_1: 3.59e-01; X_2: 6.15e-01; X_3: 5.30e-01

7.3 Multi-period portfolio optimization

Optimize the sum of a risk-adjusted negative return f and a transaction cost g, for a period of portfolio investment.

With the constraints that indicate any short position (x>0), and limit the sum o f liquid.

Assume that $f_{t}$ and $g_{t}$ are closed proper convex and that $f_{t}$ are fully separable, i.e. the transaction cost in any period is the sum of the transaction costs for each asset. Let $X = [x_{1},…,x_{T}] \in \mathbb{R}^{n \times T}$ donate the matrix of the portfoilo sequence.

Consider the splitting:

Where f is separable across the columns of X and g is separable across the rows of X.

Recall the update formula of ADMM :

The update of each column of x will be solved using a CVX solver:

The update of each rows of z will be solving the following problem:

Code could be found in Stanford page, or in my github. The following image shows the time series of asset holdings.

In this case, ADMM method converges to the same optimal point as CVX solver, however it is much slower.

7.4 Stochastic optimization

Optimize the stochastic optimization, with $\pi$ be a probability distribution, and $f_{(k)}$ is the closed proper convex objective function for scenario k.

Reform the problem into consensus form by introducing a consensus constraint.

To use ADMM method, the function f take the form of the upper objective function, while g take the form of a pojection onto the feasible set, by take the average of the local solutions $x^{(k)}$.

Example code could be found here. ADMM and CVX method solved in similar amount of time, while we should notice that in ADMM, the updates of variables could be processed in parallex.

Back To Proximal Algorithms Home.