数学基础--线性代数

数学概念

1、标量：一个单独的数，通常使用斜体小写字母表示，例如x = 1
2、向量：看作是一个有序的一维数组，通过索引能够唯一的确定向量中的某个值，通常使用斜体加粗的小写字母表示，例如x=1,2,3,4,5，其中第i个元素可以表示为x_i
3、矩阵：矩阵是一个有序的二维数组，其中每个元素由两个索引确定，分别表示它的行和列，通常使用斜体加粗的小写字母表示，例如A=[1 2 3 4]，一个n维向量可以看做是一个1 × n的矩阵.
4、张量：张量表示是个有序的多维数组，其中每个元素可以由多个索引确定，通常使用加粗的大写字母表示，例如A，向量和矩阵可以分别看作是一维和二维的张量

实验环境 ipython

• numpy中生成各种维度的张量:

>>> import numpy as np
## 生成元素全为0的二维张量，两个维度分别为３，４
In [2]: np.zeros((3,4))
Out[2]: 
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
## 生成三维的随机张量，三个维度分别为２,3,4
In [3]: np.random.rand(2,3,4)
Out[3]: 
array([[[ 0.46030997,  0.16924433,  0.37000096,  0.62619588],
        [ 0.62514369,  0.98419663,  0.1969319 ,  0.67285887],
        [ 0.64485847,  0.97908794,  0.80591464,  0.8309347 ]],

       [[ 0.16395408,  0.40201174,  0.91989319,  0.46844117],
        [ 0.02155981,  0.99966088,  0.14550838,  0.36480721],
        [ 0.21656712,  0.2282659 ,  0.23383361,  0.50520634]]])

5、方阵：行数和列数相等的矩阵
6、单位矩阵：对角线元素均为1，其他位置均为0的方阵，通常记做：I_n, n代表行列数，例如

In [4]: np.eye(4)
Out[4]: 
array([[ 1.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.]])

常用运算

• reshape()，重新改变张量的维度数和每个维度(就是数据集的列)的大小，例如创建一个0-11的向量，通过reshape()函数将序列的维度改编成3 × 4的矩阵

## 生成一个包含整数0-11的向量
In [5]: x = np.arange(12)

In [6]: x
Out[6]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
## 将x转换成二维矩阵，其中矩阵的第一个维度为1
In [7]: x = x.reshape(1,12)

In [8]: x
Out[8]: array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]])

In [9]: x.shape
Out[9]: (1, 12)
# 将x转换成3 × 4的矩阵
In [10]: x = x.reshape(3,4)
In [11]: x
Out[11]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

• 转置(transpose)：向量和矩阵的转置是交换行列顺序，矩阵A的转置记为A^T，而三维及以上的张量的转置需要指定转换的维度

## 生成包含5个元素的向量x并将其转置
In [15]: x = np.arange(5).reshape(1,-1)
In [16]: x
Out[16]: array([[0, 1, 2, 3, 4]])
In [17]: x.T
Out[17]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])
## 生成3*4的矩阵并转置
In [18]: A = np.arange(12).reshape(3,4)
In [19]: A
Out[19]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [20]: A.T
Out[20]: 
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
## 生成2 × 3 × 4的张量
In [21]: B = np.arange(24).reshape(2,3,4)
In [22]: B
Out[22]: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
## 将B的0、1两个维度转置
In [23]: B.transpose(1,0,2)
Out[23]: 
array([[[ 0,  1,  2,  3],
        [12, 13, 14, 15]],

       [[ 4,  5,  6,  7],
        [16, 17, 18, 19]],

       [[ 8,  9, 10, 11],
        [20, 21, 22, 23]]])

transpose和reshape是比较容易混淆的，reshape改变的是张量的形状，即张量在各个维度上元素的分配， flatten之后原张量不变。而transpose是改变了维度的方向，不改变形状，flatten之后原张量发生改变。

• 矩阵乘法：记两个矩阵分别为A和B，C = A * B，则C_ij = ∑_kA_i,kB_k,j，由公式可以看到两个矩阵能够相乘的条件为第一个矩阵的列数等于第二个矩阵的行数

In [24]: A = np.arange(6).reshape(3,2)
In [25]: A
Out[25]: 
array([[0, 1],
       [2, 3],
       [4, 5]])

In [26]: B = np.arange(6).reshape(2,3)
In [27]: B
Out[27]: 
array([[0, 1, 2],
       [3, 4, 5]])

In [28]: np.matmul(A,B)
Out[28]: 
array([[ 3,  4,  5],
       [ 9, 14, 19],
       [15, 24, 33]])

• 元素对应运算(Element-wise Operation)：针对形状相同张量的运算统称，包括元素对应乘积，相加等，即对两个张量相同位置的元素进行加减乘除等运算

In [29]: A = np.arange(6).reshape(3,2)
## 乘积
In [30]: A*A
Out[30]: 
array([[ 0,  1],
       [ 4,  9],
       [16, 25]])
## 相加
In [31]: A+A
Out[31]: 
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
## 相减
In [32]: A-A
Out[32]: 
array([[0, 0],
       [0, 0],
       [0, 0]])
# 除法
In [33]: A/A
Out[33]: 
array([[0, 1],
       [1, 1],
       [1, 1]])

• 逆矩阵：方阵A的逆矩阵记为A^-1，它满足A A^-1=I, 示例

# 创建2 × 2 的矩阵
In [34]: A = np.arange(4).reshape(2,2)
In [35]: A
Out[35]: 
array([[0, 1],
       [2, 3]])
# 计算矩阵A的逆矩阵
In [36]: np.linalg.inv(A)
Out[36]: 
array([[-1.5,  0.5],
       [ 1. ,  0. ]])