Robust Principal Component Analysis?（PCP）

Candes E J, Li X, Ma Y, et al. Robust principal component analysis[J]. Journal of the ACM, 2011, 58(3).

引

这篇文章，讨论的是这样的一个问题：
$M = L_0 + S_0$

有这样的一个矩阵 $M \in \mathbb{R}^{n_1 \times n_2}$，它由一个低秩的矩阵 $L_0$和稀疏矩阵 $S_0$混合而成，那么，能否通过 $M$将 $L_0$和 $S_0$分别重构出来？而且，最关键的是，也是这篇文章的亮点所在：对于 $L_0$和 $S_0$仅有一丢丢的微弱的假设。

一些微弱的假设：

关于 $L_0$:
低秩矩阵 $L_0$不稀疏，这个假设很弱，但有意义。因为如果 $M=e_1e_1^*$(文章采用 $*$作为转置符号，这里沿用这种写法)，即只有左上角第一个元素非零，那么这个矩阵如何分解为低秩和稀疏呢，因为压根没法区分。作者引入incoherence condition(不连贯条件？抱歉，不晓得如何翻译)：
假设 $L_0$的SVD分解为：
$L_0 = U\Sigma V^*=\sum \limits_{i=1}^r \sigma_i u_i v_i^*$
其中 $r = \mathrm{rank}(L_0)$, $\sigma_i$为奇异值，并且， $U = [u_1, \ldots, u_r]$, $V = [v_1, \ldots, v_r]$。
incoherence condition:

分析这些条件可以发现， $U,V$的每一行的模都不能太大， $UV^*$的每个元素同样不能太大，所以最后结果 $L_0$的各个元素的大小会比较均匀，从而保证不稀疏？

关于 $S_0$:

类似地，需要假设 $S_0$不低秩，论文另辟蹊径，假设 $S_0$的基为 $m=\mathrm{Card}(S_0)$，其支撑(support)定义为：
$\Omega = \{(i,j)| [S_0]_{i,j} \ne 0\}$
论文假设 $S_0$的支撑 $\Omega$从一个均匀分布采样。即， $S_0$不为零的项为 $m$，从 $n_1\times n_2$个元素中挑选 $m$个非零的组合有 $\mathrm{C}_{n_1 \times n_2}^m$，论文假设每一种组合被采样的概率都是相同的。事实上，关于 $S_0$元素的符号，论文在后面说明，符号固定或者随机（服从伯努利分布），都能将 $L_0,S_0$恢复出来。

问题的解决

论文反复强调，多么令人惊讶，多么不可思议，事实上的确如此，上述问题只需求解一个形式非常简单的凸优化问题：

其中 $\|L\|_* = \sum \limits_{i=1}^r \sigma_i(L)$为其核范数。

论文给出了以下结论：


即：令 $n_{(1)}= \max(n_1, n_2), n_{(2)} = \min (n_1, n_2)$，对于任意矩阵 $M = L_0 + S_0 \in \mathbb{R}^{n_1 \times n_2}$，只要 $L_0$和 $S_0$满足上面提到的假设，那么就存在常数 $c$使得，PCP的解（即（1.1）的解，且 $\lambda= 1/ \sqrt{n_{(1)}}$） $\hat{L}$和 $\hat{S}$有 $1-c n_{(1)}^{-10}$的概率重构 $L_0$， $S_0$，即 $\hat{L}=L_0$， $\hat{S}=S_0$。并且有下列性质被满足 $\mathrm{rank}(L_0) \le \rho_r n_{(2)} \mu^{-1} (\log n_{(1)})^{-2},m \le \rho_s n_1 n_2$。

这个结果需要说明的几点是，常数 $c$是根据 $S_0$的支撑 $\Omega$决定的（根据后面的理论，实际上是跟 $\|\mathcal{P}_{\Omega} \mathcal{P}_{T}\|$有关），另外一点是， $\lambda = 1 / \sqrt{n_{(1)}}$。是的，论文给出了 $\lambda$的选择（虽然这个选择不是唯一的），而且，这个值是通过理论分析得到的。

关于问题 (1.1)的求解有很多现成的算法，这篇论文大量篇幅用于证明上述的理论结果，只在最后提到利用ALM（Augmented Largrange multiplier）方法有很多优势，算法如下：

其中 $\mathcal{S}_{\tau}[x] = \mathrm{sgn} (x) \max (|x| - \tau, 0)$, $\mathcal{D}_{\tau} (X)=U\mathcal{S}_{\tau}(\Sigma)V^*,X=U\Sigma V^*$。

ALM算法实际上是交替最小化下式：

其中 $<A, B>:= \mathrm{Tr(A^TB)}$。

固定 $L, Y$,实际上就是最小化：
$\min \quad \lambda \|S\|_1 + <Y, -S> + \frac{\mu}{2}\mathrm{Tr}(S^TS -2S^T(M-L))$
其在 $S$处的导数(虽然有些点并不可导)为：
$\lambda \mathrm{sgn}(S) - Y + \mu S-\mu(M-L)$
实际上，对于每个 $S_{i,j}$，与其相关的为：
$a S_{i, j}^2 + b S_{i,j}+c|S_{i,j}|, \alpha > 0$
关于最小化这个式子，我们可以得到：
$S_{i,j}= \left \{ \begin{array}{ll} -\frac{b+c}{2a} & -\frac{b+c}{2a} \ge 0 \\ -\frac{b-c}{2a} & -\frac{b-c}{2a} \le 0 \\ 0 & else \end{array} \right.$
实际上就是 $S_{i,j}= \mathcal{S}_{c/2a}(-b/2a)$，对 $S$拆解，容易得到固定 $L,Y$的条件下， $S$的最优解为：
$\mathcal{S}_{\lambda / \mu}(M-L+\mu^{-1}Y)$
当 $S, Y$固定的时候：

实际上就是最小化下式：
$\|L\|_* + <Y, -L> + \frac{\mu}{2} \mathrm{Tr(L^TL-L^T(M-S))}$
观测其次梯度：
$UV^*+W-Y+\mu L - \mu(M-S)$
其中 $L=U\Sigma V^*，U^*W=0,WV=0,\|W\| \le 1$， $\|X\|$为 $X$的算子范数。
最小值点应当满足 $0$为其次梯度，即：
$L = -\mu^{-1}UV^*-\mu^{-1}W+\mu^{-1}Y + M-S$
有解。
令 $A = M-S+\mu^{-1}Y$
则：
$L = -\mu^{-1}UV^*-\mu^{-1}W+A \\ \Rightarrow \Sigma=-\mu^{-1}I+U^*AV$
假设 $A=U_A\Sigma_A V_A^*$，那么：
$\Sigma=-\mu^{-1}I+U^*U_A\Sigma_A V_A^*V$
如果我们令 $U=U_A,V=V_A$，则：
$\Sigma = \Sigma_A-\mu^{-1}I$
但是我们知道， $\Sigma$的对角元素必须大于等于0，所以我可以这样构造解：
假设 $\Sigma_A$的对角元素，即奇异值降序排列 $\sigma_1(A) \ge \sigma_2(A) \ldots \sigma_k(A) \ge \mu^{-1} > \sigma_{k+1}(A) \ge \ldots \ge \sigma_r(A)$，相对于的向量为 $u_1(A),\ldots,u_r(A)$和 $v_1{A},\ldots, v_r(A)$。我们令
$L=\sum \limits_{i=1}^k (\sigma_i(A)-\mu^{-1})u_i(A)v_i^T(A) \\ W = \sum \limits_{i=k+1}^{r} \mu \sigma_i(A)u_i(A)v_i^T(A)$
容易验证 $U^*W=0,WV=0$，又 $\mu^{-1} > \sigma_i(A), i > k$，所以 $\mu \sigma_i(A) < 1$，所以 $\|W\| \le 1$也满足。同样的，次梯度为0的等式也满足，所以 $L$就是我们要找到点（因为这个是凸函数，极值点就是最小值点）。

理论

这里只介绍一下论文的证明思路。
符号：

去随机

论文先证明，如果 $S_0$的符号是随机的（伯努利分布），在这种情况能恢复，那么 $S_0$的符号即便不随机也能恢复。

Dual Certificates(对偶保证？)

引理2.4

引理2.4告诉我们，只要我们能找到一对 $(W, F)$，满足 $UV^*+W=\lambda(sgn(S_0)+F)$。 $(L_0,S_0)$是优化问题(1.1)的唯一解。但是不够，因为这个条件太强了， $W, F$的构造是困难的。

引理2.5

进一步改进，有了引理2.5。

引理2.5的意义在哪呢？它意味着，我们只要找到一个 $W$，满足：

那么， $(L_0,S_0)$就是问题 $(1.1)$的最优解，而且是唯一的。

Golfing Scheme

接下来，作者介绍一种机制来构造 $W$，并且证明这种证明能够大概率保证 $W$能够满足上述的对偶条件。作者将 $W = W^L + W^S$分解成俩部分，俩部分用不同的方式构造：

接下的引理和推论，总结起来便是最后的证明：




通过引理2.8和2.9，再利用范数的三角不等式，容易验证 $W = W^L+W^S$满足对偶条件。
最后提一下，定理的概率体现在哪里，在对偶条件的引理中，有这么一个假设 $\|\mathcal{P}_{\Omega}\mathcal{P}_T\| \le 1$和 $\|\mathcal{P}_{\Omega}\mathcal{P}_T\| \le 1/2$，这些条件并不一定成立，根据 $\Omega$的采样，成立的大概率的。

数值实验

按照论文里，普通的人工生成矩阵，实验下来和论文的无异。也的确， $S_0$的规模大小（每个元素的大小）对能否恢复几乎没有影响，有影响的是 $S_0$的稀疏度。实验下来，稀疏度越高（0基越小），恢复的越好，而且差距蛮大的。

我们的实验， $L = XY$，其中 $X,Y \in \mathbb{R}^{500 \times 25}$依标准正态分布生成的， $S_0$是每个元素有 $\rho$的概率为 $100$， $\rho$的概率为 $-1$， $1-2\rho$的概率为0。 $\rho$我们选了 $1/10, 1/15, \ldots, 1/55$。
下面的图，红色表示 $\|\hat{L}-L_0\|_F/\|L_0\|_F$，蓝色表示 $\|\hat{S}-S_0\|_F/\|S_0\|_F$。因为每种情况我只做了一次实验，所以结果有起伏，但是趋势是在的。

比较有意思的是图片的拆解，我在马路上拍了31张照片，按照论文的解释，通过将照片拉成向量，再混合成一个矩阵 $M$，然后通过优化问题解出 $\hat{L}$和 $\hat{S}$，那么 $\hat{L}$的行向量（我做实验的时候是将一个照片作为一个行向量，论文里的是列向量）重新展成图片应该是类似背景的东西，而 $\hat{S}$中对应的行向量应该是原先图片中会动的东西。

照片我进行了压缩( $416 \times 233$)和灰度处理，处理 $M$用了1412次迭代，时间大概15分钟？比我预想的快多了。
我挑选其中比较混乱的图（就是车比较多的）：
第一组：
M:

L:

S:

第二组：

M:

L:

S:

第三组：

M:

L:

S:

比较遗憾的是， $\hat{S}$中都出现了面包车，我以为面包车会没有的，结果还是出现了。

代码

"""
Robust Principal Component Analysis?
"""


import numpy as np

class RobustPCA:

    def __init__(self, M, delta=1e-7):
        self.__M = np.array(M, dtype=float)
        self.__n1, self.__n2 = M.shape
        self.S = np.zeros((self.__n1, self.__n2), dtype=float)
        self.Y = np.zeros((self.__n1, self.__n2), dtype=float)
        self.L = np.zeros((self.__n1, self.__n2), dtype=float)
        self.mu = self.__n1 * self.__n2 / (4 * self.norm_l1)
        self.lam = 1 / np.sqrt(max(self.__n1, self.__n2))
        self.delta = delta

    @property
    def norm_l1(self):
        """返回M的l1范数"""
        return np.sum(np.abs(self.__M))

    @property
    def stoprule(self):
        """停止准则"""
        A = (self.__M - self.L - self.S) ** 2
        sum_A = np.sqrt(np.sum(A))
        bound = np.sqrt(np.sum(self.__M ** 2))
        if sum_A <= self.delta * bound:
            return True
        else:
            return False
    def squeeze(self, A, c):
        """压缩"""
        if c <= 0:
            return A
        B1 = np.where(np.abs(A) < c)
        B2 = np.where(A >= c)
        B3 = np.where(A <= -c)
        A[B1] = [0.] * len(B1[0])
        A[B2] = A[B2] - c
        A[B3] = A[B3] + c
        return A

	def newsvd(self, A):
        def sqrt(l):
            newl = []
            for i in range(len(l)):
                if l[i] > 0:
                    newl.append(np.sqrt(l[i]))
                else:
                    break
            return np.array(newl)
        m, n = A.shape
        if m < n:
            C = A @ A.T
            l, u = np.linalg.eig(C)
            s = sqrt(l)
            length = len(s)
            u = u[:, :length]
            D_inverse = np.diag(1 / s)
            vh = D_inverse @ u.T @ A
            return u, s, vh
        else:
            C = A.T @ A
            l, v = np.linalg.eig(C)
            s = sqrt(l)
            length = len(s)
            v = v[:, :length]
            D_inverse = np.diag(1 / s)
            u = A @ v @ D_inverse
            return u, s, v.T

    def update_L(self):
        """更新L"""
        A = self.__M - self.S + self.Y / self.mu
        u, s, vh = np.linalg.svd(A) #or self.newsvd(A)
        s = self.squeeze(s, 1 / self.mu)
        s = s[np.where(s > 0)]
        length = len(s)
        if length is 0:
            self.L = np.zeros((self.__n1, self.__n2), dtype=float)
        elif length is 1:
            self.L = np.outer(u[:, 0] * s[0], vh[0])
        else:
            self.L = u[:, :length] * s @ vh[:length]

    def update_S(self):
        """更新S"""
        A = self.__M - self.L + self.Y / self.mu
        self.S = self.squeeze(A, self.lam / self.mu)

    def update_Y(self):
        """更新Y"""
        A = self.__M - self.L - self.S
        self.Y = self.Y + self.mu * A

    def process(self):
        count = 0
        while not (self.stoprule):
            count += 1
            assert count < 10000, "something wrong..."
            self.update_L()
            self.update_S()
            self.update_Y()
        print(count)

注意到，我自己写了一个newsvd的方法，这是因为，在处理图片的时候，用numpy的np.linalg.svd会报memoryerror，所以就自己简单调整了一下。