@[toc]

标量、向量、矩阵和张量¶

• 标量（scalar）：一个标量就是一个单独的数，它不同与线性代数中研究其他大部分对象（通常是多个数的数组）。我们用斜体表示标量。标量通常被赋予小写的变量名称，比如：\(x\)
• 向量（vector）： 一个向量是一列数。这些数都是有序排列的。通过次序中的索引，我们可以确定每个单独的数。通常我们赋予向量粗体的小写变量名称.比如：\({\bf x}\)
  \(\({\bf x}=\left[\begin{matrix}x_1 \\\x_2 \\\ \vdots \\\x_n\end{matrix}\right]\tag{1}\)\)
• 矩阵（matrix）：矩阵是一个二维数组，其中的每一个元素由两个索引（而非一个）所确定。我们通常会赋予矩阵粗体的大写变量名称，比如：\({\bf A}\)
  \(\({\bf A}=\left[\begin{matrix}A_{1,1}&A_{1,2} \\\A_{2,1}&A_{2,2}\end{matrix}\right]\tag{2}\)\)
• 张量（tensor）：在某种情况下，我们会讨论坐标超过两维的数组。一般的，一个数组中的元素分布在若干维坐标的规则网格中，我们称之为张量,使用\({\sf A}\)表示，张量\({\sf A}\)中坐标为\((x,y,z)\)的元素记作\(A_{x,y,z}\)

Python代码实现¶

使用Python创建普通二维矩阵

import numpy as np

m = np.mat([[1,2,3],[4,5,6]])
print m

输出为：

[[1 2 3]
 [4 5 6]]

使用zeros创建一个\(3\times 2\)的0矩阵，还可以使用ones函数创建1矩阵

from  numpy import *
import numpy as np

m = np.mat(zeros((3,2)))
print m

输出为：

[[0. 0.]
 [0. 0.]
 [0. 0.]]

创建单位矩阵，单位矩阵部分有介绍

from numpy import *
import numpy as np

m = np.mat(eye(3,3,dtype=int))
print m

输出为：

[[1 0 0]
 [0 1 0]
 [0 0 1]]

转置¶

转置（transpose）是矩阵的重要操作之一。矩阵的转置是以对角线为轴的镜像，这条从左上角到右下角的对角线被称为主对角线（main diagonal），我们将矩阵\({\bf A}\)的转置表示为\({\bf A^\tau}\)，定义如下：
\(\(({\bf A^\tau})_{i,j}=A_{j,i}\tag{3}\)\)
标量可以看作只有一个元素的矩阵。因此，标量的转置等于它本身，\(a=a^\tau\)
\(\(A=\left[\begin{matrix}A_{1,1}&A_{1,2} \\\A_{2,1}&A_{2,2} \\\A_{3,1}&A_{3,2}\end{matrix}\right]\Rightarrow A^\tau=\left[\begin{matrix}A_{1,1}&A_{2,1}&A_{3,1} \\\A_{1,2}&A_{2,2}&A_{3,2}\end{matrix}\right]\tag{4}\)\)

矩阵的转置也是一种运算,满足下述运算规律(假设运算都可行的):
1. \(({\bf A}^\tau)^\tau={\bf A}\)
2. \(({\bf A}+{\bf B})^\tau={\bf A}^\tau+{\bf B}^\tau\)
3. \((\lambda {\bf A})^\tau=\lambda {\bf A}^\tau\)
4. \(({\bf A}{\bf B})^\tau={\bf B}^\tau{\bf A}^\tau\)

在深度学习中，我也使用一些不那么常规的符号。我们允许矩阵和向量相加，产生另一个矩阵：\({\bf C}={\bf A}+{\bf a}\)，其中\(C_{i,j}=A_{i,j}+b_j\)。换言之，向量\({\bf a}\)和矩阵\({\bf A}\)的每一行相加。这个简写方法使我们无需在加法操作前定义一个将向量\({\bf b}\)复制到每一行而生成的矩阵。这种隐式地复制向量\({\bf b}\)到很多位置的方式，称之为广播（broadcasting）

Python代码实现¶

矩阵的装置

# coding=utf-8
import numpy as np

m = np.mat([[1,2,3],[4,5,6]])
print '转置前:\n%s' % m
t = m.T
print '转置前:\n%s' % t

输出为：

转置前:
[[1 2 3]
 [4 5 6]]
转置前:
[[1 4]
 [2 5]
 [3 6]]

矩阵的运算¶

一. 矩阵的加法¶

定义: 设有两个\(m\times n\)矩阵\({\bf A}=(a_{i,j})\)和\({\bf B}=(b_{i,j})\),那么矩阵\({\bf A}\)与\({\bf B}\)的和记作\({\bf A}+{\bf B}\),规定为:
\(\({\bf A}+{\bf B}=\left[\begin{matrix}a_{1,1}+b_{1,1} & a_{1,2}+b_{1,2} & \cdots & a_{1,n}+b_{1,n} \\\a_{2,1}+b_{2,1} & a_{2,2}+b_{2,2} & \cdots & a_{2,n}+b_{2,n} \\\ \vdots & \vdots & \vdots & \vdots \\\a_{m,1}+b_{m,1}&a_{m,2}+b_{m,2}&\cdots & a_{m,n}+b_{m,n}\end{matrix}\right]\tag{5}\)\)

注意:两个矩阵必须是同型的矩阵时,这两个矩阵才能进行加法运算
矩阵加法满足下列运算规律(设\({\bf A},{\bf B},{\bf C}\)都是\(m \times n\)矩阵):
1. \({\bf A}+{\bf B}={\bf B}+{\bf A}\)
2. \(({\bf A}+{\bf B})+{\bf C}={\bf A}+({\bf B}+{\bf C})\)

Python代码实现¶

计算两个同型矩阵的加法

import numpy as np

m1 = np.mat([[1, 2, 3], [4, 5, 6]])
m2 = np.mat([[11, 12, 13], [14, 15, 16]])
print "m1 + m2 = \n%s " % (m1 + m2)

输出为：

m1 + m2 = 
[[12 14 16]
 [18 20 22]] 

二. 矩阵的乘法¶

数与矩阵相乘定义: 数\(\lambda\)与矩阵\({\bf A}\)的乘积记作\(\lambda {\bf A}\)或\({\bf A} \lambda\),规定为:
\(\(\lambda {\bf A}={\bf A} \lambda=\left[\begin{matrix}\lambda a_{1,1}&\lambda a_{1,2}&\cdots & \lambda a_{1,n}\\\lambda a_{2,1}&a_{2,2}&\cdots&\lambda a_{2,n}\\\vdots&\vdots&\vdots&\vdots\\\lambda a_{m,1}&\lambda a_{m,2}&\cdots & \lambda a_{m,n}\end{matrix}\right]\tag{6}\)\)

数乘矩阵满足下列运算规律(设\({\bf A},{\bf B}\)为\(m \times n\)矩阵,\(\lambda,\mu\)为数):
1. \((\lambda \mu){\bf A}=\lambda (\mu{\bf A})\)
2. \((\lambda + \mu){\bf A}=\lambda {\bf A}+\mu {\bf A}\)
3. \(\lambda({\bf A}+{\bf B})=\lambda {\bf A}+\lambda {\bf A}\)
矩阵加法与数乘矩阵统称为矩阵的线性运算

矩阵与矩阵相乘定义: 设\({\bf A}=(a_{i,j})\)是一个\(m \times s\)矩阵,\({\bf B}=(b_{i,j})\)是一个\(s \times n\)矩阵,那么规定矩阵\({\bf A}\)与\({\bf B}\)的乘积是一个\(m \times n\)矩阵\({\bf C}=(c_{i,j})\),记作:
\(\({\bf C}={\bf A}{\bf B}\tag{7}\)\)
计算如下:
\(\(\left[\begin{matrix} a_{i,1} & a_{i,2} & \cdots & a_{i,s} \end{matrix}\right] \left[\begin{matrix} b_{1,j} \\ b_{2,j} \\ \vdots \\ b_{s,j} \end{matrix}\right]= a_{i,1}b_{1,j}+a_{i,2}b_{2,j}+\cdots+a_{i,k}b_{k,j}= \sum_{k=1}^s a_{i,k}b_{k,j}= c_{i,j}\tag{8}\)\)
例如:
$$
\left[\begin{matrix}
a_{1,1} & a_{1,2} & a_{1,3} \
a_{2,1} & a_{2,2} & a_{2,3} \
\end{matrix}\right]
\left[\begin{matrix}
b_{1,1} & b_{1,2} \
b_{2,1} & b_{2,2} \
b_{3,1} & b_{3,2} \
\end{matrix}\right]=
\left[\begin{matrix}
a_{1,1}b_{1,1}+a_{1,2}b_{2,1}+a_{1,3}b_{3,1} & a_{1,1}b_{1,2}+a_{1,2}b_{2,2}+a_{1,3}b_{3,2} \
a_{2,1}b_{1,1}+a_{2,2}b_{2,1}+a_{2,3}b_{3,1} & a_{2,1}b_{1,2}+a_{2,2}b_{2,2}+a_{2,3}b_{3,2}
\end{matrix}\right]\tag{9}
$$

矩阵不满足交换律,但在运算都可行的情况下满足结合律和分配律
1. \(({\bf A}{\bf B}){\bf C}={\bf A}({\bf B}{\bf C})\)
2. \(\lambda ({\bf A}{\bf B})=(\lambda{\bf A}){\bf B}={\bf A}(\lambda{\bf B})\) (其中\(\lambda\)为数)
3. \({\bf A}({\bf B}+{\bf C})={\bf A}{\bf B}+{\bf A}{\bf C},({\bf B}+{\bf C}){\bf A}={\bf B}{\bf A}+{\bf C}{\bf A}\)

Python代码实现¶

计算\(2\times 3\)矩阵与\(3\times2\)矩阵相乘

import numpy as np

m1 = np.mat([[1, 2, 3], [4, 5, 6]])
m2 = np.mat([[11, 12], [13, 14], [15, 16]])
print "m1 * m2 = \n%s " % (m1 * m2)

输出为：

m1 * m2 = 
[[ 82  88]
 [199 214]] 

单位矩阵和逆矩阵¶

单位矩阵(identity matrix) 就是对角线的元素都是1,而其他的所有元素都是0,如下:
\(\({\bf I}_3=\left[\begin{matrix}1 & 0 & 0 \\\0 & 1 & 0 \\\0 & 0 & 1\end{matrix}\right]\tag{10}\)\)

逆矩阵(matrix inversion)定义: 对于\(n\)阶矩阵\({\bf A}\),如果有一个\(n\)阶矩阵,使得:’
\(\({\bf A}{\bf B}={\bf B}{\bf A}={\bf I}\tag{11}\)\)
则说明矩阵\({\bf A}\)是可逆的,并把矩阵\({\bf B}\)称为\({\bf A}\)的逆矩阵,而且矩阵是唯一的,记作\({\bf A}^{-1}\)
当\(|{\bf A}|\not=0\),则矩阵\({\bf A}\)可逆,且
\(\({\bf A}^{-1}=\frac{1}{|{\bf A}|} {\bf A}^\ast\tag{12}\)\)
其中\({\bf A}^\ast\)称为矩阵的{\bf A}的伴随矩阵

Python代码实现¶

单位矩阵的计算

from numpy import *
import numpy as np

m = np.mat(eye(3,3,dtype=int))
print m

输出为：

[[1 0 0]
 [0 1 0]
 [0 0 1]]

计算\(3\times3\)矩阵的逆矩阵

# coding=utf-8
import numpy as np

m = np.mat([[2, 0, 0], [0, 4, 0], [0, 0, 8]])
I = m.I
print '矩阵：\n%s\n的逆矩阵为：\n%s' % (m, I)

输出为：

矩阵：
[[2 0 0]
 [0 4 0]
 [0 0 8]]
的逆矩阵为：
[[0.5   0.    0.   ]
 [0.    0.25  0.   ]
 [0.    0.    0.125]]

求\(3\times3\)方阵的行列式

# coding=utf-8
import numpy as np

m = np.mat([[2, 0, 0], [0, 4, 0], [0, 0, 8]])
d = np.linalg.det(m)
print d

输出为：

64.0

求\(3\times3\)方阵的伴随矩阵

import numpy as np

m = np.mat([[2, 0, 0], [0, 4, 0], [0, 0, 8]])
i = m.I
d = np.linalg.det(m)
a = i * d
print a

输出为：

[[32.  0.  0.]
 [ 0. 16.  0.]
 [ 0.  0.  8.]]

线性相关和生成子空间¶

线性组合(linear combination)
为了分析方程有多少个解,我们可以将\({\bf A}\)的列向量看作从原点(origin)(元素都是零的向量)出发的不同方向,确定有多少种方法可以到达向量\({\bf b}\).在这个观点下,向量\({\bf x}\)中的每个元素都是表示我们应该沿着这些方向走多远,即\(x_i\)表示我们需要沿着第\(i\)个向量的方向走多远:
\(\({\bf Ax}=\sum_i x_i{\bf A}_{:,i}\tag{13}\)\)
生成子空间(span)
形式上,一组向量的线性组合,是指每个向量乘以对应标量系数之后的和,即:
\(\(\sum_i c_iv^{(i)}\tag{14}\)\)
一组向量的生产子空间是原始向量线性组合后所能抵达的点的集合

范数¶

范数(norm):在机器学习中,我们经常使用称为范数的函数来衡量向量的大小,形式上,\(L^p\)范数定义入下:
\(\(||{\bf x}||_p=\left(\sum_x |x_i|^p\right)^\frac{1}{p}\tag{15}\)\)
范数满足下列性质的任意函数:

• \(f(x)=0\Rightarrow x = 0\)
• \(f(x+y) \leq f(x) + f(y)\)(三角不定式(triangle inequality))
• \(\forall\alpha \in {\Bbb R},f(\alpha{\bf x})=|\alpha|f({\bf x})\)

当\(p=2\)时,\(L^2\)范数称为欧几里得范数(Euclidean norm).他表示从原点出发到向量\({\bf x}\)确定的点的欧几里得距离
当\(p=\infty\)时,\(L^\infty\)范数称为最大范数(max norm).这个范数表示向量中具有最大幅度的元素的绝对值:
\(\(||{\bf x}||_\infty = {\rm max}_i |x_i|\)\)

参考资料¶

1. lan Goodfellow,Yoshua Bengio,Aaron Courville.深度学习(中文版).赵申剑,黎彧君,符天凡,李凯,译.北京:人民邮电出版社
2. 同济大学数学系.工程数学-线性代数(第六版).北京:高等教育出版社