标量
标量由只有一个元素的张量表示。
在下面的代码中，我们实例化两个标量，并执行一些熟悉的算术运算，即加法、乘法、除法和指数。
import torch
x = torch.tensor(3.0) #定义两个标量，分别为3和4
y = torch.tensor(4.0)
x+y, x-y, x*y, x/y, x**y
(tensor(7.), tensor(-1.), tensor(12.), tensor(0.7500), tensor(81.))
向量
我们通过一维张量处理向量。一般来说，张量可以具有任意长度，取决于机器的内存限制。
在代码中，我们通过张量的索引来访问任一元素。
长度、维度、形状
向量的长度通常称为向量的维度（dimension）。与普通的Python数组一样，我们可以通过调用Python的内置len()函数来访问张量的长度。
len(x) #获取向量x的长度
当用张量表示一个向量（只有一个轴）时，我们也可以通过.shape属性访问向量的长度。
形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。 对于只有一个轴的张量，形状只有一个元素。
x.shape #获取向量x的形状，即张量x的维度
向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。
然而，张量的维度用来表示张量具有的轴数。 在这个意义上，张量的某个轴的维数就是这个轴的长度。
矩阵
当矩阵具有相同数量的行和列时，其形状将变为正方形；因此，它被称为方阵（square matrix）。当调用函数来实例化张量时， 我们可以通过指定两个分量m,n和来创建一个形状为** m×n**的矩阵。
当然，我们依旧可以索引矩阵中的任一元素。
当我们交换矩阵的行和列时，结果称为 矩阵的转置（transpose）。
作为方阵的一种特殊类型，对称矩阵（symmetric matrix）。 A 等于其转置 A T。 这里我们定义一个对称矩阵 B
张量
例如，向量是一阶张量，矩阵是二阶张量。 张量用特殊字体的大写字母表示（例如， X 、 Y 和 Z ）， 它们的索引机制（例如 X i j k ）
X = torch.arange(24).reshape(2,3,4) #创建一个三维的张量，长宽高分别为2,3,4
X #输出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(24, dtype=torch.float32).reshape(4,6) #依旧创建一个二维的张量
B = torch.clone(A) #复制一个和张量A相同的张量B
A, B, A+B #令它们进行相加,并输出
(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.]]),
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.]]),
tensor([[ 0., 2., 4., 6., 8., 10.],
[12., 14., 16., 18., 20., 22.],
[24., 26., 28., 30., 32., 34.],
[36., 38., 40., 42., 44., 46.]]))
具体而言，两个矩阵的按元素乘法称为Hadamard积（Hadamard product）（数学符号 ⨀ ）。
A*A
tensor([[ 0., 1., 4., 9., 16., 25.],
[ 36., 49., 64., 81., 100., 121.],
[144., 169., 196., 225., 256., 289.],
[324., 361., 400., 441., 484., 529.]])
将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。
a = 3 #设置一个标量a=3
A+a, A-a, A*a, A/a, (A+a).shape #矩阵与标量的加减乘除运算
(tensor([[ 3., 4., 5., 6., 7., 8.],
[ 9., 10., 11., 12., 13., 14.],
[15., 16., 17., 18., 19., 20.],
[21., 22., 23., 24., 25., 26.]]),
tensor([[-3., -2., -1., 0., 1., 2.],
[ 3., 4., 5., 6., 7., 8.],
[ 9., 10., 11., 12., 13., 14.],
[15., 16., 17., 18., 19., 20.]]),
tensor([[ 0., 3., 6., 9., 12., 15.],
[18., 21., 24., 27., 30., 33.],
[36., 39., 42., 45., 48., 51.],
[54., 57., 60., 63., 66., 69.]]),
tensor([[0.0000, 0.3333, 0.6667, 1.0000, 1.3333, 1.6667],
[2.0000, 2.3333, 2.6667, 3.0000, 3.3333, 3.6667],
[4.0000, 4.3333, 4.6667, 5.0000, 5.3333, 5.6667],
[6.0000, 6.3333, 6.6667, 7.0000, 7.3333, 7.6667]]),
torch.Size([4, 6]))
降维
我们可以对任意张量进行的一个有用的操作是计算其元素的和。 在数学表示法中，我们使用符号 ∑ \sum ∑表示求和。
x = torch.arange(4, dtype=torch.float32)
x, x.sum() #sum()函数负责求和
(tensor([0., 1., 2., 3.]), tensor(6.))
我们可以表示任意形状张量的元素和。 例如，矩阵中元素的和可以先对各列求和后再对各行求和。
A, A.shape, A.sum() #sum()函数求二维张量的和
(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.]]),
torch.Size([4, 6]),
tensor(276.))
我们可以指定张量沿哪一个轴来通过求和降低维度。以矩阵为例，为了通过求和所有行的元素(这里指把所有的行加起来到第一行)来降维（轴0），我们可以在调用函数时指定axis=0。
由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。
（指定axis=1将通过汇总所有列(这里指把所有的列加起来到第一列)的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失。）
A.sum(axis=0), A.sum(axis=0).shape #对所有的列(特征)求和
(tensor([36., 40., 44., 48., 52., 56.]), torch.Size([6]))
A.sum(axis=1), A.sum(axis=1).shape #对所有的行(样本内的数据)求和
(tensor([ 15., 51., 87., 123.]), torch.Size([4]))
沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和。
A.sum(axis=[0,1]),A.sum(axis=[0,1]).shape #对矩阵的所有元素进行求和
(tensor(276.), torch.Size([]))
一个与求和相关的量是平均值（mean或average）。 我们通过将总和除以元素总数来计算平均值。
A.mean(), A.sum()/A.numel() #调用原始的均值方法，或先求和再除总数，军输出平均值
同样，计算平均值的函数也可以沿指定轴降低张量的维度。
A.mean(axis=0), A.sum(axis=0)/A.shape[0] #直接求每一列的平均值，或先求每列的和再除行数，输出均值
(tensor([ 9., 10., 11., 12., 13., 14.]),
tensor([ 9., 10., 11., 12., 13., 14.]))
非降维求和
有时在调用函数来计算总和或均值时保持轴数不变会很有用。
A.sum(axis=1, keepdims=True), A.sum(axis=1, keepdims=True).shape #对每行求和，但要保持维度不变
(tensor([[ 15.],
[ 51.],
[ 87.],
[123.]]),
torch.Size([4, 1]))
A.sum(axis=0, keepdims=True), A.sum(axis=0, keepdims=True).shape #对每列求和，但要保持维度不变
(tensor([[36., 40., 44., 48., 52., 56.]]), torch.Size([1, 6]))
例如，由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播(会将自动复制缺少的列数或行数保持矩阵相等后再运算)将A除以sum_A。
A/A.sum(axis=1, keepdims=True)
tensor([[0.0000, 0.0667, 0.1333, 0.2000, 0.2667, 0.3333],
[0.1176, 0.1373, 0.1569, 0.1765, 0.1961, 0.2157],
[0.1379, 0.1494, 0.1609, 0.1724, 0.1839, 0.1954],
[0.1463, 0.1545, 0.1626, 0.1707, 0.1789, 0.1870]])
如果我们想沿某个轴计算A元素的累积总和(注意矩阵会对某个轴进行累加求和)， 比如axis=0（按行计算），我们可以调用cumsum函数。
A.cumsum(axis=0) #对每列累加求和，生成的新矩阵的每一列是由原矩阵对应列从上到下的累积和构成的。
tensor([[ 0., 1., 2., 3., 4., 5.],
[ 6., 8., 10., 12., 14., 16.],
[18., 21., 24., 27., 30., 33.],
[36., 40., 44., 48., 52., 56.]])
点积(Dot Production)
向量的一个基本操作就是点积，即两个向量的对应元素互相乘积然后求和。
y = torch.ones(4, dtype=torch.float32) #定义一个长度为4，元素均为1的向量
x,y,torch.dot(x,y) #输出x，y，及它们的点积结果torch.dot()
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))
注意，我们也可以通过执行按元素乘法，然后进行求和来表示两个向量的点积：
x*y, (x*y).sum() #先令向量元素乘积，再求和
(tensor([0., 1., 2., 3.]), tensor(6.))
矩阵-向量积
【现在我们知道如何计算点积，我们可以开始理解矩阵-向量积（matrix-vector product）。
其实矩阵-向量积就是我们线性代数中所学的矩阵与向量的乘法。】
在代码中使用张量表示矩阵-向量积，我们使用与点积相同的mv函数。 当我们为矩阵A和向量x调用torch.mv(A, x)时，会执行矩阵-向量积。 注意，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同。
B = A.T #令矩阵B为矩阵A的转置
B, x, B.shape, x.shape, torch.mv(B, x) #矩阵B与向量x作乘积，最后得到一个(6*1)的一维向量
(tensor([[ 0., 6., 12., 18.],
[ 1., 7., 13., 19.],
[ 2., 8., 14., 20.],
[ 3., 9., 15., 21.],
[ 4., 10., 16., 22.],
[ 5., 11., 17., 23.]]),
tensor([0., 1., 2., 3.]),
torch.Size([6, 4]),
torch.Size([4]),
tensor([ 84., 90., 96., 102., 108., 114.]))
矩阵-矩阵乘法
我们可以将矩阵-矩阵乘法看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成一个 m × n 矩阵。在下面的代码中，我们在 A 和 B 上执行矩阵乘法。 这里的A是一个5行4列的矩阵，B是一个4行3列的矩阵。 两者相乘后，我们得到了一个5行3列的矩阵。
注意，A的列维数（沿轴1的长度）必须与B的行维数（沿轴0的长度）相同。
A = torch.arange(20).reshape(5,4) #创建两个矩阵A， B，分别为5行4列、4行3列
B = torch.arange(12).reshape(4,3)
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, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]]))
现在执行矩阵乘法(使用torch.mm()方法)
torch.mm(A,B), torch.mm(A,B).shape #输出矩阵A、B乘积的结果，以及它们的结构
(tensor([[ 42, 48, 54],
[114, 136, 158],
[186, 224, 262],
[258, 312, 366],
[330, 400, 470]]),
torch.Size([5, 3]))
矩阵-矩阵乘法可以简单地称为矩阵乘法，不应与”Hadamard积”混淆。
范数
线性代数中最有用的一些运算符是范数（norm）。
在代码中，我们可以按如下方式计算向量的范数 L 2
u = torch.tensor([3.0, -4.0]) #定义一个向量u
torch.norm(u) #计算该向量的范数
tensor(5.)
与范数 L 2 相比，范数 L 1 受异常值的影响较小。 为了计算范数 L 1，我们将绝对值函数和按元素求和组合起来。
u.abs().sum() #先求绝对值，再求和
tensor(7.)
A, torch.norm(A.float()) #输出矩阵A ，以及A的第二范式
(tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19]]),
tensor(49.6991))
范数和目标
在深度学习中，我们经常试图解决优化问题：
最大化分配给观测数据的概率;
最小化预测和真实观测之间的距离。
用向量表示物品（如单词、产品或新闻文章），以便最小化相似项目之间的距离，最大化不同项目之间的距离。目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。
小结
通过练习，明白了以下的知识点:
标量、向量、矩阵和张量是线性代数中的基本数学对象。
向量泛化自标量，矩阵泛化自向量。
标量、向量、矩阵和张量分别具有零、一、二和任意数量的轴。
一个张量可以通过sum和mean沿指定的轴降低维度。
两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。
在深度学习中，我们经常使用 L 1 范数，如 L 2 范数、范数和Frobenius范数。