【线性代数】施密特正交化方法——Python实现_施密特正交化python

思想

施密特正交化方法：
将n维子空间中的任意一组基向量变换成标准正交向量。

假设有两个向量$\vec{a}$和$\vec{b}$，若要使两向量正交，则$\vec{a}$不变，$\vec{b}$可分解为$\vec{b}$在$\vec{a}$上的投影$\overrightarrow{b^{\prime }}$和误差向量$\vec{e}$。因为$\vec{a}$和$\vec{e}$正交，所以将$\vec{a}$和$\vec{e}$标准化后，即为一组标准正交向量。

设初始矩阵为$A=[a_1,a_2,a_3,...,a_n]$，$a_i$是$m\times 1$的列向量$(i\in (1,n))$，则$A$是$m\times n$的矩阵。
设要求的一组正交向量为$P=[p_1,p_2,p_3,...,p_n]$。
首先可知$p_1=a_1$。
其次求$p_2$，即求$a_2$在$p_1$投影的误差向量。
$a_2$在$p_1$投影向量的投影系数$x_{21}=(p_1^T{p}_1{)}^{-1}{p}_1^T{a}_2$。
投影向量$a_2^{\prime }=p_1(p_1^T{p}_1{)}^{-1}{p}_1^T{p}_2$。
$p_2=a_2-a_2^{\prime }=a_2-p_1(p_1^T{p}_1{)}^{-1}{p}_1^T{a}_2$。
再次求$p_2$，即求$a_3$在$p_1$和$p_2$构成的平面上投影的误差向量。
$a_3$在$p_1$和$p_2$构成的平面上投影向量可以写成$p_1$和$p_2$的和。
投影系数为$x_{31}=(p_1^T{p}_1{)}^{-1}{p}_1^T{a}_3$和$x_{32}=(p_2^T{p}_2{)}^{-1}{p}_2^T{a}_3$
投影向量$a_3^{\prime }=p_1(p_1^T{p}_1{)}^{-1}{p}_1^T{a}_3+p_2(p_2^T{p}_2{)}^{-1}{p}_2^T{a}_3$。
$p_3=a_3-a_3^{\prime }=a_3-[p_1(p_1^T{p}_1{)}^{-1}{p}_1^T{a}_3+p_2(p_2^T{p}_2{)}^{-1}{p}_2^T{a}_3]$。
……
用此方法迭代即可求出这一组正交向量$P$。
然后将其标准化。
设标准正交矩阵为$Q=[q_1,q_2,q_3,...,q_n]$。
标准化方法为$q_i=\frac{p_i}{|p_i|}(i\in (1,n))$

Python代码

import numpy as np
from scipy import linalg

def matmul_mulelms(*matrixs):
    '''
    连乘函数。将输入的矩阵按照输入顺序进行连乘。

    Parameters
    ----------
    *matrixs : 矩阵
        按计算顺序输入参数.

    Raises
    ------
    ValueError
        当参数个数小于2时，不满足乘法的要求.

    Returns
    -------
    res : 矩阵
        返回连乘的结果.

    '''
    if len(matrixs)<2:
        raise ValueError('Please input more than one parameters.')
    res = matrixs[0]
    for i in range(1,len(matrixs)):
        res = np.matmul(res, matrixs[i])
    return res

# 3.3.4 施密特正交化
def One_Col_Matrix(array):
    '''
    确保为列矩阵

    Parameters
    ----------
    array : 矩阵，向量或数组

    Raises
    ------
    ValueError
        获得的参数不是1xn或mx1时，报错.

    Returns
    -------
    TYPE
        返回列矩阵.

    '''
    mat = np.mat(array)
    if mat.shape[0] == 1:
        return mat.T
    elif mat.shape[1] == 1:
        return mat
    else:
        raise ValueError('Please input 1 row array or 1 column array')

def Transfor_Unit_Vector(matrix):
    '''
    将每列都转换为标准列向量，即模等于1

    Parameters
    ----------
    matrix : 矩阵

    Returns
    -------
    unit_mat : 矩阵
        每列模都为1的矩阵.

    '''
    col_num = matrix.shape[1]
    # 初始化为零矩阵
    unit_mat = np.zeros((matrix.shape))
    for col in range(col_num):
        vector = matrix[:,col]
        unit_vector = vector / np.linalg.norm(vector)
        unit_mat[:,col] = unit_vector.T
    return unit_mat

def Gram_Schmidt_Orthogonality(matrix):
    '''
    施密特正交化方法

    Parameters
    ----------
    matrix : 矩阵

    Returns
    -------
    标准正交化矩阵。

    '''
    col_num = matrix.shape[1]
    # 第一列无需变换
    gram_schmidt_mat = One_Col_Matrix(matrix[:,0])
    for col in range(1,col_num):
        raw_vector = One_Col_Matrix(matrix[:,col])
        orthogonal_vector = One_Col_Matrix(matrix[:,col])
        if len(gram_schmidt_mat.shape)==1:
            # 当矩阵为列向量是，shape的返回值为“(row,)”，没有col的值
            gram_schmidt_mat_col_num = 1
        else:
            gram_schmidt_mat_col_num = gram_schmidt_mat.shape[1]
        for base_vector_col in range(gram_schmidt_mat_col_num):
            base_vector = gram_schmidt_mat[:,base_vector_col]
            prejective_vector = matmul_mulelms(base_vector, linalg.inv(np.matmul(base_vector.T,base_vector)), base_vector.T, raw_vector)
            orthogonal_vector = orthogonal_vector - prejective_vector
        gram_schmidt_mat = np.hstack((gram_schmidt_mat,orthogonal_vector))
    #print(gram_schmidt_mat)
    return Transfor_Unit_Vector(gram_schmidt_mat)
### 测试用例
A = np.array([[1,1,1],
              [-1,0,-1],
              [0,-1,1]])
print(Gram_Schmidt_Orthogonality(A))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117