ADMM,ISTA,FISTA算法步骤详解,MATLAB代码,求解LASSO优化问题

ADMM,ISTA,FISTA算法步骤详解,MATLAB代码,求解LASSO优化问题

原创文章!转载需注明来源:©️ Sylvan Ding’s Blog ❤️

ADMM,ISTA,FISTA算法步骤详解,MATLAB代码,求解LASSO优化问题_第1张图片

实验目的

  • 了解 ADMM, ISTA, FISTA 算法的基本原理、收敛性和复杂度;
  • 使用上述三种算法,解决 LASSO 问题;
  • 分析三种算法的表现情况。

实验环境

MATLAB R2021a

文章目录

  • ADMM,ISTA,FISTA算法步骤详解,MATLAB代码,求解LASSO优化问题
    • 实验目的
    • 实验环境
    • 实验内容
      • LASSO Problem
      • ADMM
      • ISTA
      • FISTA
    • 算法描述
      • ADMM
      • [F]ISTA
    • 实验步骤
      • ADMM [6]
      • [F]ISTA [7]
      • 绘图
    • 结果分析
    • 参考文献

实验内容

ADMM 和 [F]ISTA 的收敛性证明在 [1] 和 [2] 中给出,ADMM 和 ISTA 的全局收敛速率(global convergence rate)为 O ( 1 / k ) O(1/k) O(1/k) [Eckstein and Bertsekas, 1990; Deng and Yin, 2012; He and Yuan, 2012],然而 FISTA 的全局收敛速率为 O ( 1 / k 2 ) O(1/k^2) O(1/k2)​ 。但是,[2] 得出了在某些情况下,ISTA 却比 FISTA 更快的结论,并给出了具体原因。

LASSO Problem

许多机器学习和数据拟合问题都可以看成是最小二乘问题,添加正则项从而避免过拟合。在许多应用中,使用 l 1 l1 l1-范数 作为正则项可以带来不错的泛化效果,所以我们求解含有 l 1 l1 l1-正则项 的线性最小二乘问题,也称为 LASSO 问题 [2],其一般形式为:(P)

min ⁡ x ∈ R n 1 2 ∥ A x − b ∥ 2 + λ ∥ x ∥ 1 . \min \limits _{x\in \mathbb{R} ^n} \frac{1}{2} \Vert Ax-b \Vert ^2 + \lambda \Vert x \Vert _1. xRnmin21Axb2+λx1.

其中, A ∈ R m × n A\in \mathbb{R} ^{m\times n} ARm×n 是一个行满秩矩阵, n > m n>m n>m b b b 是一个已知向量; λ > 0 \lambda >0 λ>0 是一标量; l 1 l1 l1-正则项 ∥ x ∥ 1 \Vert x \Vert _1 x1 会产生一稀疏解,在降低代价的同时,避免发生过拟合 [Tibshirani, 1996]。

在实验一和实验三中,分别使用了不同的正则项实现了信号的降噪,体现了 l 1 l1 l1-正则项 的另一个优势,就是相较于 l 2 l2 l2-正则项 来说, l 1 l1 l1-正则项 对边界值(outliers)不敏感,这一特点有利于图像降噪中对锐利边缘(sharp edges)的处理。

在实验三中,曾将(P)视为盒状约束(box-constrained)的二次优化问题,使用梯度投影法进行求解。本文要求使用 ADMM, ISTA, FISTA 这三种算法,求解 LASSO 问题。

ADMM

ADMM 算法(Alternating Direction Method of Multipliers)[Gabay, Mercier, Glowinski, Marrocco, 1976] 将原问题的变量 x x x 分解为两个变量 x x x z z z ,在最小二乘的损失函数里使用 x x x ,在 l 1 l1 l1-范数 的正则项里使用 z z z 。这样,外加一个等式约束,就可构造增广拉格朗日函数,进而分别求解两个变量的最优值,使得计算较为容易。

问题(P)等价于:

min ⁡ x 1 2 ∥ A x − b ∥ 2 + λ ∥ z ∥ 1 s . t . x − z = 0 \begin{array}{l} \min \limits _x & \frac{1}{2} \Vert Ax-b \Vert ^2 + \lambda \Vert z \Vert _1 \\ \mathrm{s.t.} & x-z=0 \end{array} xmins.t.21Axb2+λz1xz=0

构造增广拉格朗日函数(augmented Lagrangian) L ρ L_\rho Lρ

L ρ ( x , z , μ ) = f ( x ) + g ( z ) + μ T ( x − z ) + ρ 2 ∥ x − z ∥ 2 . L_\rho (x,z,\mu) = f(x)+g(z)+\mu ^T(x-z) + \frac{\rho }{2} \Vert x-z \Vert ^2. Lρ(x,z,μ)=f(x)+g(z)+μT(xz)+2ρxz2.

其中, f ( x ) = 1 2 ∥ A x − b ∥ 2 f(x)=\frac{1}{2} \Vert Ax-b \Vert ^2 f(x)=21Axb2 g ( z ) = λ ∥ z ∥ 1 g(z)=\lambda \Vert z \Vert _1 g(z)=λz1 ρ \rho ρ 是惩罚参数。

不难发现,最优化 x x x 时,是一个二次优化问题,而最优化 z z z 时,是一个软阈(soft-thresholding)问题,那么,ADMM 的迭代形式为:

x k + 1 : = ( A T A + ρ I ) − 1 ( A T b + ρ z k − μ k ) x . m i n i m i z a t i o n z k + 1 : = S λ / ρ ( x k + 1 + μ k / ρ ) z . m i n i m i z a t i o n μ k + 1 : = μ k + ρ ( x k + 1 − z k + 1 ) d u a l u p d a t e \begin{array}{l} x^{k+1} &:= (A^TA+\rho I)^{-1}(A^Tb+\rho z^k-\mu ^k) & \mathrm{ x.minimization } \\ z^{k+1} &:= S_{\lambda / \rho} (x^{k+1} + \mu ^{k}/ \rho) & \mathrm{ z.minimization }\\ \mu ^{k+1} &:= \mu ^k + \rho (x^{k+1}-z^{k+1}) & \mathrm{ dual \quad update } \end{array} xk+1zk+1μk+1:=(ATA+ρI)1(ATb+ρzkμk):=Sλ/ρ(xk+1+μk/ρ):=μk+ρ(xk+1zk+1)x.minimizationz.minimizationdualupdate

其中, S τ S_\tau Sτ 是软阈函数(又称为Shrinkage), S τ ( g ) : = s i g n ( g ) ⋅ ( ∣ g ∣ − τ ) + S_\tau (g):=sign(g)\cdot (|g|-\tau)_+ Sτ(g):=sign(g)(gτ)+ [3],也即 [5]

[ S τ ( g ) ] j = { g j − τ g > τ 0 − τ ≤ g ≤ τ g j + τ g < − τ , j = 1 , 2 , … , n \left [S_\tau (g) \right ]_j= \left\{\begin{matrix} g_j-\tau & g> \tau \\ 0 & -\tau \le g \le \tau \\ g_j+\tau & g<-\tau \end{matrix}\right. , \quad j=1,2,\dots ,n [Sτ(g)]j=gjτ0gj+τg>ττgτg<τ,j=1,2,,n

实际上,ADMM 算法往往在一系列迭代后,能获得较为精确的解,但是所需要的迭代次数是大量的 [5]。

ρ \rho ρ 的选取会在极大程度上影响 ADMM 的收敛性。若 ρ \rho ρ 太大,则对于优化 f + g f+g f+g 的能力会下降;反之,则会削弱约束条件 x = z x=z x=z. Boyd et al. (2010) 给出了选 ρ \rho ρ 的策略,效果不错,但不能保证一定收敛。

ISTA

现在流行的一种解决问题(P)的方法是 ISTA(iterative shrinkage-thresholding algorithms)[Daubechies et al, 2004],该方法在每次迭代时会计算矩阵和向量的乘积,随后是收缩步骤(shrinkage/soft-threshold)。

对于连续可微函数 f : R n → R f:\mathbb{R} ^n \to \mathbb{R} f:RnR 的无约束优化问题 min ⁡ { f ( x ) : x ∈ R n } \min \{ f(x): x\in \mathbb{R} ^n \} min{f(x):xRn} ,解决此类问题的一种简单的方法是使用梯度算法,通过 x k = x k − 1 − t k ∇ f ( x k − 1 ) x_k=x_{k-1}-t_k\nabla f(x_{k-1}) xk=xk1tkf(xk1) 生成序列 { x k } \{ x_k \} {xk}. 这种梯度迭代法可以被视为一种线性函数 f f f 在点 x k − 1 x_{k-1} xk1 处的近端正则化(proximal regularization)[Martinet, Bernard ,1970],即

x k = arg ⁡ min ⁡ x { f ( x k − 1 ) + ⟨ x − x k − 1 , ∇ f ( x k − 1 ) ⟩ + 1 2 t k ∥ x − x k − 1 ∥ 2 } . x_k=\arg \min \limits _x \left \{ f(x_{k-1} ) + \left \langle x-x_{k-1},\nabla f(x_{k-1}) \right \rangle + \frac{1}{2t_k} \Vert x-x_{k-1} \Vert ^2 \right \}. xk=argxmin{f(xk1)+xxk1,f(xk1)+2tk1xxk12}.

其中, ⟨ x , y ⟩ = x T y \left \langle x,y \right \rangle =x^Ty x,y=xTy 表示两向量的内积。将这种梯度思想运用到非光滑的含 l 1 l1 l1-正则项 的优化问题(P)上,那么可以得到迭代策略:

x k = arg ⁡ min ⁡ x { f ( x k − 1 ) + ⟨ x − x k − 1 , ∇ f ( x k − 1 ) ⟩ + 1 2 t k ∥ x − x k − 1 ∥ 2 + λ ∥ x ∥ 1 } . x_k=\arg \min \limits _x \left \{ f(x_{k-1} ) + \left \langle x-x_{k-1},\nabla f(x_{k-1}) \right \rangle + \frac{1}{2t_k} \Vert x-x_{k-1} \Vert ^2 + \lambda \Vert x \Vert _1 \right \}. xk=argxmin{f(xk1)+xxk1,f(xk1)+2tk1xxk12+λx1}.

合并同类项,忽略常数项后,我们能得到如下形式:

x k = arg ⁡ min ⁡ x { 1 2 t k ∥ x − ( x k − 1 − t k ∇ f ( x k − 1 ) ) ∥ 2 + λ ∥ x ∥ 1 } . x_k = \arg \min \limits _x \left \{ \frac{1}{2t_k} \Vert x-(x_{k-1}-t_k\nabla f(x_{k-1})) \Vert ^2 + \lambda \Vert x \Vert _1 \right \}. xk=argxmin{2tk1x(xk1tkf(xk1))2+λx1}.

这是一种特殊情况,因为 l 1 l1 l1-范数 是可以分离的,所以计算 x k x_k xk 简化为解决一维的优化问题,即

x k = τ λ t k ( x k − 1 − t k ∇ f ( x k − 1 ) ) . x_{k}=\tau _{\lambda t_k} (x_{k-1} -t_k\nabla f(x_{k-1})). xk=τλtk(xk1tkf(xk1)).

针对(P)问题时,ISTA 的迭代形式为:( P i s t a P_{ista} Pista

x k + 1 = τ λ t k + 1 ( x k − t k + 1 A T ( A x k − b ) ) . x_{k+1}=\tau _{\lambda t_{k+1}} (x_k -t_{k+1}A^T(Ax_k-b)). xk+1=τλtk+1(xktk+1AT(Axkb)).

其中, t k + 1 t_{k+1} tk+1 为步长,步长 t k ∈ ( 0 , 1 / ∥ A T A ∥ ) t_k\in (0,1/\Vert A^TA \Vert ) tk(0,1/ATA) 确保了 x k x_k xk 可以收敛到 x ∗ x^* x τ α \tau _{\alpha} τα 为收缩算子(shrinkage operator),和 shrinkage function 无异。[1] 中证明了下降和收敛性。

这一算法的思想可以追溯到 proximal forwardbackward iterative scheme。最近,一种由 proximal forward-backward algorithms 产生 { x k } \{ x_k \} {xk} 序列的算法也作出了贡献 [1]。

对于( P i s t a P_{ista} Pista),步长 t t t 的确定有两种方法,分别是定步长法和回溯法(backtracking)。在使用定步长法时,我们需要设定 t ˉ = 1 / L ( f ) \bar{t}=1/L(f) tˉ=1/L(f) L ( f ) L(f) L(f) ∇ f \nabla f f 的 Lipschitz 常数。对于(P), L ( f ) = 2 λ max ⁡ ( A T A ) L(f)=2\lambda _{\max} (A^TA) L(f)=2λmax(ATA) ,这就导致对于大规模问题( A A A 维数过大),求解 L ( f ) L(f) L(f) 往往是困难的,而且,很多时候, L ( f ) L(f) L(f) 不可求。所以,我们使用回溯法求解合适的步长。(R)

虽然 ISTA 是一种非常简单的方法,但是它的收敛速度较慢。最近的研究表明,对于一些特定的 A A A ,ISTA 生成的 { x k } \{ x_k \} {xk} 序列有着同样慢速的渐进收敛速率,这很糟糕 [Bredies and D. Lorenz, 2008]。

FISTA

那么,现在需要找到一种形式上和 ISTA 一样简单,在速度上却优于 ISTA 的算法。Beck A, Teboulle M 在 2009 年提出 FISTA [1],FISTA 和 ISTA 主要的不同就在于,收缩算子 τ \tau τ 没有用在 x k − 1 x_{k-1} xk1 上,而是用在 y k y_k yk 上, y k y_k yk 以线性方式结合了前两次的迭代结果 x k − 1 x_{k-1} xk1 x k − 2 x_{k-2} xk2 ,即

x k = τ λ / L k ( y k − 1 L k A T ( A y k − b ) ) x_{k}=\tau _{\lambda /L_{k}} (y_k -\frac{1}{L_k}A^T(Ay_k-b)) xk=τλ/Lk(ykLk1AT(Aykb))

y k + 1 = x k + ( t k − 1 t k + 1 ) ( x k − x k − 1 ) . y_{k+1}=x_k+\left ( \frac{t_k-1}{t_{k+1}} \right )(x_k - x_{k-1}). yk+1=xk+(tk+1tk1)(xkxk1).

此外, t k t_k tk 的迭代策略为:

t k + 1 = 1 + 1 + 4 t k 2 2 . t_{k+1}=\frac{1+\sqrt{1+4t^2_k}}{2}. tk+1=21+1+4tk2 .

注意,这里 t k + 1 t_{k+1} tk+1 并非步长,而是 y k + 1 y_{k+1} yk+1 线性结合前两次迭代结果的系数。此时的步长为 L L L L L L 恰好和之前的步长互为倒数。和上述原因(R)相同,我们也使用回溯法求解合适的步长。

算法描述

ADMM

ADMM Algorithm for LASSO problem based on [4-5]

% Solves the following problem via ADMM:
% minimize 1/2*|| Ax - b ||_2^2 + \lambda || x ||_1

% INPUT
%=======================================
% A
% b
% rho ....... augmented Lagrangian parameter
% lambda .... coefficient of l1-norm
% iter ...... iteration number
% OUTPUT
%=======================================
% x_s ....... sequences {xk} generated by ADMM
  1. 初始化 x 0 , z 0 , μ 0 = 0 x_0,z_0,\mu _0 = \mathrm{0} x0,z0,μ0=0 [6]
  2. 更新变量( k ≥ 0 k \ge 0 k0):

x k + 1 : = ( A T A + ρ I ) − 1 ( A T b + ρ z k − μ k ) x . m i n i m i z a t i o n z k + 1 : = S λ / ρ ( x k + 1 + μ k / ρ ) z . m i n i m i z a t i o n μ k + 1 : = μ k + ρ ( x k + 1 − z k + 1 ) d u a l u p d a t e \begin{array}{l} x^{k+1} &:= (A^TA+\rho I)^{-1}(A^Tb+\rho z^k-\mu ^k) & \mathrm{ x.minimization } \\ z^{k+1} &:= S_{\lambda / \rho} (x^{k+1} + \mu ^{k}/ \rho) & \mathrm{ z.minimization }\\ \mu ^{k+1} &:= \mu ^k + \rho (x^{k+1}-z^{k+1}) & \mathrm{ dual \quad update } \end{array} xk+1zk+1μk+1:=(ATA+ρI)1(ATb+ρzkμk):=Sλ/ρ(xk+1+μk/ρ):=μk+ρ(xk+1zk+1)x.minimizationz.minimizationdualupdate

[F]ISTA

[F]ISTA with backtracking for LASSO problem based on [1]

% Solves the following problem via [F]ISTA:
% minimize 1/2*|| Ax - b ||_2^2 + \lambda || x ||_1

% INPUT
%=======================================
% A
% b
% x0......... initial point
% L0 ........ initial choice of stepsize
% eta ....... the constant in which the stepsize is multiplied
% lambda .... coefficient of l1-norm
% iter ...... iteration number
% opt ....... 0 for ISTA or 1 for FISTA
% eps ....... stop criterion
% OUTPUT
%=======================================
% x_s ....... sequences {xk} generated by [F]ISTA
  1. L 0 > 0 , η > 1 , x 0 ∈ R n L_0>0 ,\eta>1,x_0 \in \mathbb{R} ^n L0>0,η>1,x0Rn, 设置 y 1 = x 0 , t 1 = 1 y_1=x_0,t_1=1 y1=x0,t1=1 ;

  2. k ≥ 1 k \ge 1 k1 步,寻找最小非负整数 i k i_k ik , 使得对于 L ˉ = η i k L k − 1 \bar{L}=\eta ^{i_k}L_{k-1} Lˉ=ηikLk1, 有
    F ( p L ˉ ( y k ) ) ≤ Q L ˉ ( p L ˉ ( y k ) , y k ) . F(p_{\bar{L}}(y_k))\le Q_{\bar{L}} (p_{\bar{L}}(y_k), y_k). F(pLˉ(yk))QLˉ(pLˉ(yk),yk). [1]

    其中,

    F ( x ) ≡ f ( x ) + g ( x ) , F(x) \equiv f(x)+g(x), F(x)f(x)+g(x),

    ∇ f ( y ) = A T ( A y − b ) , \nabla f(y) = A^T(Ay-b) , f(y)=AT(Ayb),

    p L ˉ ( y k ) = τ λ / L ˉ ( y k − 1 L ˉ A T ( A y k − b ) ) , p_{\bar{L}} (y_k) = \tau _{\lambda /\bar{L}} (y_k -\frac{1}{\bar{L}}A^T(Ay_k-b)) , pLˉ(yk)=τλ/Lˉ(ykLˉ1AT(Aykb)),

    Q L ˉ ( x , y ) : = f ( y ) + ⟨ x − y , ∇ f ( y ) ⟩ + L ˉ 2 ∥ x − y ∥ 2 + g ( x ) . Q_{\bar{L}}(x,y):=f(y)+\left \langle x-y,\nabla f(y) \right \rangle + \frac{\bar{L}}{2} \Vert x-y \Vert ^2 + g(x) . QLˉ(x,y):=f(y)+xy,f(y)+2Lˉxy2+g(x).

  3. 设置 L k = η i k L k − 1 L_k=\eta ^{i_k} L_{k-1} Lk=ηikLk1 ,更新如下变量:[2]

    x k = p L k ( y k ) , x_{k}= p_{L_k} (y_k), xk=pLk(yk),

    t k + 1 = 1 + 1 + 4 t k 2 2 , t_{k+1}=\frac{1+\sqrt{1+4t^2_k}}{2}, tk+1=21+1+4tk2 ,

    δ k = 0   f o r   I S T A ,   o r   t k − 1 t k + 1   f o r   F I S T A , \delta _k=0 \ \mathrm{for \ ISTA},\ or\ \frac{t_k-1}{t_{k+1}}\ \mathrm{for \ FISTA}, δk=0 for ISTA, or tk+1tk1 for FISTA,

    y k + 1 = x k + δ k ( x k − x k − 1 ) . y_{k+1} = x_{k} + \delta _k (x_k-x_{k-1}) . yk+1=xk+δk(xkxk1).

注:Remark 3.2 [1] 给出了 L k L_k Lk 的取值范围:

L 0 ≤ L k ≤ η L ( f ) . L_0\le L_k \le \eta L(f) . L0LkηL(f).

实验步骤

设定 m = 1500 , n = 5000 , p = 0.02 m=1500,n=5000,p=0.02 m=1500,n=5000,p=0.02 p p p 是真值 u u u 的稀疏度(sparsity density), A ∈ R m × n A\in \mathbb{R} ^{m\times n} ARm×n. b = A*u + sqrt(0.001)*randn(m,1); b b b 上添加了随机噪声,初值 x 0 = 0 x_0=0 x0=0 λ = 0.15 \lambda=0.15 λ=0.15 . 误差的估计使用 E ( x ^ ) = ∥ x ^ − u ∥ 1 E(\hat{x}) = \Vert \hat{x}-u \Vert _1 E(x^)=x^u1 x ^ \hat{x} x^ 是预测值。

clc;clear

randn('seed', 0);
rand('seed',0);

m = 1500;       % number of examples
n = 5000;       % number of features
p = 100/n;      % sparsity density

u = sprandn(n,1,p);
A = randn(m,n);
A = A*spdiags(1./sqrt(sum(A.^2))',0,n,n); % normalize columns
b = A*u + sqrt(0.001)*randn(m,1);

iter = 70;
lambda = 0.15;
x0 = zeros(5000,1);

E = @(x) sum(abs(x-u)); % compute error

ADMM [6]

设置 ρ = 0.7 \rho = 0.7 ρ=0.7 .

%% ADMM DEMO
rho = 0.7;
x_admm = admm_lasso(A,b,rho,lambda,iter);
conv_admm = E(x_admm);
function x_s = admm_lasso(A,b,rho,lambda,iter)
% Solves the following problem via ADMM:
% minimize 1/2*|| Ax - b ||_2^2 + \lambda || x ||_1

% INPUT
%=======================================
% A
% b
% rho ....... augmented Lagrangian parameter
% lambda .... coefficient of l1-norm
% iter ...... iteration number
% OUTPUT
%=======================================
% x_s ....... sequences {xk} generated by ADMM

%% shrinkage operator
S = @(tau, g) max(0, g - tau) + min(0, g + tau);

x_s = [];
[~,n] = size(A);
I = eye(n);
x = zeros(n,1);
z_old = zeros(n,1);
u_old = zeros(n,1);
%% MAIN LOOP
for ii = 1:iter
    % record x_s
    x_s = [x_s, x];
    % minimize x,z,u
    x = (A'*A+rho*I) \ (A'*b+rho*z_old-u_old);
    z_new = S(lambda/rho, x+u_old/rho);
    u_new = u_old + rho*(x-z_new);
    % check stop criteria
    % e = norm(x_new-x_old,1)/numel(x_new);
    % if e < eps
        % break
    % end
    % update
    z_old = z_new;
    u_old = u_new;
end

[F]ISTA [7]

设置 L 0 = 1.05 , η = 1.01 L_0=1.05,\eta=1.01 L0=1.05,η=1.01 .

%% [F]ISTA DEMO
L0 = 1.05;
eta = 1.01;
x_ista = fista_backtracking_lasso(A,b,x0,L0,eta,lambda,iter,0,0);
conv_ista = E(x_ista);
x_fista = fista_backtracking_lasso(A,b,x0,L0,eta,lambda,iter,1,0);
conv_fista = E(x_fista);
function x_s = fista_backtracking_lasso(A,b,x0,L0,eta,lambda,iter,opt, eps)
% Solves the following problem via [F]ISTA:
% minimize 1/2*|| Ax - b ||_2^2 + \lambda || x ||_1

% INPUT
%=======================================
% A
% b
% x0......... initial point
% L0 ........ initial choice of stepsize
% eta ....... the constant in which the stepsize is multiplied
% lambda .... coefficient of l1-norm
% iter ...... iteration number
% opt ....... 0 for ISTA or 1 for FISTA
% eps ....... stop criterion
% OUTPUT
%=======================================
% x_s ....... sequences {xk} generated by [F]ISTA

%% f = 1/2*|| Ax - b ||_2^2
f = @(x) 0.5 * norm(A*x-b)^2;

%% g = \lambda || x ||_1
g = @(x) lambda * norm(x,1);

%% the gradient of f
grad = @(x) A'*(A*x-b);

%% computer F
F = @(x) 0.5*(norm(A*x-b))^2 + lambda*norm(x,1);

%% shrinkage operator
S = @(tau, g) max(0, g - tau) + min(0, g + tau);

%% projection
P = @(L, y) S(lambda/L, y - (1/L)*grad(y));

%% computer Q
Q = @(L, x, y) f(y) + (x-y)'*grad(y) + 0.5*L*norm(x-y) + g(x);

x_s = [];
x_old = x0;
y_old = x0;
L_new = L0;
t_old = 1;
%% MAIN LOOP
for ii = 1:iter
    % find i_k
    j = 1;
    while true
        L_bar = eta^j * L_new;
        if F(P(L_bar, y_old)) <= Q(L_bar, P(L_bar, y_old), y_old)
            L_new = L_new * eta^j;
            break
        else
            j = j + 1;
        end
    end
    x_new = P(L_new, y_old);
    t_new = 0.5 * (1+sqrt(1+4*t_old^2));
    del = opt * (t_old-1)/(t_new);
    y_new = x_new + del*(x_new-x_old);
    % record x_s
    x_s = [x_s, x_new];
    % check stop criteria
    % e = norm(x_new-x_old,1)/numel(x_new);
    % if e < eps
        % break
    % end
    % update
    x_old = x_new;
    t_old = t_new;
    y_old = y_new;
end

注:这里将 ISTA 和 FISTA 算法合并成一个,可以使用 opt 参数进行选择。在函数中,加了停止条件 check stop criteria,为方便测试,这里不使用,故注释掉。

绘图

%% draw
plot(conv_admm,'LineWidth',1,...
    'DisplayName','ADMM','Color','black')
hold on
plot(conv_ista,'--','LineWidth',1,...
    'DisplayName','ISTA','Color','blue')
plot(conv_fista,'-.','LineWidth',1,...
    'DisplayName','FISTA','Color','red')
hold off
ylim([0 270])
xlabel('iteration k')
ylabel('$E(\bar{x})$','Interpreter','latex')
legend('Location','northeast')
title('Convergence behavior in terms of error of iterates of ADMM, ISTA, FISTA.',...
    '$m=1500,n=5000,p=0.02,x_0=0,\lambda=0.15,\rho = 0.7,L_0=1.05,\eta=1.01$',...
    'Interpreter','latex')

结果分析

ADMM,ISTA,FISTA算法步骤详解,MATLAB代码,求解LASSO优化问题_第2张图片

在此实验中,ADMM 算法的收敛速率最快,FISTA 的收敛速度和 ADMM 相当,ISTA 最慢。在 ADMM 中,设置 ρ = 0.7 \rho = 0.7 ρ=0.7 ρ \rho ρ 较小 ,虽然获得了不错的收敛速率,但可能在一定程度上削弱了约束条件 x = z x=z x=z. 此外,ADMM 在第二次迭代时(所有方法都存在这个问题,暂时不清楚原因), E ( x ˉ ) E(\bar{x}) E(xˉ) 波动幅度较大。此外,FISTA 的收敛速率明显优于 ISTA,在 20 次迭代左右时,基本达到的最优值。

在实验时,ADMM 的求解速度明显慢于 ISTA 和 FISTA,时间主要消耗在计算 x k + 1 x_{k+1} xk+1 时的求逆操作上。

原创文章!转载需注明来源:©️ Sylvan Ding’s Blog ❤️

参考文献

  1. Beck A, Teboulle M. A fast iterative shrinkage-thresholding algorithm for linear inverse problems[J]. SIAM journal on imaging sciences, 2009, 2(1): 183-202.
  2. Tao S, Boley D, Zhang S. Convergence of common proximal methods for l1-regularized least squares[C]//Twenty-Fourth International Joint Conference on Artificial Intelligence. 2015.
  3. Selesnick I. A derivation of the soft-thresholding function[J]. Polytechnic Institute of New York University, 2009.
  4. S. Boyd. Alternating Direction Method of Multipliers. Available online at https://web.stanford.edu/class/ee364b/lectures/admm_slides.pdf.
  5. Ryan Tibshirani. Alternating Direction Method of Multipliers. Available online at https://stat.cmu.edu/~ryantibs/convexopt/lectures/admm.pdf.
  6. You are allowed to develop your solvers by adopting the ADMM codes available from the following Stanford University websites: https://web.stanford.edu/~boyd/papers/admm/lasso/lasso.html.
  7. Tiep Vu. fista_backtracking.m. Available online at https://github.com/tiepvupsu/FISTA.

你可能感兴趣的:(凸优化,数学建模)