数值计算方法 Chapter7. 计算矩阵的特征值和特征向量

• 数值计算方法 Chapter7. 计算矩阵的特征值和特征向量
  • 0. 问题描述
  • 1. 幂法
    • 1. 思路
    • 2. 规范运算
    • 3. 伪代码实现
  • 2. 反幂法
    • 1. 思路 & 方法
    • 2. 伪代码实现
  • 3. 实对称矩阵的Jacobi方法
    • 1. 思路 & 方法
    • 2. 伪代码实现

0. 问题描述

这一章节面对的问题是说，给定一个$n$阶矩阵，如何数值求解其特征值，即：

$$Ax=\lambda x$$

1. 幂法

1. 思路

幂法的主要思路其实依然还是来源于迭代思想。

显然，对于任意一个向量$x$，我们总可以将其用$n$阶矩阵的一组正交基进行表示，即：

$$x=\sum _{i=1}^n{x}_i\cdot n_i$$

其中，$n_i$为矩阵$A$的一个单位向量，有$A{n}_i={\lambda }_i{n}_i$。

令$x^{(0)}={\sum }_i{x}_i{n}_i$，$x^{(k+1)}=A{x}^{(k)}$，则易有：

$$x^{(k)}=\sum _i{x}_i\cdot {\lambda }_i^k\cdot n_i$$

对应的模长为：

$$||x^{(k)}||=\sqrt{\sum _i{x}_i^2{\lambda }_i^{2k}}$$

我们考虑当$k\to \infty$时$x^{(k)}$的方向，不妨设$max(|{\lambda }_i|)=\lambda$。

不妨设$\lambda =|{\lambda }_1|\ge |{\lambda }_2|\ge ...\ge |{\lambda }_n|$，则我们可以分情况讨论有：

1. 假设有且仅有一个正的${\lambda }_i$使得$|{\lambda }_i|=\lambda$

   $$\underset{k\to \infty }{\lim }\frac{x^{(k)}}{||x^{(k)}||}=n_1$$

   此时有：

   $$x^{(k+1)}=A{x}^{(k)}=\lambda x^{(k)}$$

2. 假设满足$|{\lambda }_i|=\lambda$条件的$i$共有$m$个，且均有${\lambda }_i>0$

   $$\underset{k\to \infty }{\lim }\frac{x^{(k)}}{||x^{(k)}||}=\sum _i^m\frac{x_i}{\sqrt{{\sum }_i^m{x}_i^2}}{n}_i$$

   此时同样有：

   $$x^{(k+1)}=A{x}^{(k)}=\lambda x^{(k)}$$

3. 假设有$m$个正的$|{\lambda }_i|=\lambda$，$l$个负的$|{\lambda }_i|=\lambda$

   $$\underset{k\to \infty }{\lim }\frac{x^{(k)}}{||x^{(k)}||}=\sum _i^m\frac{x_i}{\sqrt{{\sum }_i^{m+l}{x}_i^2}}{n}_i+\sum _j^l\frac{(-1{)}^k\cdot x_j}{\sqrt{{\sum }_i^{m+l}{x}_j^2}}{n}_j$$

   此时，虽然$x^{(k+1)}/x^{(k)}$不稳定，但是依然有：

   $$x^{(k+2)}=AA{x}^{(k)}={\lambda }^2{x}^{(k)}$$

不过需要注意的是，这里讨论的只是一般的情况，其基于的假设是说所有的$x_i\ne 0$，如果恰好存在某些分量上的投影为0， 即某些$x_i=0$，那么上述讨论会发生一定的变化甚至失效。

而且，如上述分析，通过幂法，我们只能够获得一般矩阵当中绝对值最大的一个特征值$\lambda$，无法获取其所有的特征值，这个也需要注意一下。

2. 规范运算

基于上述思路，我们给出幂法计算的规范运算方法：

$$\{\begin{array}{rl}{y}^{(k)}& =x^{(k)}/||x^{(k)}||\\ x^{(k+1)}& =A\cdot y^{(k)}\end{array}$$

通过上述迭代，我们即可求取矩阵$A$的绝对值最大的特征值。

3. 伪代码实现

给出python伪代码实现如下：

def power_fn(A, epsilon=1e-6):
    n = len(A)
    x = [1 for _ in range(n)]
    for _ in range(10**3):
        s = math.sqrt(sum(t*t for t in x))
        y = [t/s for t in x]
        z = [0 for _ in range(n)]
        for i in range(n):
            for j in range(n):
                z[i] += A[i][j] * y[j]
                
        lamda = sum([a/b for a, b in zip(z, y)]) / n
        delta =  max(abs(a-b) for a, b in zip(z, x))
        x = z
        if delta < epsilon:
            break
    return lamda

当然，这里只考虑了仅有单一符号的最大绝对值$\lambda$的情况，如果存在绝对值相同且符号相反的最大特征值$\lambda$，上述代码会失效，需要进行一些复杂操作还有判断，这里就不过多展开了。

2. 反幂法

1. 思路 & 方法

反幂法的思路和幂法其实大差不差，不过幂法是直接正向的进行迭代，即：

$$x^{(k+1)}=A{x}^{(k)}$$

反幂法的迭代方式则是：

$$x^{(k+1)}=A^{-1}{x}^{(k)}$$

或者说：

$$x^{(k)}=A{x}^{(k+1)}$$

解法而言，我们只需要在上述幂法的基础上叠加上一章节当中多元方程组求解的方法即可。

需要额外说明的是，由于这里使用的迭代与之前的幂法是相反的，因此，这里求解的是$A^{-1}$当中绝对值最大的特征值，也就是$A$当中绝对值最小的特征值。

而同样的，这里的额外隐性条件就是需要矩阵$A$是满秩的，否则矩阵不存在逆矩阵，上述方程$x^{(k)}=A{x}^{(k+1)}$可能无解。

2. 伪代码实现

同样的，这里我们给出最简单情况下（即$A$满秩且且仅存在一个最小的绝对值特征根的情况），反幂法的python伪代码实现：

def rev_power_fn(A, epsilon=1e-6):
    n = len(A)
    x = [1 for _ in range(n)]
    for _ in range(10**3):
        s = math.sqrt(sum(t*t for t in x))
        y = [t/s for t in x]
        z = loose_iter(A, y)
                
        lamda = sum([a/b for a, b in zip(y, z)]) / n
        delta =  max(abs(a-b) for a, b in zip(z, x))
        x = z
        if delta < epsilon:
            break
    return lamda

3. 实对称矩阵的Jacobi方法

1. 思路 & 方法

如前所述，幂法和反幂法本质上都是通过迭代的思路找一个稳定的特征向量，然后通过特征向量来求特征值。

因此，他们只能求取矩阵的某一个特征值，无法对矩阵的全部特征值进行求解。如果要对矩阵的全部特征值进行求解，上述方法就会失效。

但是，对于一些特殊的矩阵，即实对称矩阵，事实上我们是可以对其全部的特征值进行求解的，一种典型的方法就是Jacobi方法。

本质上来说，Jacobi方法依然还是进行迭代，不过其迭代的思路则是不断地对矩阵进行酉变换，使之收敛到一个对角矩阵上面，此时对角矩阵的各个对角元就是原矩阵的特征值。

具体而言，已知$Ax=\lambda x$，有正交矩阵$U$满足$U{U}^T=I$，则有：

$$UA{U}^T\cdot Ux=\lambda \cdot Ux$$

此时，$\lambda$依然是矩阵$UA{U}^T$的特征值。

如果经过一系列变换之后：

$$U_k{U}_{k-1}...U_{1}A{U}_1^T{U}_2^T...U_k^T=diag({\lambda }_1,...,{\lambda }_n)$$

则${\lambda }_1,...,{\lambda }_n$即为矩阵$A$的全部特征值。

剩下的问题就是如何求解这些矩阵$U$，Jacobi方法给出的一种可行的思路是通过Givens矩阵，即：

$$G(p,q,\theta )=\left(\begin{array}{ccccccc}1& & & & & & \\ & ...& & & & & \\ & & cos\theta & ...& sin\theta & & \\ & & ...& & ...& & \\ & & -sin\theta & ...& cos\theta & & \\ & & & & & ...& \\ & & & & & & 1\end{array}\right)$$

也就是说，只对$p,q$两行的元素进行角度为$\theta$的旋转变换。

令:

$$B=G(p,q,\theta )\cdot A\cdot G^T(p,q,\theta )$$

则有：

$$\{\begin{array}{rl}{b}_{i,j}& =a_{i,j}\\ b_{i,p}& =b_{p,i}=a_{p,i}cos\theta -a_{q,i}sin\theta \\ b_{i,q}& =b_{q,i}=a_{p,i}sin\theta +a_{q,i}cos\theta \\ b_{p,p}& =a_{p,p}co{s}^2\theta +a_{q,q}si{n}^2\theta -a_{p,q}sin2\theta \\ b_{q,q}& =a_{p,p}si{n}^2\theta +a_{q,q}co{s}^2\theta +a_{p,q}sin2\theta \\ b_{p,q}& =b_{q,p}=a_{p,q}cos2\theta +\frac{a_{p,p}-a_{q,q}}{2}sin2\theta \end{array}$$

我们取合适的$\theta$，使得$b_{q,p}=0$，则有：

$$\{\begin{array}{rl}\sum _{i\ne j}{b}_{i,j}^2& =\sum _{i\ne j}{a}_{i,j}^2-2a_{p,q}^2\\ \sum _i{b}_{i,i}^2& =\sum _i{a}_{i,i}^2+2a_{p,q}^2\end{array}$$

可以看到，非对角元的元素绝对值会越来越小。

因此，经过足够次数的迭代，可以将原始矩阵$A$变换成为一个特征值相同的近对角矩阵。

而为了进一步提升迭代的速度，可以优先选择绝对值最大的非对角元进行迭代消去。

2. 伪代码实现

同样的，我们给出python伪代码实现如下：

def jacobi_eigen_fn(A, epsilon=1e-6):
    n = len(A)
    assert(len(A[0]) == n)
    assert(A[i][j] == A[j][i] for i in range(n) for j in range(i+1, n))
    
    finished = False
    for _ in range(1000):
        for p in range(n):
            for q in range(p+1, n):
                if A[p][p] != A[q][q]:
                    theta = 0.5 * math.atan(2*A[p][q] / (A[q][q] - A[p][p]))
                else:
                    theta = math.pi / 4
                ap = deepcopy(A[p])
                aq = deepcopy(A[q])
                for i in range(n):
                    if i == p or i == q:
                        continue
                    A[i][p] = A[p][i] = ap[i] * math.cos(theta) - aq[i] * math.sin(theta)
                    A[i][q] = A[q][i] = ap[i] * math.sin(theta) + aq[i] * math.cos(theta)
                A[p][p] = ap[p] * math.cos(theta)**2 + aq[q] * math.sin(theta)**2 - ap[q] * math.sin(2*theta)
                A[q][q] = ap[p] * math.sin(theta)**2 + aq[q] * math.cos(theta)**2 + ap[q] * math.sin(2*theta)
                A[p][q] = A[q][p] = ap[q] * math.cos(2 * theta) + (ap[p] - aq[q])/2 * math.sin(2*theta)
                
                finished = all(A[i][j] < epsilon for i in range(n) for j in range(i+1, n))
                if finished:
                    break
            if finished:
                break
        if finished:
            break
    return [A[i][i] for i in range(n)]