解对称正定矩阵线性方程组的平方根方法

0. 引言

在求解线性方程组中，有一类比较特殊的系数矩阵即对称正定矩阵的方程求解。这一类矩阵方程使用普通线性方程求解的方法比较繁琐。平方根方法是一种对称正定矩阵的一种三角分解方法，下面介绍这一中方法。

1. 对称正定矩阵线性方程组

1.1 对称正定矩阵及其三角分解法

什么是对称形式的正定矩阵？
定义 设$A\in {\mathbb{R}}^{n\times n}$，如果矩阵$A$满足：
(1) $A^T=A$；
(2) $\forall x\in {\mathbb{R}}^n$并且$x\ne 0,xAx>0$。
则称$A$为对称正定矩阵。
性质 设矩阵$A$是对称正定阵，那么它必有以下的性质：
(1) $A$是非奇异矩阵，并且$A^{-1}$也是对称正定阵；
(2) $A$的顺序主子阵$A_k,(k=1,2,...,n)$是对称正定阵；
(3) $A$的顺序主子式都大于零，即$\det (A_k)>0,(k=1,2,...,n)$；
(4) $A$的特征值${\lambda }_i(A)>0,(i=1,2,...,n)$。

对于性质(1)，由于$A^T=A$，所以$A^{-1}=(A^T{)}^{-1}=(A^{-1}{)}^T$，证毕。
对于性质(3)，设$\lambda$为$A\in {\mathbb{R}}^{n\times n}$的一个实特征值，$x\in R^n$是$\lambda$对应的特征向量，那么$Ax=\lambda x$，故而$\lambda x^{T}x=x^{T}Ax>0$，从而有$\lambda >0$。

对称正定矩阵的判别方法(充分条件)
(1) 如果$A\in {\mathbb{R}}^{n\times n}$是对称矩阵，并且$\det A_k>0,(k=1,2,...,n)$，那么$A$是正定阵。
(2) 如果$A\in {\mathbb{R}}^{n\times n}$是对称矩阵，$A$的特征值${\lambda }_i>0,(i=1,2,...,n)$，则$A$是对称正定阵。
对称矩阵的三角分解方法
首先我们引入下面的定理：
定理一：对于任意矩阵$X\in {\mathbb{R}}^{n\times n}$，若$X$的各阶顺序主子式均不为零，那么$X$具有唯一的Doolittle分解：$X=\tilde{L}\tilde{U}$，其中$\tilde{L},\tilde{U}$分别为下三角矩阵和上三角矩阵。
定理二：若矩阵$X\in {\mathbb{R}}^{n\times n}$是非奇异矩阵，并且Doolittle分解存在，则Doolittle分解是唯一的。
特别地，对于三角矩阵$\tilde{L},\tilde{U}$我们可以分解为$\tilde{L}=L{D}_1,\tilde{U}=D_{2}U$，其中$L,U$是单位三角矩阵，$D_1,D_2$是对角矩阵。所以对于矩阵$A$，则有
$$X=\tilde{L}\tilde{U}=L{D}_1{D}_{2}U$$

设$D=D_1{D}_2$，所以对于一般矩阵来说，可以分解为一个下三角矩阵、对角矩阵和一个上三角矩阵的乘积，并且这样的分解唯一：
$$X=LDU$$

现在，我们设$A$是实对称正定矩阵，根据定理一以及对称正定矩阵的性质我们可以知道，存在Doolittle分解，所以必存在唯一的上三角矩阵$L$，对角矩阵$D$以及下三角矩阵$U$以及对角矩阵$D$，使得
$$A=LDU$$

根据对称矩阵的性质可知$A=A^T$，所以得到
$$LDU=U^T{D}^T{L}^T=U^{T}D{L}^T$$
由于唯一性可以得到$L=U^T,U=L^T$，所以有
$$A=L^{T}DL$$
其中，对角矩阵$D=\text{diag}(d_1,d_2,...,d_n)$的元素$d_k$由下面的表达式给出
$$\{\begin{array}{ll}{d}_1=D_1>0& \\ d_k=\frac{D_k}{D_{k-1}}>0& ,k=2,3,..,n\end{array}$$
其中$D_k=\det (A_k)$为$A$的顺序主子式。从而得到
$$D=\text{diag}(\sqrt{d_1},\sqrt{d_2},...,\sqrt{d_n})\cdot \text{diag}(\sqrt{d_1},\sqrt{d_2},...,\sqrt{d_n})$$

令$D^{1/2}=\text{diag}(\sqrt{d_1},\sqrt{d_2},...,\sqrt{d_n})$那么上式就可以写为$D=D^{1/2}{D}^{1/2}$（唯一）。从而得到
$$A=L^T{D}^{1/2}{D}^{1/2}L=M^{T}M$$

其中$M$为下三角矩阵并且对角线元素大于$0$。所以我们有以下的分解定理：
定理 对称正定矩阵的Cholesdy分解：若$A\in {\mathbb{R}}^{n\times n}$为正定阵，则存在唯一的具有正对角元的下三角阵$M$，使得$A=M^{T}M$。
通过上述的定理推论，我们来求解对称正定矩阵中的线性方程组求法。

1.2 平方根法

基本求解思路：
(1) 分解对称正定矩阵$A=M^{T}M$；
(2) 求解$Ax=b$即求解$M^{T}Mx=b$。
所以最终求解方法即为：
$$\{\begin{array}{ll}{M}^{T}y=b& ,\text{ solve }y\\ Mx=y& ,\text{ solve }x\end{array}$$
设$n$阶对称正定矩阵$A$有分解$A=L{L}^T$，令
$$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ :& :& :& :\\ a_{n1}& a_{n2}& ...& a_{nn}\end{array}\right]=\left[\begin{array}{cccc}{l}_{11}& & & \\ l_{21}& l_{22}& & \\ :& :& & \\ l_{n1}& l_{n2}& ...& l_{nn}\end{array}\right]\left[\begin{array}{cccc}{l}_{11}& l_{12}& ...& l_{1n}\\ & l_{22}& ...& l_{2n}\\ & & :& :\\ & & & l_{nn}\end{array}\right]$$

可以看出，必有以下的等式关系：
$$a_{ij}=\sum _{k=1}^n{l}_{ik}{l}_{jk}=\sum _{j-1}^{k=1}{l}_{ik}{l}_{jk}+l_{ij}{l}_{jj}$$

其中，当$k>j$时候，$l_{jk}=0$，所以我们求解对称正定方程组$Ax=b$时候，计算过程如下所示：
输入 对称矩阵$A$以及$b$

1. 分解计算$A=L{L}^T$
   $\text{ repeat }i=1\text{ to }n$
   $$\begin{gathered} l_{ij}=(a_{ij}-\sum _{k=1}^{j-1}{l}_{ik}{l}_{jk})/l_{jj},(j=1,2,...,i-1)(j<i) \\ {l}_{ii}=(a_{ii}-\sum _{k=1}^{i-1}{l}_{ik}^2{)}^{1/2}(i=1,2,...,n) \end{gathered}$$
   $\text{ end }$
2. 求解计算
   $$\{\begin{array}{ll}Ly=b& ,\text{ solve }y\\ L^{T}x=y& ,\text{ solve }x\end{array}$$
   $\text{repeat i = 1 to n}$
   $$y_i=(b_i-\sum _{k=1}^{i-1}{l}_{ik}{y}_k)/l_{ii}$$
   $\text{end}$
   $\text{ repeat }i=n\text{ to }1$
   $$x_i=(y_i-\sum _{k=i+1}^n{l}_{ki}{x}_k)/l_{ii}$$
   $\text{end}$

输出 未知向量$x$的解

平方根方法有一些优点，
(1) 计算量比较小，计算复杂度为$O(n^3)$(实际上大约是$n^3/6$次乘除法)，是一般矩阵$A$的Doolittle分解计算量的一半。
(2) 计算数值稳定。
缺点：计算$l_{ii}$的时候需要开方，增加了计算量。

1.3 改进平方根法

设对称正定矩阵$A$有分解$A=LD{L}^T$，其中$L$为单位下三角阵，$D$为对角阵，即有
$$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ :& :& :& :\\ a_{n1}& a_{n2}& ...& a_{nn}\end{array}\right]=\left[\begin{array}{cccc}{l}_{11}& & & \\ l_{21}& l_{22}& & \\ :& :& & \\ l_{n1}& l_{n2}& ...& l_{nn}\end{array}\right]\left[\begin{array}{cccc}{d}_1& & & \\ & d_2& & \\ & & ...& \\ & & & d_n\end{array}\right]\left[\begin{array}{cccc}{l}_{11}& l_{12}& ...& l_{1n}\\ & l_{22}& ...& l_{2n}\\ & & :& :\\ & & & l_{nn}\end{array}\right]$$
设$d_1=a_{11}$，则
$$a_{ij}=\sum _{k=1}^n(LD{)}_{ik}(L^T{)}_{kj}=\sum _{k=1}^{j-1}(l_{ik}{d}_k)l_{jk}+l_{ij}{d}_j$$

特别地，和平方根方法类似，当$k>j$时，$l_{jk}=0$。故而有以下的$n$阶对称正定矩阵$A$的$LD{L}^T$分解公式：
(1) $d_1=a_{11}$；
(2) 当$i=2,3,...,n$时，
$$\begin{gathered} l_{ij}=(a_{ij}-\sum _{k=1}^{j-1}{l}_{ik}{d}_k{l}_{jk})/d_j,(j=1,2,..,i-1) \\ {d}_i=a_{ii}-\sum _{k=1}^{i-1}{l}_{ik}^2{d}_k \end{gathered}$$

综上所述，改进平方根方法的计算过程如下所示：
输入 矩阵系数$A$以及$b$

1. 分解计算$A=LD{L}^T$
   $d_1=a_{11}$
   $\text{repeat}i=2\text{ to }n$
   令$t_{ij}=l_{ij}{d}_j$，
   $t_{ij}=a_{ij}-\sum _{k=1}^{j-1}{t}_{ik}{l}_{jk},(j=1,2,...,i-1)$
   $l_{ij}=t_{ij}/d_j,(j=1,2,...,i-1)$
   $d_i=a_{ii}-\sum _{k=1}^{i-1}{t}_{ik}{l}_{ik}$
   $\text{end}$
2. 求解计算
   $$\{\begin{array}{ll}Ly=b& ,\text{ solve }y\\ L^{T}x=D^{-1}y& ,\text{ solve }x\end{array}$$
   $y_1=b_1$
   $y_i=b_i-\sum _{k=1}^{i-1}{l}_{ik}{y}_k,(i=2,...,n)$
   $x_n=y_n/d_n$
   $x_i=y_i/d_i-\sum _{k=i+1}^n{l}_{ki}{x}_k,(i=n-1,..,2,1)$

输出 未知向量$x$
改进平方根算法中具有以下的优点：
(1) 没有开方运算；
(2) 计算量比较小，大约为$n^3/6$次乘除法运算，同平方根方法类似，是Doolittle分解方法中计算量的一半，是一种有效的求解对称正定矩阵方程组的方法。
(3) 计算精度较高，不需要选定主元。
缺点：元素的存储量比较大。

1.4 代码实现

平方根方法和改进版平方根方法的核心代码大同小异。平方根方法的核心代码如下所示：

def cholesky_LLT(A):
    if A.ndim!=2 :
        raise ValueError("size of matrix doesn't match!")
    m,n = A.shape
    if m!=n:
        raise ValueError("size of matrix doesn't match!")
    # calculate the matrix L
    L = np.zeros(A.shape,dtype = np.float)
    n = A.shape[0]
    for i in range(0,n):
        for j in range(0,n):
            if i < j+1:
                if j>0:
                    L[j,j] = np.sqrt(A[j,j]-np.sum(L[j,0:j]*L[j,0:j]))
                else:
                    L[j,j] = np.sqrt(A[j,j])
            else:
                if j>0:
                    L[i,j] = (A[i,j] - np.sum(L[i,0:j]*L[j,0:j]))/L[j,j]
                else:
                    L[i,j] = A[i,j]/L[j,j]
    return L
def cholesky_LLT_solve(A,b):
    n,_ = A.shape
    L = cholesky_LLT(A)
    y = np.zeros(n)
    x = y.copy()
    for i in range(0,n):
        if i == 0:
            y[i] = b[i]/L[i,i]
        else:
            y[i] = (b[i] - np.sum(L[i,0:i]*y[0:i]))/L[i,i]
    for i in range(n-1,-1,-1):
        if i == n-1:
            x[i] = y[i]/ L[i,i]
        else:
            x[i] = (y[i] - np.sum(L[i+1:n,i]*x[i+1:n]))/L[i,i]
    return x

改进版平方根方法的核心代码如下所示：

def cholesky_LDLT(A):
    if A.ndim != 2:
        raise ValueError("size of matrix doesn't match!")
    m, n = A.shape
    if m != n:
        raise ValueError("size of matrix doesn't match!")
    # calculate the matrix L
    L = np.zeros(A.shape, dtype=np.float)
    T = np.zeros(A.shape,dtype=np.float)
    n = A.shape[0]
    D = np.zeros(n,dtype=np.float)
    for i in range(0,n):
        if i >0:
            for j in range(0,n):
                if i<j+1:
                    pass
                else:
                    if j > 0:
                        T[i, j] = A[i, j] - np.sum(T[i, 0:j] * L[j, 0:j])
                        L[i,j] = T[i,j]/D[j]
                    else:
                        T[i, j] = A[i, j]
                        L[i,j] = T[i,j]/D[j]
            D[i] = A[i,i] - np.sum(T[i,0:i]*L[i,0:i])
        else:
            D[i] = A[i,i]
    return L,D
def cholesky_LDLT_solve(A,b):
    n, _ = A.shape
    L,D = cholesky_LDLT(A)
    y = np.zeros(n)
    x = y.copy()
    for i in range(0,n):
        if i>0:
            y[i] = b[i] - np.sum(L[i,0:i]*y[0:i])
        else:
            y[i] = b[i]
    for i in range(n-1,-1,-1):
        if i == n-1:
            x[i] = y[i]/D[i]
        else:
            x[i] = y[i]/D[i]-np.sum(L[i+1:n,i]*x[i+1:n])
    return x

完整的代码版本参见笔者github

2. 应用举例：最小二乘法多项式拟合函数

2.1 最小二乘法拟合多项式

假设我们现在有一个数据集：
D = { x k , y k } k = 1 N D=\{x_{k},y_{k}\}_{k=1}^{N} D={ xk​,yk​}k=1N​

对于给定的数据集，我们使用$M$阶多项式进行曲线拟合，即
$$f(x)=\sum _{j=0}^M{w}_j{x}^j$$

为了使得拟合出的近似曲线能够尽量反映出所给数据的变化趋势，所以我们要求在所有数据点上的残差都比较小：
$${\delta }_k=|f(x_k)-y_k|$$

为了达到上述目标值，我们使用平方项之和使得上述求解的值最小：
$$Q=\sum _{k=1}^N{\delta }_k^2=\sum _{k=1}^N(y_k-f(x_k){)}^2$$

称这种方法为最小二乘法原则。
为了求解出使得总残差项$Q$最小，我们对每一个参数$w_k$进行求导，并且使其导数值为0：
$$\frac{\partial Q}{\partial w_j}=\sum _{k=1}^N\frac{\partial f}{\partial w_j}\cdot 2(y_k-f(x_k))=2\sum _{k=1}^N{x}_k^j(y_k-f(x_k))=0$$

对于每一个求导值，会有以下的一个结果：
$$\frac{\partial Q}{\partial w_j}=\sum _{k=1}^N\frac{\partial f}{\partial w_j}\cdot 2(y_k-f(x_k))=2\sum _{k=1}^N{x}_k^j(y_k-f(x_k))=0$$

所以得到

$$\sum _{k=1}^N{x}_k^{j}f(x_k)=\sum _{k=1}^N{x}_k^j{y}_k$$

从而得到一个线性方程组：
$$\left[\begin{array}{cccccc}N& \sum _{k=1}^N{x}_k& ...& \sum _{k=1}^N{x}_k^j& ...& \sum _{k=1}^N{x}_k^M\\ \sum _{k=1}^N{x}_k& \sum _{k=1}^N{x}_k^2& ...& \sum _{k=1}^N{x}_k^{j+1}& ...& \sum _{k=1}^N{x}_k^{M+1}\\ :& :& :& :& :& :\\ \sum _{k=1}^N{x}_k^M& \sum _{k=1}^N{x}_k^{M+2}& ...& \sum _{k=1}^N{x}_k^{j+M}& ...& \sum _{k=1}^N{x}_k^{2M}\end{array}\right]\left[\begin{array}{c}{w}_0\\ w_1\\ :\\ w_j\\ :\\ w_M\end{array}\right]=\left[\begin{array}{c}\sum _{k=1}^N{y}_k\\ \sum _{k=1}^N{x}_k{y}_k\\ :\\ \sum _{k=1}^N{x}_k^j{y}_k\\ :\\ \sum _{k=1}^N{x}_k^M{y}_k\end{array}\right]$$

显然，求解参数的值化为求解线性方程组值的问题。系数矩阵是一个实对称矩阵，那么求解这个问题，首先计算系数矩阵，然后通过Cholesdy分解的办法实现系数的求解过程。
为防止数据的过拟合现象，一般情况下添加有系数的正则化项来减缓数据的过拟合因素：
$$Q=\sum _{k=1}^N{\delta }_k^2+\frac{\lambda }{2}||w|{|}^2=\sum _{k=1}^N(y_k-f(x_k){)}^2+\frac{\lambda }{2}\sum _{k=1}^M{w}_k^2$$

所以求导之后变为
$$\frac{\partial Q}{\partial w_j}=2\sum _{k=1}^N{x}_k^j(y_k-f(x_k))+\lambda w_j$$

即
$$\sum _{k=1}^N{x}_k^j{y}_k=\sum _{k=1}^N{x}_k^{j}f(x_k)-\frac{\lambda }{2}{w}_j$$

用归纳法可以证明，当$\lambda =0$时候，系数矩阵$A$是实对称正定矩阵。

2.2 代码实现

我们这里使用到了numpy库来实现上述的对称矩阵线性方程组的算法。首先我们随机的生成一些数据。
首先，我们生成一些多项式拟合的数据，数据在图中如下所示：

算法的核心代码如下所示

import numpy as np
from model import cholesky_LDLT_solve
class Polynomial:
    def __init__(self,degree,lambd=0):
        self.degree = degree
        self.lambd = lambd
        self.Mat = None
        self.Bais = None
        self.weight = None
    def fit(self,input,target):
        if input.shape != target.shape:
            raise ValueError("size of matrix doesn't match!")
        degree = self.degree
        self.Mat = np.zeros((degree,degree))
        self.Bais = np.zeros(degree)
        for k in range(degree):
            for j in range(degree):
                self.Mat[k,j] = np.sum(np.power(input,k+j))
        for j in range(degree):
            self.Mat[k,j] -= self.lambd/2
            self.Bais[j] = np.sum(np.power(input,j)*target)
        self.weight = cholesky_LDLT_solve(self.Mat,self.Bais)
    def regress(self,input):
        if type(input)==np.ndarray:
            if input.ndim !=1:
                raise ValueError("size of matrix doesn't match!")
            output = np.zeros(input.shape)
            for i in range(len(input)):
                output[i] = np.sum(np.power(input[i],np.arange(self.degree))*self.weight)
            return output
        elif type(input) == float or type(input) == int:
            output = np.sum(np.power(input,np.arange(self.degree))*self.weight)
            return output
        else:
            raise ValueError("Unknown type:%s"%type(input))

数据模拟的效果

完整的代码参见笔者的github

参考文献

[1] https://wenku.baidu.com/view/1c454f27af45b307e8719736.html
[2] https://blog.csdn.net/orangefly0214/article/details/80383456
[3] Pattern recognition and machine learning，BiShop.