包含一个数值的叫标量（scalar）。标量由只有一个元素的张量表示：
import torch
x = torch.tensor(3.0)
y = torch.tensor(2.0)
x + y,x * y,x / y,x ** y
(tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))
将向量视为标量值组成的列表。 我们将这些标量值称为向量的元素（element）或分量（component）。通过一维张量处理向量。一般来说，张量可以具有任意长度，取决于机器的内存限制，可以使用下标来引用向量的任一元素。
\[\mathbf{A}=\left[\begin{array}{c}\mathbf{a}_{1}^{\top} \\ \mathbf{a}_{2}^{\top} \\ \vdots \\ \mathbf{a}_{m}^{\top}\end{array}\right] \]x = torch.arange(4)
x,x[3]
(tensor([0, 1, 2, 3]), tensor(3))
向量的长度通常称为向量的维度，可以通过调用 Python 的内置 len()函数来访问张量的长度。当用张量表示一个向量（只有一个轴）时，我们也可以通过.shape属性访问向量的长度。 形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。 对于只有一个轴的张量，形状只有一个元素:
len(x),x.shape
(4, torch.Size([4]))
正如向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。
\[\mathbf{A}=\left[\begin{array}{cccc}a_{11} & a_{12} & \cdots & a_{1 n} \\ a_{21} & a_{22} & \cdots & a_{2 n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m 1} & a_{m 2} & \cdots & a_{m n}\end{array}\right] \]A = torch.arange(20).reshape(5, 4)
A,A[-1],A[2][3]
(tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19]]),
tensor([16, 17, 18, 19]),
tensor(11))
当我们交换矩阵的行和列时，结果称为矩阵的转置（transpose）：
A.T
tensor([[ 0, 4, 8, 12, 16],
[ 1, 5, 9, 13, 17],
[ 2, 6, 10, 14, 18],
[ 3, 7, 11, 15, 19]])
作为方阵的一种特殊类型，对称矩阵（symmetric matrix）\(\mathbf{A}\) 等于其转置：\(\mathbf{A}=\mathbf{A}^{\top}\)，定义一个对称矩阵:
B = torch.tensor([[1,2,3],[2,0,4],[3,4,5]])
B,B == B.T
(tensor([[1, 2, 3],
[2, 0, 4],
[3, 4, 5]]),
tensor([[True, True, True],
[True, True, True],
[True, True, True]]))
就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构。 张量为我们提供了描述具有任意数量轴的 n 维数组的通用方法:
X = torch.arange(24).reshape(2,3,4)
X
tensor([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量:
A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone()
A,A + B
(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.],
[16., 17., 18., 19.]]),
tensor([[ 0., 2., 4., 6.],
[ 8., 10., 12., 14.],
[16., 18., 20., 22.],
[24., 26., 28., 30.],
[32., 34., 36., 38.]]))
将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘：
a = 2
X = torch.arange(24).reshape(2,3,4)
a + X,(a * X).shape
(tensor([[[ 2, 3, 4, 5],
[ 6, 7, 8, 9],
[10, 11, 12, 13]],
[[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 25]]]),
torch.Size([2, 3, 4]))
计算张量元素的和：
x = torch.arange(4, dtype=torch.float32)
x, x.sum()
(tensor([0., 1., 2., 3.]), tensor(6.))
默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。 我们还可以指定张量沿哪一个轴来通过求和降低维度。 以矩阵为例，为了通过求和所有行的元素来降维（轴0），我们可以在调用函数时指定 axis=0。 由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失：
A = torch.arange(20,dtype=torch.float32).reshape(5,4)
A_sum_axis0 = A.sum(axis=0)
A,A_sum_axis0,A_sum_axis0.shape
(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.],
[16., 17., 18., 19.]]),
tensor([40., 45., 50., 55.]),
torch.Size([4]))
指定 axis=1 将通过汇总所有列的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失：
A = torch.arange(20,dtype=torch.float32).reshape(5,4)
A_sum_axis1 = A.sum(axis=1)
A,A_sum_axis1,A_sum_axis1.shape
(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.],
[16., 17., 18., 19.]]),
tensor([ 6., 22., 38., 54., 70.]),
torch.Size([5]))
沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和：
A.sum(axis=[0, 1]) # A.sum()
tensor(190.)
调用 mean 函数可以求平均值：
A.mean(),A.sum()/A.numel(),A.mean(axis=0),A.sum(axis=0)/A.shape[0]
(tensor(9.5000),
tensor(9.5000),
tensor([ 8., 9., 10., 11.]),
tensor([ 8., 9., 10., 11.]))
有时在调用函数来计算总和或均值时保持轴数不变会很有用：
sum_A = A.sum(axis=1, keepdims=True)
sum_A,A/sum_A
(tensor([[ 6.],
[22.],
[38.],
[54.],
[70.]]),
tensor([[0.0000, 0.1667, 0.3333, 0.5000],
[0.1818, 0.2273, 0.2727, 0.3182],
[0.2105, 0.2368, 0.2632, 0.2895],
[0.2222, 0.2407, 0.2593, 0.2778],
[0.2286, 0.2429, 0.2571, 0.2714]]))
给定两个向量：\(\mathbf{x}, \mathbf{y} \in \mathbb{R}^{d}\)，它们的点积（dot product）：\(\mathbf{x}^{\top} \mathbf{y}\)，或者记为：\(\langle\mathbf{x}, \mathbf{y}\rangle\)，相同位置的按元素乘积的和：\(\mathbf{x}^{\top} \mathbf{y}=\sum_{i=1}^{d} x_{i} y_{i}\):
y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))
为矩阵 A 和向量 x 调用 torch.mv(A, x) 时，会执行矩阵-向量积。 注意，A 的列维数（沿轴1的长度）必须与 x 的维数（其长度）相同:
\[\mathbf{A}=\left[\begin{array}{c}\mathbf{a}_{1}^{\top} \\ \mathbf{a}_{2}^{\top} \\ \vdots \\ \mathbf{a}_{m}^{\top}\end{array}\right] \]\[\mathbf{A}=\left[\begin{array}{cccc}a_{11} & a_{12} & \cdots & a_{1 n} \\ a_{21} & a_{22} & \cdots & a_{2 n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m 1} & a_{m 2} & \cdots & a_{m n}\end{array}\right] \]\[\mathbf{A} \mathbf{x}=\left[\begin{array}{c}\mathbf{a}_{1}^{\top} \\ \mathbf{a}_{2}^{\top} \\ \vdots \\ \mathbf{a}_{m}^{\top}\end{array}\right] \mathbf{x}=\left[\begin{array}{c}\mathbf{a}_{1}^{\top} \mathbf{x} \\ \mathbf{a}_{2}^{\top} \mathbf{x} \\ \vdots \\ \mathbf{a}_{m}^{\top} \mathbf{x}\end{array}\right] \]A.shape,x.shape,torch.mv(A,x)
(torch.Size([5, 4]), torch.Size([4]), tensor([ 14., 38., 62., 86., 110.]))
假设有两个矩阵：\(\mathbf{A} \in \mathbb{R}^{n \times k}\)，\(\mathbf{B} \in \mathbb{R}^{k \times m}\)：
\[\mathbf{A}=\left[\begin{array}{cccc}a_{11} & a_{12} & \cdots & a_{1 k} \\ a_{21} & a_{22} & \cdots & a_{2 k} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n 1} & a_{n 2} & \cdots & a_{n k}\end{array}\right], \quad \mathbf{B}=\left[\begin{array}{cccc}b_{11} & b_{12} & \cdots & b_{1 m} \\ b_{21} & b_{22} & \cdots & b_{2 m} \\ \vdots & \vdots & \ddots & \vdots \\ b_{k 1} & b_{k 2} & \cdots & b_{k m}\end{array}\right] \]则计算结果 \(\mathbf{C} \in \mathbb{R}^{n \times m}\):
\[\mathbf{C}=\mathbf{A B}=\left[\begin{array}{c}\mathbf{a}_{1}^{\top} \\ \mathbf{a}_{2}^{\top} \\ \vdots \\ \mathbf{a}_{n}^{\top}\end{array}\right]\left[\begin{array}{llll}\mathbf{b}_{1} & \mathbf{b}_{2} & \cdots & \mathbf{b}_{m}\end{array}\right]=\left[\begin{array}{cccc}\mathbf{a}_{1}^{\top} \mathbf{b}_{1} & \mathbf{a}_{1}^{\top} \mathbf{b}_{2} & \cdots & \mathbf{a}_{1}^{\top} \mathbf{b}_{m} \\ \mathbf{a}_{2}^{\top} \mathbf{b}_{1} & \mathbf{a}_{2}^{\top} \mathbf{b}_{2} & \cdots & \mathbf{a}_{2}^{\top} \mathbf{b}_{m} \\ \vdots & \vdots & \ddots & \vdots \\ \mathbf{a}_{n}^{\top} \mathbf{b}_{1} & \mathbf{a}_{n}^{\top} \mathbf{b}_{2} & \cdots & \mathbf{a}_{n}^{\top} \mathbf{b}_{m}\end{array}\right] \]B = torch.ones(4,3)
torch.mm(A,B)
tensor([[ 6., 6., 6.],
[22., 22., 22.],
[38., 38., 38.],
[54., 54., 54.],
[70., 70., 70.]])
一个向量的范数告诉我们一个向量有多大。 这里考虑的大小（size）概念不涉及维度，而是分量的大小。
在线性代数中，向量范数是将向量映射到标量的函数 \(f\) 。给定任意向量 \(\mathbf{X}\),向量范数要满足一些属性:
- 第一个性质：如果我们按常数因子 \(Q\) 缩放向量的所有元素， 其范数也会按相同常数因子的绝对值缩放：\(f(\alpha \mathbf{x})=|\alpha| f(\mathbf{x})\)
- 第二个性质：三角不等式:\(f(\mathbf{x}+\mathbf{y}) \leq f(\mathbf{x})+f(\mathbf{y})\)
- 第三个性质：范数必须是非负的:\(f(\mathbf{x}) \geq 0\)
- 最后一个性质要求范数最小为0，当且仅当向量全由0组成:\(\forall i,[\mathbf{x}]_{i}=0 \Leftrightarrow f(\mathbf{x})=0\)
欧几里得距离是一个 \(L_{2}\) 范数：
\[\|\mathbf{x}\|_{2}=\sqrt{\sum_{i=1}^{n} x_{i}^{2}} \]u = torch.tensor([3.0,-4.0])
torch.norm(u)
tensor(5.)
\(L_{1}\) 范数，表示为向量元素的绝对值之和：
\[\|\mathbf{x}\|_{1}=\sum_{i=1}^{n}\left|x_{i}\right| \]与 \(L_{2}\) 范数相比，\(L_{1}\) 范数受异常值的影响较小。
torch.abs(u).sum()
tensor(7.)
\(L_{2}\) 范数和 \(L_{1}\) 范数都是更一般的范数的特例：
\[\|\mathbf{x}\|_{p}=\left(\sum_{i=1}^{n}\left|x_{i}\right|^{p}\right)^{1 / p} \]类似于向量的 \(L_{2}\) 范数，矩阵 \(\mathbf{X} \in \mathbb{R}^{m \times n}\) 的Frobenius范数（Frobenius norm）是矩阵元素平方和的平方根：
\[\|\mathbf{X}\|_{F}=\sqrt{\sum_{i=1}^{m} \sum_{j=1}^{n} x_{i j}^{2}} \]Frobenius 范数满足向量范数的所有性质，它就像是矩阵形向量的 \(L_{2}\) 范数。 调用以下函数将计算矩阵的 Frobenius 范数。
torch.norm(torch.ones(4,9))
tensor(6.)
经常试图解决优化问题： 最大化分配给观测数据的概率; 最小化预测和真实观测之间的距离。目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。
【文章转自荷兰服务器 http://www.558idc.com/helan.html 欢迎留下您的宝贵建议】