人工智能必备数学知识学习笔记7：矩阵的应用和更多矩阵相关的高级话题

• 更多变换矩阵

 

 

 

 

 

 

 

 

 

---

---

• 矩阵旋转变换和矩阵在图形学中的应用

 

 

 

  

 

 仿射变换：（百度百科 https://baike.baidu.com/item/%E4%BB%BF%E5%B0%84%E5%8F%98%E6%8D%A2/4289056?fr=aladdin）

仿射变换，又称仿射映射，是指在几何中，一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间。

 图形学：（百度百科：https://baike.baidu.com/item/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9B%BE%E5%BD%A2%E5%AD%A6/279486?fr=aladdin）

 代码实现：

1.在 main_matrix_transformation.py中编写代码：

import matplotlib.pyplot as plt
import math
from playLA.Matrix import Matrix
from playLA.Vector import Vector

# 绘图数学库 matplotlib
if __name__ == "__main__":

    points = [[0,0], [0,5], [3,5], [3,4], [1,4],
              [1,3], [2,3], [2,2], [1,2], [1,0]]

    x = [point[0] for point in points]
    y = [point[1] for point in points]

    # 根据点来绘制图案
    plt.figure(figsize=(5,5))# 设置绘制窗口的大小（单位：英尺）
    plt.xlim(-10,10)# 设置窗口坐标系x轴的范围
    plt.ylim(-10,10)# 设置窗口坐标系y轴的范围

    plt.plot(x,y)# 输入绘制点
    #plt.show()# 窗口展示

    # 将矩阵 P 进行转换
    P = Matrix(points)

    #T = Matrix([[2,0],[0,1.5]])   # 将矩阵 P 横坐标扩大2倍，纵坐标扩大1.5倍
    #T = Matrix([[1,0],[0,-1]])     # 将矩阵 P 进行x轴翻转
    #T = Matrix([[-1,0],[0,1]])       # 将矩阵 P 进行y轴翻转
    #T = Matrix([[-1, 0], [0, -1]])  # 将矩阵 P 进行原点对称
    #T = Matrix([[1, 0.5], [0, 1]])  # 将矩阵 P 进行沿着x轴错切操作
    #T = Matrix([[1, 0], [0.5, 1]])  # 将矩阵 P 进行沿着y轴错切操作

    #旋转操作
    theta = math.pi / 3 #三分之一π，也就是60度
    T = Matrix([[math.cos(theta),math.sin(theta)], [-math.sin(theta),math.cos(theta)]])

    P2 = T.dot(P.T()) # T 点乘已转置后的矩阵P
    plt.plot([P2.col_vector(i)[0] for i in range(P2.col_num())],
             [P2.col_vector(j)[1] for j in range(P2.col_num())])
    plt.show()

2.运行 main_matrix_transformation.py 结果为：

根据点来绘制图案

 

将矩阵 P 横坐标扩大2倍，纵坐标扩大1.5倍

 

 将矩阵 P 进行x轴翻转

将矩阵 P 进行y轴翻转

将矩阵 P 进行原点对称

将矩阵 P 进行沿着x轴错切操作

将矩阵 P 进行沿着y轴错切操作

旋转操作：三分之一π，也就是60度

 

---

---

• 从缩放变换到单位矩阵

 

 

 

 

 

 非方形矩阵：需要单位矩阵的列数等于长方形矩阵的行数

---

---

• 矩阵的逆

 

 

 

 代码实现：

 1.在Matrix.py编写代码:单位矩阵类方法：返回一个n行n列的单位矩阵

#矩阵类
from playLA.Vector import Vector


class Matrix:
    # 参数2：二维数组
    def __init__(self, list2d):
        self._values = [row[:] for row in list2d]#将数组变为矩阵

    #矩阵类方法:返回一个r行c列的零矩阵：参数1：为零的类对象
    @classmethod
    def zero(cls,r,c):
        return cls([[0] * c for _ in range(r)]) #创建一个r行c列为零的一个列表

    #单位矩阵类方法：返回一个n行n列的单位矩阵
    @classmethod
    def identity(cls, n):
        m = [[0] * n for _ in range(n)] #此处 m 代表有 n 行，每一行有 n 个 0
        for i in range(n):
            m[i][i] = 1  #此处代表将矩阵 m 的 第i行的第i个元素赋值为1
        return cls(m)

    #返回矩阵的转置矩阵
    def T(self):
        #将每一行的相同位置（每一列）元素提取出来变为行组成新的矩阵
        return Matrix([[e for e in self.col_vector(i)]
                       for i in range(self.col_num())])

    #返回两个矩阵的加法结果
    def __add__(self, another):
        # 校验两个矩阵的形状为一致（行数、列数一致）
        assert self.shape() == another.shape(), 
            "Error in adding. Shape of matrix must be same."
        # 根据矩阵的加法公式：两个矩阵对应的每一行的每一个元素相加，获得新的矩阵(遍历两个矩阵对应的每一个行每个元素进行相加<第二步>，外部再遍历该矩阵的行数（循环的次数）<第一步>)
        return Matrix([[a+b for a,b in zip(self.row_vector(i),another.row_vector(i))]
                       for i in range(self.row_num())])

    # 返回两个矩阵的减法结果
    def __sub__(self, another):
        assert self.shape() == another.shape(), 
            "Error in subtracting. Shape of matrix must be same."
        return Matrix([[a - b for a, b in zip(self.row_vector(i), another.row_vector(i))]
                       for i in range(self.row_num())])

    #返回两个矩阵的乘法结果（矩阵乘以矩阵）
    def dot(self,another):
        if isinstance(another,Vector):#判断是否为向量：矩阵与向量的乘法
            assert self.col_num() == len(another),
                "Error in Matrix_Vector Multiplication." #矩阵与向量的乘法错误
            return Vector([self.row_vector(i).dot(another) for i in range(self.row_num())])
        if isinstance(another,Matrix):#判断是否为矩阵：矩阵与矩阵的乘法
            assert self.col_num() == another.row_num(),
                "Error in Matrix-Matrix Multiplication." #矩阵与矩阵的乘法错误
            # 将矩阵的每一行与另一矩阵的每一列进行向量间的点乘
            return Matrix([[self.row_vector(i).dot(another.col_vector(j)) for j in range(another.col_num())]
                            for i in range(self.row_num())])

    #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
    def __mul__(self, k):
        #通过遍历每一行的每个元素e后分别乘以k<第一步>，外部再遍历该矩阵的行数（循环的次数）<第二步>
        return Matrix([[e * k for e in self.row_vector(i)]
                       for i in range(self.row_num())])

    # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
    def __rmul__(self, k):
        return self * k

    #返回数量除法的结果矩阵：self / k
    def __truediv__(self, k):
        return (1 / k) * self

    #返回矩阵取正的结果
    def __pos__(self):
        return 1 * self

    #返回矩阵取负的结果
    def __neg__(self):
        return -1 * self

    #返回矩阵的第index个行向量
    def row_vector(self,index):
        return Vector(self._values[index])

    # 返回矩阵的第index个列向量
    def col_vector(self, index):
        return Vector([row[index] for row in self._values])

    #返回矩阵pos位置的元素(根据元素的位置取元素值) :参数2：元组
    def __getitem__(self, pos):
        r,c = pos
        return self._values[r][c]

    #返回矩阵的元素个数
    def size(self):
        r,c = self.shape()
        return r*c

    #返回矩阵行数
    def row_num(self):
        return self.shape()[0]

    __len__ = row_num

    #返回矩阵列数
    def col_num(self):
        return self.shape()[1]

    #返回矩阵形状：（行数，列数）
    def shape(self):
        return len(self._values),len(self._values[0])

    #矩阵展示
    def __repr__(self):
        return "Matrix({})".format(self._values)

    __str__ = __repr__

 2.在main-matrix.py编写代码:单位矩阵类方法：返回一个n行n列的单位矩阵

from playLA.Matrix import Matrix
from playLA.Vector import Vector

if __name__ == "__main__":
    #生成一个矩阵
    matrix = Matrix([[1,2],[3,4]])
    print(matrix)
    #矩阵的行数和列数（返回矩阵形状：（行数，列数））
    print("matrix.shape = {}".format(matrix.shape()))
    #返回矩阵的元素个数
    print("matrix.size = {}".format(matrix.size()))
    print("len(matrix) = {}".format(len(matrix)))
    #根据元素的位置取元素值
    print("matrix[0][0] = {}".format(matrix[0,0]))
    # 返回矩阵的第index个行向量
    print("matrix.row_vector = {}".format(matrix.row_vector(0)))
    # 返回矩阵的第index个列向量
    print("matrix.col_vector = {}".format(matrix.col_vector(0)))

    # 返回两个矩阵的加法结果
    matrix2 = Matrix([[5,6],[7,8]])
    print("add:{}".format(matrix + matrix2))
    # 返回两个矩阵的减法结果
    print("subtract:{}".format(matrix - matrix2))
    #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
    print("scalar-mul:{}".format(matrix * 2))
    # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
    print("scalar-mul:{}".format(2 * matrix))
    # 零矩阵类方法:返回一个2行3列的零矩阵
    print("zero_2_3:{}".format(Matrix.zero(2,3)))

    # 返回两个矩阵的乘法结果（矩阵乘以矩阵）
    T = Matrix([[1.5,0],[0,2]])
    p = Vector([5,3])
    print("T.dot(p) = {}".format(T.dot(p)))
    P = Matrix([[0,4,5],[0,0,3]])
    print("T.dot(P) = {}".format(T.dot(P)))
    print("matrix.dot(matrix2) = {}".format(matrix.dot(matrix2)))
    print("matrix2.dot(matrix) = {}".format(matrix2.dot(matrix)))

    # 返回矩阵的转置矩阵
    print("P.T = {}".format(P.T()))

    #单位矩阵类方法：返回一个n行n列的单位矩阵
    I = Matrix.identity(2)
    print(I)
    print("A.dot(I) = {}".format(matrix.dot(I)))
    print("I.dot(A) = {}".format(I.dot(matrix)))

3.运行main_matrix.py结果为：

/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/pydevconsole.py --mode=client --port=52708
import sys; print('Python %s on %s' % (sys.version, sys.platform))
sys.path.extend(['/Users/liuxiaoming/PycharmProjects/LinearAlgebra'])
PyDev console: starting.
Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) 
[Clang 6.0 (clang-600.0.57)] on darwin
>>> runfile('/Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_matrix.py', wdir='/Users/liuxiaoming/PycharmProjects/LinearAlgebra')
Matrix([[1, 2], [3, 4]])
matrix.shape = (2, 2)
matrix.size = 4
len(matrix) = 2
matrix[0][0] = 1
matrix.row_vector = (1, 2)
matrix.col_vector = (1, 3)
add:Matrix([[6, 8], [10, 12]])
subtract:Matrix([[-4, -4], [-4, -4]])
scalar-mul:Matrix([[2, 4], [6, 8]])
scalar-mul:Matrix([[2, 4], [6, 8]])
zero_2_3:Matrix([[0, 0, 0], [0, 0, 0]])
T.dot(p) = (7.5, 6)
T.dot(P) = Matrix([[0.0, 6.0, 7.5], [0, 0, 6]])
matrix.dot(matrix2) = Matrix([[19, 22], [43, 50]])
matrix2.dot(matrix) = Matrix([[23, 34], [31, 46]])
P.T = Matrix([[0, 0], [4, 0], [5, 3]])
Matrix([[1, 0], [0, 1]])
A.dot(I) = Matrix([[1, 2], [3, 4]])
I.dot(A) = Matrix([[1, 2], [3, 4]])

4. (矩阵再numpy中的应用)文件 main_numpy_vector.py 编写代码:单位矩阵、逆矩阵

import numpy as np

if __name__ == "__main__":

    #矩阵的创建
    A =np.array([[1,2],[3,4]])
    print(A)

    #矩阵的属性
    print(A.shape)#矩阵的形状（行数、列数）
    print(A.T)#矩阵的转置

    #获取矩阵的元素(从零开始计算)
    print(A[1,1])#矩阵的某个元素
    print(A[0])#矩阵的行向量 等价于 A([0,:])
    print(A[:,0])#矩阵的列向量（两个索引：索引1：冒号取全部行，索引2：某一列）

    #矩阵的基本运算
    B = np.array([[5,6],[7,8]])
    print("A + B = {}".format(A + B))
    print("A - b = {}".format(A - B))
    print("10 * A = {}".format(10 * A))
    print("A * 10 = {}".format(A * 10))
    print(A * B)#矩阵中每个元素对应元素相乘而已（不是线性代数中的矩阵相乘）
    print("A.dot(B) = {}".format(A.dot(B)))#矩阵之间相乘

    p = np.array([10,100])
    print("A + p = {}".format(A + p))#此处处理为广播机制处理，也就是每一行对应的每个元素进行相加，但不是线性代数中的矩阵加法
    print("A + 1 = {}".format(A + 1))#此处处理为广播机制处理，也就是每一行对应的每个元素进行相加，但不是线性代数中的矩阵加法

    print("A.dot(p) = {}".format(A.dot(p)))#矩阵乘以向量

    # 单位矩阵
    I = np.identity(2)
    print(I)
    print("A.dot(I) = {}".format(A.dot(I)))
    print("I.dot(A) = {}".format(I.dot(A)))

    #逆矩阵
    invA = np.linalg.inv(A)
    print(invA)
    print(invA.dot(A))
    print(A.dot(invA))

    # 只有方阵才会有逆矩阵：对于非方阵取逆矩阵时会报错
    C = np.array([[1,2,3],[4,5,6]])
    np.linalg.inv(C)

5. 运行文件 main_numpy_vector.py 结果为：

/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Users/liuxiaoming/PycharmProjects/LinearAlgebra/playLA/main_numpy_matrix.py
[[1 2]
 [3 4]]
(2, 2)
[[1 3]
 [2 4]]
4
[1 2]
[1 3]
A + B = [[ 6  8]
 [10 12]]
A - b = [[-4 -4]
 [-4 -4]]
10 * A = [[10 20]
 [30 40]]
A * 10 = [[10 20]
 [30 40]]
[[ 5 12]
 [21 32]]
A.dot(B) = [[19 22]
 [43 50]]
A + p = [[ 11 102]
 [ 13 104]]
A + 1 = [[2 3]
 [4 5]]
A.dot(p) = [210 430]
[[1. 0.]
 [0. 1.]]
A.dot(I) = [[1. 2.]
 [3. 4.]]
I.dot(A) = [[1. 2.]
 [3. 4.]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[1.00000000e+00 0.00000000e+00]
 [1.11022302e-16 1.00000000e+00]]
[[1.0000000e+00 0.0000000e+00]
 [8.8817842e-16 1.0000000e+00]]
Traceback (most recent call last):
  File "/Users/liuxiaoming/PycharmProjects/LinearAlgebra/playLA/main_numpy_matrix.py", line 47, in <module>
    np.linalg.inv(C)
  File "<__array_function__ internals>", line 5, in inv
  File "/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/lib/python3.8/site-packages/numpy/linalg/linalg.py", line 541, in inv
    _assert_stacked_square(a)
  File "/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/lib/python3.8/site-packages/numpy/linalg/linalg.py", line 204, in _assert_stacked_square
    raise LinAlgError('Last 2 dimensions of the array must be square')
numpy.linalg.LinAlgError: Last 2 dimensions of the array must be square

Process finished with exit code 1

---

---

• 矩阵的逆的性质

 

 

 

 

 

 

---

---

• 看待矩阵的关键视角：用矩阵表示空间 

 

 

 

 

 

 

将原矩阵图形放入一个新的矩阵空间（T）中展示的样子：

 

 

---

---

• 总结：看待矩阵的四个重要视角