Module III·Article II·~4 min read

Proximal Algorithms and Operator Splitting

First-Order Algorithms

Reading tools · save, download, print, audio

Turn this article into a podcast

Pick voices, format, length — AI generates the audio

Motivation: How to Handle Nondifferentiable Terms?

LASSO problem: min (1/2)‖Ax−b‖² + λ‖x‖₁. The first term is smooth (can be differentiated), the second is not (∣x∣1|x|_1 is nondifferentiable at zero). Gradient descent cannot be applied directly. The subgradient method is too slow (O(1/k)O(1/\sqrt{k})). Proximal algorithms solve this problem elegantly: they “split” the function into smooth and nonsmooth parts and handle each differently.

Proximal Operator

Definition: prox⁡τf(x)=arg⁡min⁡y{f(y)+12τ∥y−x∥2}\operatorname{prox}_{\tau f}(x) = \arg\min_{y} \left\{ f(y) + \frac{1}{2\tau} \|y - x\|^2 \right\}

Meaning of each symbol:

  • τ>0\tau > 0 — step size
  • f(y)f(y) — “minimize” ff
  • 12τ∥y−x∥2\frac{1}{2\tau}\|y - x\|^2 — “don’t move far from xx”
  • arg⁡min⁡\arg\min — returns the minimizer yy

This is a “soft step toward the minimum of ff.” When τ→0\tau \to 0: prox ≈x\approx x (do not move). When τ→∞\tau \to \infty: prox →arg⁡min⁡f\to \arg\min f (go straight to the minimum).

Key examples:

  1. f(x)=∥x∥1f(x) = \|x\|_1: prox⁡τf(x)=sign⁡(x)⋅max⁡(∣x∣−τ,0)\operatorname{prox}_{\tau f}(x) = \operatorname{sign}(x) \cdot \max(|x| - \tau, 0) — soft thresholding

    Meaning: components with ∣xi∣≤τ|x_i| \leq \tau are set to zero, the rest are shifted toward zero by τ\tau.

  2. f(x)=δC(x)f(x) = \delta_C(x) — indicator of a convex CC: prox⁡δC(x)=PC(x)\operatorname{prox}_{\delta_C}(x) = P_C(x) — projection onto CC

  3. f(X)=∥X∥∗f(X) = \|X\|_* (nuclear norm = sum of singular values): prox⁡τ∥⋅∥∗(X)=UΣ~VT\operatorname{prox}_{\tau\|\cdot\|_*}(X) = U\tilde{\Sigma}V^T, where X=UΣVTX = U\Sigma V^T (SVD), Σ~ii=max⁡(σi−τ,0)\tilde{\Sigma}_{ii} = \max(\sigma_i - \tau, 0) — soft thresholding for singular values.

Proximal Gradient Method (ISTA/FISTA)

For the problem min⁡F(x)=f(x)+g(x)\min F(x) = f(x) + g(x), where ff is smooth (LL-smooth), gg is convex (prox-friendly):

ISTA (Iterative Shrinkage-Thresholding Algorithm):

xk+1=prox⁡τg(xk−τ∇f(xk))x^{k+1} = \operatorname{prox}_{\tau g} (x^k - \tau \nabla f(x^k))

Steps: 1) Gradient step for ff 2) Proximal step for gg. Convergence: O(1/k)O(1/k).

FISTA = ISTA + Nesterov momentum:

yk+1=prox⁡τg(xk−τ∇f(xk))xk+1=yk+1+k−1k+2(yk+1−yk)y^{k+1} = \operatorname{prox}_{\tau g} (x^k - \tau \nabla f(x^k)) \\ x^{k+1} = y^{k+1} + \frac{k-1}{k+2} (y^{k+1} - y^k)

Convergence: O(1/k2)O(1/k^2) — optimal!

Complete Walkthrough of LASSO with FISTA

Problem: min⁡F(x)=12∥Ax−b∥2+λ∥x∥1\min F(x) = \frac{1}{2}\|Ax - b\|^2 + \lambda\|x\|_1

f(x)=12∥Ax−b∥2f(x) = \frac{1}{2}\|Ax-b\|^2, ∇f(x)=AT(Ax−b)\nabla f(x) = A^T(Ax-b), L=λmax⁡(ATA)L = \lambda_{\max}(A^TA)

g(x)=λ∥x∥1g(x) = \lambda\|x\|_1, prox⁡τg(z)=sign⁡(z)⋅max⁡(∣z∣−τλ,0)\operatorname{prox}_{\tau g}(z) = \operatorname{sign}(z) \cdot \max(|z| - \tau \lambda, 0)

FISTA iteration:

  1. Compute rk=Axk−br^k = Ax^k - b (residual)
  2. Gradient: ∇f(xk)=ATrk\nabla f(x^k) = A^T r^k
  3. Gradient step: zk+1=xk−(1/L)ATrkz^{k+1} = x^k - (1/L) A^T r^k
  4. Proximal: yk+1=sign⁡(zk+1)⋅max⁡(∣zk+1∣−λ/L,0)y^{k+1} = \operatorname{sign}(z^{k+1}) \cdot \max(|z^{k+1}| - \lambda/L, 0)
  5. Momentum: xk+1=yk+1+βk(yk+1−yk)x^{k+1} = y^{k+1} + \beta_k(y^{k+1} - y^k)

Numerical example: AA is a 50×10050 \times 100 matrix, x∗x^* is sparse (5 nonzero components). FISTA with λ=0.1\lambda = 0.1 achieves accuracy 10−610^{-6} in about 200 iterations. Without acceleration (ISTA) — in about 2000 iterations.

ADMM (Alternating Direction Method of Multipliers)

ADMM solves problems of the form: min⁡f(x)+g(z)\min f(x) + g(z) subject to Ax+Bz=cAx + Bz = c

ADMM Algorithm (iteration):

  1. x-step: xk+1=arg⁡min⁡x{f(x)+ρ2∥Ax+Bzk−c+uk∥2}x^{k+1} = \arg\min_x \left\{ f(x) + \frac{\rho}{2}\|Ax + Bz^k - c + u^k\|^2 \right\}
  2. z-step: zk+1=arg⁡min⁡z{g(z)+ρ2∥Axk+1+Bz−c+uk∥2}z^{k+1} = \arg\min_z \left\{ g(z) + \frac{\rho}{2}\|Ax^{k+1} + Bz - c + u^k\|^2 \right\}
  3. Dual step: uk+1=uk+Axk+1+Bzk+1−cu^{k+1} = u^k + Ax^{k+1} + Bz^{k+1} - c

Here ρ>0\rho > 0 is the penalty parameter, uu is the (scaled) dual variable.

Why ADMM is more powerful: it splits the problem into two subproblems — for xx and for zz — which are solved independently. If both subproblems have convenient proximal operators, the whole algorithm is very efficient.

Example: Lasso via ADMM

x-step: ordinary ridge regression (closed-form solution via LDLT decomposition) z-step: soft thresholding

ADMM converges in O(1/k)O(1/k) and is highly parallelizable over data blocks.

Applications

Distributed optimization: with nn machines, each stores its own portion of the data. ADMM enables solving the global problem without gathering all the data in one place — only exchange of “dual” variables.

Image processing: Total Variation (TV) denoising: min⁡12∥u−f∥2+λTV(u)\min \frac{1}{2}\|u-f\|^2 + \lambda TV(u). TV norm is nonsmooth, but has a convenient proximal. FISTA and ADMM are standard methods.

Proximal Operators for Typical Regularizers

Besides soft thresholding for L1 and projection for the indicator, important proximal operators are:

  • For L2-regularization τ∥x∥2\tau\|x\|^2: prox⁡(x)=x/(1+2τ)\operatorname{prox}(x) = x / (1 + 2\tau) — simple scaling
  • For group LASSO τ∥x∥2,1\tau\|x\|_{2,1}: group soft thresholding, zeroing out entire groups of coordinates
  • For nuclear norm ∥X∥∗\|X\|_* (sum of singular values of a matrix): SVD decomposition X=UΣVTX = U\Sigma V^T, then soft threshold the singular values and reassemble
  • For the simplex indicator: projection onto the simplex via sorting — O(nlog⁡n)O(n \log n)

Applications of Operator Splitting

Douglas-Rachford splitting and ADMM form the foundation of modern convex optimization systems: TFOCS, CVXPY, COSMO. They are especially effective for problems with a separable structure, where the objective function splits into simple terms with easily computable proximal operators. ADMM is actively used in distributed optimization: each compute node solves a local subproblem via a prox, then synchronizes through dual variables. This allows scaling training to thousands of machines.

§ Act · what next