FastICA的原理及实现

FastICA的原理及实现

为什么是ICA而不是PCA

ICA分离出来的是非高斯分布的信号，而PCA是假设高斯分布，非高斯分布在均值为0方差一样的情况下，信息熵比高斯分布小，所以在0附近有比高斯分布更高的峰值。所以更适合学习稀疏特征。ICA是使分量最大独立化，PCA是使重构误差最小。
PCA与ICA的对比参看https://blog.csdn.net/vendetta_gg/article/details/106521295。

FastICA相比ICA的进步

1. ICA需要假定si的先验分布函数为sigmoid函数，而FastICA不需要假定先验分布。
2. ICA使用梯度下降法更新，收敛速度是一次的。FastICA使用牛顿法更新，收敛速度至少是二次的，这就是FastICA名字的来源。
3. ICA只能一次把所有独立成分全求出来，FastICA可以根据需要只求出1～n个独立成分。

论文的解读

此部分参照独立成分分析FastICA算法原理-知乎，并且加入了我的一些理解。
对于d维随机变量$x$，假设是由相互独立的源$s$通过$A$矩阵线性组合产生：
$x=As$
如果$s$服从高斯分布，则不能还原出唯一的$s$，如果$s$非高斯，则可以通过找到$W$使$s=Wx$，使$s$相互独立从而得到$W$和$s$。

为什么ICA可以恢复原始的源？

Darmois - Skitovitch theorem 假设Si是相互独立的源噪声，对于两个随机变量
$$\begin{gathered} X=a_1{S}_1+\dots +a_n{S}_n, \\ Y=b_1{S}_1+\dots +b_n{S}_n \end{gathered}$$
若$XY$相互独立，则对任意$a_i{b}_i\ne 0$，必有$S_i$为高斯分布。即两个独立的分布，除了高斯分布，两个非零的线性组合一定不相互独立。
根据定理，假设n=2，$S$非高斯，于是
$$\begin{gathered} x_1=a_1{s}_1+a_2{s}_2, \\ {x}_2=b_1{s}_1+b_2{s}_2 \end{gathered}$$
且$z_1=w_1^{T}X,z_2=w_2^{T}X$，且相互独立，则
$$\begin{gathered} z_1=c_1{s}_1+c_2{s}_2, \\ {z}_2=d_1{s}_1+d_2{s}_2 \end{gathered}$$
根据定理，因为$s_1,s_2$非高斯，所以$c_1{d}_1=0，c_2{d}_2=0$。但是$z_1,z_2$不是零，所以$z_1,z_2$分别为$c_1{s}_1，b_2{s}_2$（或者反过来），总之可以分离成两个相互独立的$z_1,z_2$。即把$x_1,x_2$重新线性组合为$s_1,s_2$使其相互独立后，$s_1,s_2$就是独立源噪声（可能多一个倍数关系）。

目标函数

我们使用互信息（独立的情况下$S$的信息熵为分量$s_i$信息熵的和，用分量信息熵和减去$S$信息熵，越小说明越接近独立）作为目标函数。
$$I(s_1,\dots ,s_n)=\sum (H(s_i))-H(S)$$
首先计算$H(S)$。因为$S=WX$，
所以$$logP(S)=logP(X)-log|detW|$$
如果$detW=1，log|detW|=0$。此时$H(S)$与$W$无关，只需要最小化每一个$H(s_i)$。

如何保证$detW=1$呢？
首先，根据$S$是相互独立的源，可以假设$si$的方差是一致的。那么$S$的协方差为$I$的整数倍。不妨设为$I$。这时$X$可以看成$S$每个源先经过放大器再线性组合得到，并不影响模型。在$X$接收器，线性组合后，变成$\hat{X}$，使其协方差为$I$。这些改动没有改变$X$是$S$线性组合的本质。但是经过这些假设，从$S$到$X$的中间线性变换$W$的行列式绝对值变为1，因为
$$\begin{gathered} S{S}^T=WX{X}^T{W}^T, \\ S{S}^T=nI, \\ X{X}^T=nI. \end{gathered}$$取行列式发现$|detW|=1$。
$X$正交化利用协方差特征分解。
$$X{X}^T=AS{S}^T{A}^T=A{A}^T=ED{E}^T,$$则
$$E{D}^{-1/2}{E}^{T}X{X}^{T}E{D}^{-1/2}{E}^T=E{D}^{-1/2}{E}^{T}ED{E}^{T}E{D}^{-1/2}{E}^T.$$注意$E{E}^T=I$，所以原式=$I$。
令$$\hat{X}=E{D}^{-1/2}{E}^{T}X，\hat{X}{\hat{X}}^T=I,$$即$\hat{X}$是正交矩阵。

完成以后才发现其实原文定义的$I$并不是这样。原文令$J(y)=H\left(y_{\text{gauss }}\right)-H(y)$，其中$y_{gauss}$是与$y$同方差的正态分布。$$I\left(y_1,y_2,\cdots ,y_n\right)=J(\mathbf{y})-\sum _{i}J\left(y_i\right).$$实际上对$S$在假定独立且协方差为$I$时，$H(S_{gauss})={\sum }_{i}H(s_{i_{gauss}})$。因此这个互信息和上面的定义等价。因为$H(S_{gauss})$也是一个常数，再根据上面已经证明的$H(S)$与$W$无关，$J(S)=H(S_{gauss})-H(S)$与$W$无关。所以最小化$I(s_1,\dots ,s_n)$，只需要最大化${\sum }_{i}J\left(y_i\right)$。根据知乎大佬的解释，最小化$H(s_i)$就是最大化非高斯性，因为高斯分布在同均值方差下有最大熵。$J(s_i)$就是衡量非高斯性大小的。

原文用$J$定义后用了另一个式子来近似$$J\left(y_i\right)\approx c{\left[E\left\{G\left(y_i\right)\right\}-E\{G(\nu )\}\right]}^2,$$其中$c$是正常数，$\nu \sim N(0,1)$，$G$是非二次函数。
$J_G(w_i)=[E\left\{G(w_i^{T}x)\right\}-E\left\{G(\nu )\right\}{]}^2$
$s_i=w_i^{T}x$.
至此已经找到目标函数了：
最大化 ${\sum }_{i=1}^n{J}_G\left({\mathbf{w}}_i\right)\text{ wrt. }{\mathbf{w}}_i,i=1,\cdots ,n$
其中约束条件为$s_i,s_j$无关，即
$E\left\{\left({\mathbf{w}}_k^T\mathbf{x}\right)\left({\mathbf{w}}_j^T\mathbf{x}\right)\right\}={\delta }_{jk}$，其中${\delta }_{jk}$是示性函数。

$G$的选择

然后考虑非二次函数$G(u)$的选择。论文给了几个定理，分别从$w$估计的一致性，渐进方差和鲁棒性出发给了几个定理和选择标准。具体可以查看原论文。中间有一个地方比较重要，需要$G$满足：
条件1
$$E\left\{s_{i}g\left(s_i\right)-g^{\prime }\left(s_i\right)\right\}\left[E\left\{G\left(s_i\right)\right\}-E\{G(\nu )\}\right]>0$$
注意左边第二项是$J_G(w_i)$的绝对值。该论文选择的$G$为$logP(s)$，并且在$s$是指数族分布下进行一些近似。这个在后面优化会用到。
$$\begin{array}{rl}{G}_1(u)& =\frac{1}{a_1}\log \cosh \left(a_{1}u\right)\\ g_1(u)& =\tanh \left(a_{1}u\right)\\ G_2(u)& =-\frac{1}{a_2}\exp \left(-a_2{u}^2/2\right)\\ g_2(u)& =u\exp \left(-a_2{u}^2/2\right)\\ G_3(u)& =\frac{1}{4}{u}^4\\ g_3(u)& =u^3\end{array}$$
其中$g(\ast )$是$G(\ast )$的导数。实际上算法还需要$g^{\prime }(\ast )$但是没有给出。实现的时候还需要再算一下。

牛顿法解优化问题

接下来使用拉格朗日方程去解带约束的优化问题。
当$E\left\{G\left(s_i\right)\right\}-E\{G(\nu )\}>0$时，最大化 ${\sum }_{i=1}^n{J}_G\left({\mathbf{w}}_i\right)\text{ wrt. }{\mathbf{w}}_i,i=1,\cdots ,n$等价于最大化${\sum }_{i=1}^{n}E\left\{G(w_i^{T}x)\right\}$。逐个考虑${\mathbf{w}}_i$，即最大化$E\left\{G({\mathbf{w}}_i^T\mathbf{x})\right\},{\Vert {\mathbf{w}}_i\Vert }^2=1$使用拉格朗日方程：
$$E\left\{\mathbf{x}g\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-\beta \mathbf{w}=0$$
可以得到$\beta =E\left\{{\mathbf{w}}_0^T\mathbf{x}g\left({\mathbf{w}}_0^T\mathbf{x}\right)\right\}$，其中${\mathbf{w}}_0$是${\mathbf{w}}_i$的最优点。
记$F$为左边的式子，则$J_F(\mathbf{w})$为雅各比矩阵
$$JF(\mathbf{w})=E\left\{{\mathbf{xx}}^T{g}^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-\beta \mathbf{I}.$$
$E\left\{{\mathbf{xx}}^T{g}^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}$合理近似为$E\left\{{\mathbf{xx}}^T\right\}E\left\{g^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}=IE\left\{g^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}$。
接下来用牛顿法求解拉格朗日方程。
$$\begin{array}{l}{\mathbf{w}}^{+}=\mathbf{w}-\left[E\left\{\mathbf{x}g\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-\beta \mathbf{w}\right]/\left[E\left\{g^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-\beta \right]\\ {\mathbf{w}}^{\ast }={\mathbf{w}}^{+}/\Vert {\mathbf{w}}^{+}\Vert \end{array}$$
根据条件1左边第一项为正，即分母$E\left\{g^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-\beta$为负，所以同乘分母的相反数不改变${\mathbf{w}}^{+}$的方向，只改变大小，单位化以后不变。即：
$$\begin{array}{rl}{\mathbf{w}}^{+}& =E\left\{\mathbf{x}g\left({\mathbf{w}}^T\mathbf{x}\right)\right\}-E\left\{g^{\prime }\left({\mathbf{w}}^T\mathbf{x}\right)\right\}\mathbf{w}\\ {\mathbf{w}}^{\ast }& ={\mathbf{w}}^{+}/\Vert {\mathbf{w}}^{+}\Vert \end{array}$$

有了一个$\mathbf{w}$的估计，就可以进行n次从而得到n个独立成分。为了防止收敛到同一个$\mathbf{w}$，可以使用施密特正交化把${\mathbf{w}}_i$单位正交化。只需要在第i+1个${\mathbf{w}}_{i+1}$去掉其在前i个方向上的分量，然后单位化即可：
$$\begin{gathered} {\mathbf{w}}_{i+1}={\mathbf{w}}_{i+1}-\sum _{j=1}^i{\mathbf{w}}_{i+1}^T{\mathbf{w}}_j{\mathbf{w}}_j \\ {\mathbf{w}}_{i+1}={\mathbf{w}}_{i+1}/\sqrt{{\mathbf{w}}_{p+1}^T{\mathbf{w}}_{i+1}} \end{gathered}$$

还有一种对称去相关的方法，与白化基本一致，不赘述直接贴公式
$$\mathbf{W}={\left({\mathbf{WW}}^T\right)}^{-1/2}\mathbf{W}$$
对称矩阵的-1/2次幂意味着特征分解后的逆矩阵
$$(\mathbf{WW}{)}^{-1/2}={\mathbf{ED}}^{-1/2}{\mathbf{E}}^T$$
在具体得到n个${\mathbf{w}}_i$的实现，我使用随机选取X的样本点和随机从$G_1,G_2,G_3$中选择$G$的方式，防止${\mathbf{w}}_i$相关性太强。

python实现及sklearn包调用

numpy实现

首先使用numpy编写自己的算法，然后与sklearn包比较。

import numpy as np

# 1.白化
def whiten(x):
    # x是一列一个记录，一行一个特征
    mean=np.mean(x,axis=1)
    sd=np.std(x,axis=1)
    std_x=(x-mean)/sd
    Lambda, Vec=np.linalg.eig(std_x.dot(std_x.T))
    # C = V*Lambda*V'
    X_white=(np.dot(Vec.dot(np.diag(1/np.sqrt(Lambda))),Vec.T))
    X_white=X_white.dot(std_x)
    # print(1/np.sqrt(Lambda))
    return X_white

# 验证白化效果
X=np.mat(np.random.randn(5,100))
A=np.mat(np.array([[1,0,0,0,0],
[0,2,0,0,1],
[0,0,1,1,0],
[1,1,0,1,0],
[0,1,0,0,1]
]))
X=A.dot(X)
print(A.dot(A.T))

X=whiten(X)
print(np.dot(X,X.T))

定义G
def G_1(x,a=1.5):
    # G_1(u)=1/a1 logcosh(a1u)
    # G_1'=tanh(a1u)
    # G_1''=a1(1-tan(a1u)^2)
    # 返回一阶导数和二阶导数
    g=np.tanh(a*x)
    g_dif=a*(1-g**2)
    return (g,g_dif)

def G_2(x,a=1):
    # G_2(u)=-1/a2*exp(-a2*u^2/2)
    # G_2'=u*exp(-a2*u^2/2)
    # G_2''=exp(-a2*u^2/2)-a2*u^2*exp(-a2*u^2/2)
    g_2=x*np.exp(-(a*x**2/2))
    g_2_dif=g_2/x - g_2*a*x
    return (g_2,g_2_dif)

def G_3(x):
    # G_3(u)=1/4 * u^4
    # G_3'=u^3
    # G_3''=3*u^2
    g_3=x**3
    g_3_dif=3*x**2
    return (g_3,g_3_dif)

牛顿法求单个$w$

def newton_method(X,G,loops,eps=0.0001):
    """
    参数
    X: 观测矩阵，每列为一个观测，每行为一个特征
    G: 函数G
    loops: 最大循环次数
    eps: 判断收敛的参数 当循环后w变化的模小于eps停止循环
    返回值
    列向量w
    """
    m,n=X.shape
    w0=np.random.random([m,1])
    w0=w0/np.dot(w0.T,w0)
    w=w0
    for i in range(loops):
        E1=np.zeros((m,1))
        E2=np.zeros((m,1))
        for k in range(n):
            x=X[:,k]
            y=np.dot(w.T,x)
            g,g_dif=G(y)
            E1+=g.item()*x
            E2+=g_dif.item()
        E1=E1/n
        E2=E2/n
        w1=E1-E2*w
        w1=w1/np.dot(w1.T,w1)
        dif_w=w1-w0
        dif_w_size=np.dot(dif_w.T,dif_w)
        w=w1
        if dif_w_size<eps:
            break
    # print('i',w)
    return w

def extract_w(X,bs,loops,n=None):
    """
    提取n个w作为矩阵输出
    参数
    X: 观测矩阵，每列为一个观测，每行为一个特征
    bs: 一次提取多少个观测求w
    loops: 一次牛顿法用至多多少次循环
    n: 求多少个独立成分。默认X的特征数。
    返回值
    w作为列向量构成矩阵W
    """
    if n is None:
        n=X.shape[0]
    m=X.shape[1]
    W=np.mat(np.zeros([X.shape[0],n]))
    for i in range(n):
        idx=np.random.choice(range(m),bs,False)
        X_sample=X[:,idx]
        if np.random.sample(1)>0.5:
            G=G_1
        elif np.random.sample(1)>0.5:
            G=G_2
        else:
            G=G_3
        w=newton_method(X_sample,G,loops)
        if i>0:
            for j in range(i-1):
                # print(w.T)
                # print(W[:,j])
                # print(np.dot(w.T,W[:,j]).item())
                w=w-np.dot(w.T,W[:,j]).item() * W[:,j]
            w=w/np.dot(w.T,w)

        W[:,i]=w
    return W


    

import matplotlib.pyplot as plt
# 生成波函数1
z0=np.hstack((np.ones(10),0,-np.ones(10)))
z1=np.tile(z0,(10))
z1=z1+np.random.random(len(z1))*0.01
plt.plot(z1)


# 生成波函数2
z0=[0.05*i for i in range(21)]
z0=z0-np.mean(z0)
z2=np.tile(z0,(10))
z2=z2+np.random.random(len(z2))*0.01
plt.plot(z2)

# 生成波函数3
z0=np.sin(np.linspace(0,2*np.pi,num=21,endpoint=False))
z3=np.tile(z0,(10))*0.5
plt.plot(z3)

# 生成X，A是混合矩阵
A=np.mat([[1,2,0],[0.5,2,0.5],[0,1,1.5]])
z1=z1[:180]
z2=z2[:180]
z3=z3[:180]
Z=np.vstack((z1,z2,z3))
X=A*Z
# 绘制X
for i in range(X.shape[0]):
    plt.plot(range(X.shape[1]),X[i,:].T)

用FastICA处理信号

X=whiten(X)
W=extract_w_2(X,150,500)
# 重构原始信号S
S=np.dot(W.T,X)
for i in range(3):
    plt.figure()
    plt.plot(range(S.shape[1]),S[i,:].T)

sklearn包

用sklearn包直接调用FastICA

from sklearn.decomposition import FastICA
fast_ica=FastICA(n_components=3)
Sr=fast_ica.fit_transform(X)
S=np.dot(Sr.T,X)
for i in range(3):
    plt.figure()
    plt.plot(range(S.shape[1]),S[i,:].T)

可以看出我实现的算法效果还是不错的，跟调包差不多。没有进一步增加数据集研究表现。毕竟只是学习笔记。

参照

HYVARINEN A. Fast and robust fixed-point algorithms for independent component analysis[J]. IEEE transactions on Neural Networks, IEEE, 1999, 10(3): 626–634.
小杰-独立成分分析FastICA算法原理
「vendetta_gg」PCA和ICA的对比