《深度学习的数学——使用Python语言》线性代数 [复制链接]

标量：

这个名词理解，标量就是一个数字，比如7、42或PI。在表达式中，x表示标量，也就是不带任何样式的变量记号。对于计算机来说，标量就是一个简单的数值变量：

>>> s = 66
>>> s
66
>>> 

向量：

向量是由数字构的一维数组。在数学上，向量有水平和垂直两种列式方法。如果是水列式，那么就一个行向量。

x=[x0,x1,x2]

其中x是由3个元素构成的行向量。

在数学上，我们通常将向量表示为列向量y=

y，为二维向量。

在代码中，我们通常使用一维数组来表示向量

>>> import numpy as np

>>> x = np.array([1,2,3])
>>> print(x)
[1 2 3]
>>> print(x.reshape((3,1)))
[[1]
 [2]
 [3]]
>>> 

上述代码中通过调用reshape函数，将一个三元行向量转换成了列向量。

向量中的成员通常表示向量在一组坐标系中沿各个坐标轴的长度。例如，一个三元向量可以表示三维空间中的一个点。在这个三元向量中，x是沿X轴的长度，y是沿y轴的长度，z是沿z轴的长度，这就是笛卡儿坐标系用于唯一地表示整个三维空间中所有的点，比如：

x=（x，y，z）

然后，在深度学习和机器学习领域，向量的各个成同之间通常没有严格的几何位置关系。它们用来表示特征，也就是描述样本特性的某些量。模型需要通过这些量来得到有用的输出，如分类标签或回归值。尽管如此，用来表特征向量（特征的集合）的特征有时也是有几何含义的。例如，一些机器学习算法（如k近邻算法）会把特征解读为几何空间中的坐标。

在深度学习中，问题的特征空间是指由所有可能的输入构成的集合。提供给模型的训练样本需要能够有效地表示模型在使用阶段的特征空间。从这个角度讲，特征向量就是n维空间的一个点，n等于特征向量中特征的数量。

矩阵：

矩阵是由数字构成的二维数组。

A=

在矩阵A中，各元素所处的行数和列数为下标。矩阵A包含2行3列，因而它被称为2*3的矩阵。其中，2*3就是矩阵A的阶数。注意，数组的下标是从0开始的。矩阵在代码中是二维数组表示的：

>>> a = np.array([[1,2,3],[4,5,6]])
>>> print(a)
[[1 2 3]
 [4 5 6]]
>>> 

numpy就一个数据结构：ndarray ，但变化多端。。。

根本学不完呀，学不完！以前做报表时用过，还没有想到可以做向量、张量。

张量：

标量是零给的，向量是一维的，矩阵是二维的。高于二维的对象称为张量。

张量的维数又称为阶数，注意不要与矩阵的阶数弄混淆。三维张量的阶数为3.矩阵是二阶张量（阶数为2），向量是一阶张量（阶数为1），标量是零阶张量（阶数为0）。在以后学习神经网络中的数据流时，会看很多组件使用了四阶张量（甚至更高阶的张量）

【小结】张量可以用阶数来统一标量、矩阵、向量等等。

在Python中，可以使用三维或者更高维的NumPy数组来实现张量。

如下为一个三维张量：

>>> t = np.arange(36).reshape((3,3,4))
>>> print(t)
[[[ 0  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]]]

这段代码中首先用np.arange定义了一个由数字0-35组成的向量，其中包含36个元素。接下来通过调用reshape函数，将这个数组转换成3*3*4的张量。理解这个3*3*4的张量的一种方式，就是将其想象一个由3张3*4的矩阵图片叠在一起的阵列。

>>> print(t[0])
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

>>> print(t[0,1])
[4 5 6 7]
>>> print(t[0,1,2])
6
>>> 

书中使用以上代码对张量中的元素进行了访问。

下面这个表让我明白了张量与上面说的标量、向量、矩阵、张量等关系

一开始不理解AI，以为AI是电子，实际AI是数学。真的是学好数理化，走遍天下都不怕

对的，数学是基础东西，没有数学，行不通呀。

确实如此。。。。。。。机器学习就是数学。。。。。。。。。

化现在不太行了，数理还是可以。现在据说很多大学都在关停化相关专业。

基础的东西还需要有人来做的，人类的进步，都是无数科学家的付出。

单位向量

在学会计算向量的模长之后，下面介绍向量的一种很有用的表示形式，名为单位向量。如果将向量中的各个元素除以向量的模长，就可以得到一个方向不变且大小为1的向量，这就是单位向量。

使用NumPy的计算单位向量（2，-4，3）的代码如下：

>>> v = np.array((2,-4,3))
>>> u = v/np.sqrt((v*v).sum())
>>> print(u)
[ 0.37139068 -0.74278135  0.55708601]

上述代码利用了向量的按元素相乘的特性，让向量v乘以自身，便可得到其中每个元素的平方项。然后调用sum函数，得到所有元素的平方和，从而计算出向理的模长。

化学不好就业，哈哈哈哈。到处在闹环保。

化学要是学得好，也是非常有前途呀，比如厂油提练，稀土提练，还有硅的提纯，这都跟化学有关系呀。

生，化，环，材 四大天坑，这么多年没啥变化。

做基础研究的人，现在非常少了，有可能一辈子都没有什么突破。

等着西大弄出来我们抄，哈哈哈。

向量的转置：

行向量可以视为1*n的矩阵，列向量可以视为n*1的矩阵。将行向量转为列向量，或者相反的操作，在NumPy中都非常容易，就是reshape函数、transpose。

>>> v = np.array([1,2,3])
>>> print(v)
[1 2 3]
>>> print(v.reshape((3,1))
... )
[[1]
 [2]
 [3]]
>>> print(v.reshape(1,3))
[[1 2 3]]
>>> print(v.transpose())
[1 2 3]

>>> print(v.T)
[1 2 3]

>>> v = v.reshape((1,3))
>>> print(v.transpose())
[[1]
 [2]
 [3]]
>>> print(v.T)
[[1]
 [2]
 [3]]
>>> 

内积

最“著名”的向量运算可能就是计算内积（标量积、点乘）了。两个向量的内积记为

内积等于两个n元向量按元素相乘后求和的结果。

向量内积的分计算代码如下：

>>> b = np.array([5,6,7,8])
>>> a = np.array([1,2,3,4])
>>> def inner(a,b):
...     s = 0.0
...     for i in range(len(a)):
...             s += a[i]*b[i]
...     return s
... 
>>> inner(a,b)
np.float64(70.0)

在上述代码中，a和b是NumPy数组，因此我们有如下更高效的方案：

>>> (a*b).sum()
np.int64(70)

还有更高效的方式是让NumPy为我们做一切，如下所示：

>>> np.dot(a,b)
np.int64(70)

在深度学习领域的代码频繁看到np.dot函数，很快你就会明白，np.dot函数实现的不仅仅是内积。

可以计算两个夹角的夹角公式

实现代码如下：

>>> A = np.sqrt(np.dot(a,a))
>>> B = np.sqrt(np.dot(b,b))
>>> t = np.arccos(np.dot(a,b)/(A*B))
>>> t*(180/np.pi)
np.float64(14.335170291600924)

计算出a和b的夹角约为14度（这里将弧度转换成了角度）。

考虑三维空间中的向量，垂直的点乘结果为0，这意味着它们的夹角为90度：

>>> a = np.array([1,0,0])
>>> b = np.array([0,1,0])
>>> np.dot(a,b)
np.int64(0)
>>> t = np.arccos(0)
>>> t*(180/np.pi)
np.float64(90.0)
>>> 

上面输出结果是正确的，因为a是沿X轴的单位向量，b是沿y轴的单位向量，它们之间的夹角为直角。