张量压缩感知---相关概念理解

文章目录

前言
- 基本概念
总结

前言

本文主要详细介绍一些关于张量压缩感知方面的内容，包括相关的基础概念和一些算法原理，并给出具体的Python代码实现过程。

基本概念

1.1 什么是张量

用一张图可以很好的理解：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PYMGYPjT-1684332309179)(image/tensorcompression/1684331384665.png)]

1.2 张量的“积”运算

1.2.1 张量内积

含义：两个相同阶的张量 $A、B ∈ R^{I_{1}×I_{2}...×I_{N}}$ 之间的运算，是两个张量位置相对应的元素乘积之后的总和。
符号表示： $<\underline{A},\underline{B}>$

1.2.2 张量外积

含义：张量 $A ∈ R^{I_{1}×I_{2}...×I_{N}}$ 和张量 $B ∈ R^{J_{1}×J_{2}...×J_{M}}$ 的外积是对应的向量元素的乘积。
符号表示： $A$ $\circ$ $B$
秩1张量:若某个张量 $X$ 可以表示为 $n$ 个向量的外积时，则 $X$ 的秩为1。例如下图中的两个张量，都是秩1张量。

1.2.3 kronecker积

含义：设 $A∈ R^{m×n}$ 和 $B∈R^{p×q}$ 是两个矩阵，则它们之间的 $Kro n ec k er$ 积是 $A$ 中的每个元素分别与矩阵 $B$ 相乘得到一个 $(m p) \times (n q)$ 大小的矩阵，其定义如下：

$\begin{aligned} A\otimes B &=\begin{pmatrix}a_{11}B&a_{12}B&\cdots&a_{1n_A}B\\a_{21}B&a_{22}B&\cdots&a_{2n_A}B\\\vdots&\vdots&\ddots&\vdots\\a_{m_A1}B&a_{m_A2}B&\cdots&a_{m_An_A}B\end{pmatrix} \\ &= \begin{pmatrix}a_{11}b_{11} & a_{11}b_{12} & \cdots & a_{11}b_{1n_B} & \cdots & a_{1n_A}b_{11} & a_{1n_A}b_{12} & \cdots & a_{1n_A}b_{1n_B} \\a_{11}b_{21} & a_{11}b_{22} & \cdots & a_{11}b_{2n_B} & \cdots & a_{1n_A}b_{21} & a_{1n_A}b_{22} & \cdots & a_{1n_A}b_{2n_B}\\\vdots & \vdots & \ddots & \vdots & \ddots & \vdots &\vdots & \ddots & \vdots\\a_{m_A1}b_{11} & a_{m_A1}b_{12} & \cdots & a_{m_A1}b_{1n_B} & \cdots & a_{m_An_A}b_{11} & a_{m_An_A}b_{12} & \cdots & a_{m_An_A}b_{1n_B} \end{pmatrix} \end{aligned}$

其中， $a_{ij}$ 和 $b_{kl}$ 分别代表矩阵 $A$ 和 $B$ 的元素， $a_{ij}B$ 代表矩阵 $B$ 中的每个元素都乘以 $a_{ij}$ ，得到的结果组合成逐元素乘积的矩阵。

符号表示： $A$ $\otimes$ $B$

1.2.4 Hadamard积

含义：就是两个矩阵对应元素相乘，即矩阵间的点乘，要求两个矩阵的大小相等。
符号表示： $A$ $\circledast$ $B$

1.2.5 Khatri-Rao积

含义：又称为列分解相乘(CP)积。
假设有两个矩阵 $A_{m \times r}$ 和 $B_{n \times r}$ ，那么它们的 $K ha t r i - R a o$ 积所得的矩阵维数为 $(mn) \times r$ 。换句话说矩阵的Khatri-Rao积就是两个矩阵对应列的Kronecker积。
符号表示： $A$ $\odot$ $B$

1.2.6 n模张量-矩阵积（模态积）

含义：设 $N$ 阶张量 $\mathcal{X} ∈ R^{I_{1}×I_{2}...×I_{N}}$ 矩阵 $U∈ R^{J×I_{n}}$ ,二者的 $n$ 模积得到的结果是一个 $I_{1}×...×I_{n-1}×J×I_{n+1}×...×I_{N}$ 的张量，即 $I_{n}$ 维度大小变为 $J$ 。
符号表示 $\mathcal{X} \times_{n}U$

1.2.7 Numpy中的“积”运算

1.内积——np.vdot()函数
在这里插入图片描述

对于两个向量的内积，也可以使用np.inner()或者np.dot函数

在这里插入图片描述

2.外积——np.matmul函数或者直接使用 @ 运算符

在这里插入图片描述

3.kronecker积——np.kron()

在这里插入图片描述

4.Hadamard积——np.multiply函数和 * 运算符
在这里插入图片描述

5.模态积——np.einsum()
假设三阶张量 $\mathcal{X}^{i\times j\times k}$ ，矩阵 $U^{a\times b}$ ，则

$\mathcal{X} \times_{1}U$ ：np.einsum('ijk,ab->ajk',X,U)
$\mathcal{X} \times_{2}U$ ：np.einsum('ijk,ab->iak',X,U)
$\mathcal{X} \times_{3}U$ ：np.einsum('ijk,ab->ija',X,U)

1.3 张量的分解运算

1.3.1CP分解

一种基于高阶张量的矩阵分解方法，简单点说就是将 $N$ 阶张量 $\mathcal{X} ∈ R^{I_{1}×I_{2}...×I_{N}}$ 分解成多个形状相同的秩一张量的和。
$数学表达：\mathcal{X} \approx[[ \lambda ;A^{(1)},A^{(2)},\cdot\cdot\cdot A^{(N)}]]\equiv\sum_{s=1}^{R}\lambda_{r}\alpha_{r}^{(1)}\circ\alpha_{r}^{(2)}\circ\alpha_{r}^{(3)}\circ\cdot\cdot\cdot\alpha_{r}^{(n)} \quad \quad (1)$
$\lambda：为了将A^{(1)}-A^{(N)}中每列值归一化时，引入的参数列$
$R ： CP 秩$

当 $\mathcal{X}$ 阶数为3时的分解示意图如下：
在这里插入图片描述

我们把通过外积组成秩1张量元素的向量集合为因子矩阵，例如令 $A = [a_{1} a_{2}...a_{R}]$ ， $B = [b_{1} b_{2}...b_{R}]$ ， $C = [c_{1} c_{2}...c_{R}]$ ,不难发现因子矩阵存在一个共同点，那就是他们的列维度肯定是相同的。

上面 $(1)$ 式可用因子矩阵表示为
$\mathcal{X} _{(1) }\approx A(C\odot B) ^T$ $\mathcal{X} _{(2) } \approx B(C\odot A) ^T$ $\mathcal{X} _{(3) } \approx C (B\odot A) ^T \\$
$\mathcal{X} _{(n)}$ ：表示张量以第 $n$ 模态展开得到的矩阵。

1.3.1.1 CP分解算法——ALS-CP（交替最小二乘法）

现在已经知道分解的方法和原理，那么接下来的问题就是如何进行有效分解，其实就是寻找 $R$ ( $\mathcal{X}$ 的CP秩) 个秩一向量使得其估计得到的张量最接近初始张量，即待优化的问题为：
$\mid\mid\widetilde{\mathcal{X} }-\mathcal{X} \mid\mid$
而 $A L S$ 的思想很简单，以三阶张量分解为例，对应的因子矩阵为 $A 、 B 、 C$ ，算法流程为：

1.初始化：随机生成一个三维张量X和一个rank为R的分解矩阵集合{A,B,C}。
2.交替更新A、B、C三个矩阵：
	a. 固定B和C，通过最小化目标函数来更新A矩阵。
	b. 固定A和C，通过最小化目标函数来更新B矩阵。		
	c. 固定A和B，通过最小化目标函数来更新C矩阵。
3.重复步骤2直到收敛，即当目标函数达到一定精度或迭代次数达到一定值时停止。
4.输出分解矩阵集合{A,B,C}，即为原始张量X的CP分解结果

其中，目标函数为：

$min_{A,B,C}\sum_{i,j,k}(X_{i,j,k} - \sum_{r=1}^{R}A_{i,r}B_{j,r}C_{k,r})^2$

在每次更新A、B、C矩阵时，可以使用最小二乘法（Least squares）来求解目标函数的最小值，即：

a. 对于A矩阵，固定B和C，最小化问题被写成：

$\operatorname*{min}_{\hat{A}} ||\mathcal{X} _{(1)}-\hat{A} (C\odot B) ^T ||_{F}$
故 $\hat{A}$ 的最优解为：
$\hat{A}=\mathcal{X} _{(1)}[(C\odot B) ^T]^{\dagger}\quad\quad(2) \\\dagger：表示伪逆$
其中，上式又可以根据 $K ha t r i - R a o$ 积的性质写成：
$\hat{A}=\mathcal{X} _{(1)}(C\odot B)(C^{T}C * B^{T}B)^{\dagger}\quad\quad(3)$
注意： $(3)$ 式相比 $(2)$ 式的优势在于可以降低计算伪逆矩阵时的计算量，但是会存在数值病态条件的可能。

b. 类似地，对于B矩阵作同样操作：

$\hat{B}$ 的最优解为：
$\hat{B}=\mathcal{X} _{(2)}[(C\odot A) ^T]^{\dagger}\quad\quad$
或者
$\hat{B}=\mathcal{X} _{(2)}(C\odot A)(C^{T}C * A^{T}A)^{\dagger}\quad\quad$

c. C矩阵的更新公式：

$\hat{C}$ 的最优解为：
$\hat{C}=\mathcal{X} _{(3)}[(B\odot A) ^T]^{\dagger}\quad\quad$
或者
$\hat{C}=\mathcal{X} _{(3)}(B\odot A)(B^{T}B * A^{T}A)^{\dagger}\quad\quad$

下面是具体实现代码：

import numpy as np
from numpy.linalg import norm
from scipy.linalg import khatri_rao

def tensor_mode_unfold(T, p):      #函数功能：将张量tensor按模式p展开成矩阵
    """
    Unfold tensor T along mode p
    """
    T = np.moveaxis(T, p-1, 0)
    new_shape = (T.shape[0], np.prod(T.shape[1:]))
    T = np.reshape(T, new_shape)
    return T

def als_cp(X, R, max_iter=100, tol=1e-6):
    """
    ALS-CP算法对三维张量X进行CP分解
    :param X: 三维张量
    :param R: 分解矩阵集合{A,B,C}的rank
    :param max_iter: 最大迭代次数
    :param tol: 收敛精度
    :return: 分解矩阵集合{A,B,C}
    """
    
    #随机初始化A,B,C
    n1, n2, n3 = X.shape
    A = np.random.rand(n1, R)
    B = np.random.rand(n2, R)
    C = np.random.rand(n3, R)

    # X按照不同模式展开
    X_1 = tensor_mode_unfold(X,1)
    X_2 = tensor_mode_unfold(X,2)
    X_3 = tensor_mode_unfold(X,3)
    
    
    # 迭代更新A、B、C
    for i in range(max_iter):
        
        # 更新A矩阵
        BtB = np.dot(B.T, B)
        CtC = np.dot(C.T, C)

        # A =  X_1 @ khatri_rao(C,B) @ (np.linalg.pinv(CtC*BtB)) #另一种更新公式
        A =  X_1 @ (np.linalg.pinv(khatri_rao(C,B).T))
        A = np.round(A,2)     #保留两位小数

        # 更新B矩阵
        AtA = np.dot(A.T, A)
        CtC = np.dot(C.T, C)

        # B =  X_2 @ khatri_rao(C,A) @ (np.linalg.pinv(CtC*AtA))
        B =  X_2 @ (np.linalg.pinv(khatri_rao(C,A).T))
        B = np.round(B,2)

        # 更新C矩阵
        AtA = np.dot(A.T, A)
        BtB = np.dot(B.T, B)
        # C =  X_3 @ khatri_rao(B,A) @ (np.linalg.pinv(BtB*AtA))
        C =  X_3 @ (np.linalg.pinv(khatri_rao(B,A).T))
        C = np.round(C,2)

        # 计算目标函数值
        X_pred = np.einsum('ir,jr,kr->ijk', A, B, C)
        err = norm(X - X_pred) / norm(X)
        # err = norm(X - X_pred) 
        
        if err < tol:
            print(err)
            print(X_pred)
            print(i)
            break

    return A, B, C


X =np.array([[[21, 26, 31, 36], [43, 54, 65, 76], [65, 82, 99, 116]], [[43, 54, 65, 76], [89, 114, 139, 164], [135, 174, 213, 252]]])
print(als_cp(X, 2, max_iter=2000, tol=0.05))

这里收敛精度取的很低，运行过程中发现如果收敛精度设置的较高，最终分解得到的全是零矩阵。
运行结果如下：

在这里插入图片描述

需要注意的是某些张量的分解结果不一定是唯一的，例子如下：

在这里插入图片描述

1.3.1.2 CP分解函数——`parafac`

直接看代码：

import numpy as np
import tensorly as tl
from tensorly.decomposition import parafac   #CP分解

X = np.array(
       [[[ -2,  -4,  -5],
        [ -4,  -8, -10],
        [ -6, -12, -15]],

       [[ -4,  -8, -10],
        [ -8, -16, -20],
        [-12, -24, -30]],

       [[ -6, -12, -15],
        [-12, -24, -30],
        [-18, -36, -45]]])
factors = parafac(X, rank=1)
print(factors.factors)    #打印出分解的矩阵
print('还原结果：',tl.kruskal_to_tensor(factors))
# 或者使用 np.einsum('ir,jr,kr->ijk', factors.factors[0], factors.factors[1], factors.factors[2])

>>>[array([[-25.0998008 ],
       [-50.19960159],
       [-75.29940239]]), array([[0.26726124],
       [0.53452248],
       [0.80178373]]), array([[0.2981424 ],
       [0.59628479],
       [0.74535599]])]
还原结果： [[[ -2.  -4.  -5.]
  [ -4.  -8. -10.]
  [ -6. -12. -15.]]

 [[ -4.  -8. -10.]
  [ -8. -16. -20.]
  [-12. -24. -30.]]

 [[ -6. -12. -15.]
  [-12. -24. -30.]
  [-18. -36. -45.]]]

1.3.2 Tucker分解

一句话解释：Tucker分解算法将张量分解为核心张量在每个mode上与矩阵的乘积。
以一个三维张量 $\mathcal{X} \in \mathbb{R}^{I \times J \times K}$ 分解为一个核心张量 $\in \mathbb{R}^{P \times Q \times R}$ 和一组矩阵 $\in \mathbb{R}^{I \times P}$ ， $\in \mathbb{R}^{J \times Q}$ ， $\in \mathbb{R}^{K \times R}$ 的乘积：

$\mathcal{X} \approx \mathcal{G} \times_1 A\ \times_2 B \times_3 C$ $对于每个元素：\mathcal{X}\approx\sum_{p=1}^{P}\sum_{q=1}^{Q}\sum_{r=1}^{R}g_{pqr}a_{ip}b_{jq}c_{kr}$
$用矩阵的形式表示：$

$\mathcal{X} _{(1) }\approx AG_{(1)}(C\odot B) ^T$ $\mathcal{X} _{(2) } \approx BG_{(2)}(C\odot A) ^T$ $\mathcal{X} _{(3) } \approx CG_{(3)} (B\odot A) ^T \\$

$P, Q, R$ 是对应的因子矩阵 $A, B, C$ 的成分数目（即列向量的数目）。
从上面可以发现 $CP$ 分解法其实是 $T u c kk er$ 法的一个特例：
$Tucker\xrightarrow{当G为超对角张量以及P=Q=R时}CP$
这里我们直接使用已有函数tensorly.decomposition.tucker实现：

import tensorly as tl
import numpy as np
from tensorly.decomposition import tucker
X =np.array([[[21, 26, 31, 36], [43, 54, 65, 76], [65, 82, 99, 116]], [[43, 54, 65, 76], [89, 114, 139, 164], [135, 174, 213, 252]]])
core, factors = tucker(X, rank=[2,2,2]) #rank的值 = 核张量的大小
print(core)
print(core.shape)
for i in factors:
    print(i)
    print(i.shape)

>>>[[[ 5.40004250e+02  4.78055587e-04]
  [ 1.10588415e-03  2.27895261e+00]]

 [[ 8.60894313e-04  2.92055972e+00]
  [ 1.28242147e+00 -2.05226289e-01]]]
(2, 2, 2)
[[ 0.42364875  0.90582655]
 [ 0.90582655 -0.42364875]]
(2, 2)
[[ 0.24937424  0.87814909]
 [ 0.52995313  0.22909171]
 [ 0.81053203 -0.41996567]]
(3, 2)
[[ 0.34397247  0.76268141]
 [ 0.44018534  0.32593997]
 [ 0.53639821 -0.11080146]
 [ 0.63261107 -0.5475429 ]]
(4, 2)

验证一下，看一下还原结果：

tl.tucker_to_tensor((core,factors))
#或者使用： X = np.einsum('ijk,ai,bj,ck->abc',core,factors[0],factors[1],factors[2])

>>>array([[[ 21.,  26.,  31.,  36.],
        [ 43.,  54.,  65.,  76.],
        [ 65.,  82.,  99., 116.]],

       [[ 43.,  54.,  65.,  76.],
        [ 89., 114., 139., 164.],
        [135., 174., 213., 252.]]])

1.3.2 t-SVD（张量奇异值分解）

$T u c k er$ 分解能够将高维张量分解为互不重叠的低维矩阵和核张量的乘积，是一种常用的张量分解方法。但是， $T u c k er$ 分解存在着许多问题：例如难以处理高阶张量、储存核张量需要大量空间等。 $t - S V D$ （tensor singular value decomposition）分解就是用来解决这些问题的一种改进方法。
首先了解一下SVD（奇异值分解）的基本概念：
对于矩阵 $A^{m\times n}$ ，A的SVD为：
$A=U\Sigma V^{T}$
其中 $U^{m\times m},V^{n\times n}$ 都是正交矩阵， $\Sigma^{m\times n}{}$ 除主对角线上的元素以外全为0
$t - S V D$ 算法也很类似，以三阶张量 $\mathcal{X}^{i\times j\times k}$ 为例，经过 $t - S V D$ 分解(其中， $S$ 是对角张量)：
$\mathcal{X} = U_{i\times i\times k}*S_{i\times j\times k}*V^{T}_{j\times j\times k}$
注意： $A^{l\times p\times n}$ ， $B^{p\times m\times n}$ ，则 $A * B$ 得到大小为 $l\times m\times n$ 的张量
算法步骤：

1.4 什么是张量压缩感知

介绍完前面的基础知识，再进入正题🤦‍♂️，了解一下张量压缩感知的概念。张量压缩感知(Tensor Compressed Sensing)是一种利用稀疏性和低秩性信息来压缩张量的方法。与传统的向量或矩阵压缩感知不同，张量压缩感知可以对高阶张量进行压缩，例如视频、音频等多维信号。
张量压缩感知假设张量本身具有某种结构，例如低秩性或矩阵结构，从而可以使用较少的数据来恢复原始张量。这种方法在处理高维数据时具有很大的优势，可以显著减少存储和计算的成本。
张量压缩感知的核心就是张量分解，常用的分解方法在前文已经介绍了一些。通过在低维空间中进行张量分解，并利用稀疏表示和优化算法来实现压缩和恢复操作，可以高效地实现张量压缩感知。
张量压缩感知在计算机视觉、信号处理、语音识别等领域有着广泛的应用，可以大大提高数据的存储和传输效率。

总结

张量分解还有其他不同的算法，以后再把原理和代码一并附上。文章不足之处，欢迎指正，共同学习，共同进步。✔