深度学习笔记2：线性代数

线性代数

标量

标量由只有一个元素的张量表示。

• 简单操作

• 长度

实例化两个标量，并执行一些熟悉的算术运算，即加法、乘法、除法和指数。

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）。 当向量表示数据集中的样本时，它们的值具有一定的现实意义。

• 简单操作

• 长度

• 点乘

• 正交

1、通过一维张量处理向量。

x = torch.arange(4)
x

结果：tensor([0, 1, 2, 3])

2、通过张量的索引来访问任一元素

x[3]

结果：tensor(3)

3、可以通过调用Python的内置len()函数来访问张量的长度。

len(x)

结果：4

4、也可以通过.shape属性访问向量的长度。 形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。 对于只有一个轴的张量，形状只有一个元素。

x.shape

结果：torch.Size([4])

维度：向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。 然而，张量的维度用来表示张量具有的轴数。 在这个意义上，张量的某个轴的维数就是这个轴的长度。

矩阵

正如向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。在代码中表示为具有两个轴的张量。

• 特殊矩阵

• 简单操作

• 乘法（矩阵乘以向量）

• 乘法（矩阵乘以矩阵）

• 范数

取决于如何衡量b和c的长度

• 常见范数

• 正交矩阵（了解）

• 置换矩阵（了解）

  置换矩阵是正交矩阵

当调用函数来实例化张量时，可以通过指定两个分量m和n来创建一个形状为m×n的矩阵。

#创建矩阵
A = torch.arange(20).reshape(5,4)
A

结果：

tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19]])

矩阵的转置

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）A等于其转置：A=A^T

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B

结果：

tensor([[1, 2, 3],
[2, 0, 4],
[3, 4, 5]])

B == B.T

结果：

tensor([[True, True, True],
[True, True, True],
[True, True, True]])

就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构

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.]]))

使用B = A.clone()的话：如果改变B，A将会不变；使用直接B=A的话：如果改变B，就会改变A

clone：返回一个和源张量同shape、dtype和device的张量，与源张量不共享数据内存，但提供梯度的回溯。

赋值=：赋值只是相当于贴上新的标签，数据是共享内存的

两个矩阵的按元素乘法称为哈达玛积（Hadamard product）（数学符号⊙）

A * B

结果：

tensor([[ 0., 1., 4., 9.],
[ 16., 25., 36., 49.],
[ 64., 81., 100., 121.],
[144., 169., 196., 225.],
[256., 289., 324., 361.]])

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]))

降维

可以对任意张量进行的一个有用的操作是计算其元素的和。 在数学表示法中，我们使用∑符号表示求和。 为了表示长度为d的向量中元素的总和，可以记为∑_i=1^dx_i。

计算其元素的和

x = torch.arange(4, dtype=torch.float32)
x, x.sum()

结果：(tensor([0., 1., 2., 3.]), tensor(6.))

表示任意形状张量的元素和

A, A.shape, A.sum()

结果：

(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.],
[16., 17., 18., 19.]]),
torch.Size([5, 4]),
tensor(190.))

默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。指定张量沿哪一个轴来通过求和降低维度

A_sum_axis0 = A.sum(axis=0) #由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。
A_sum_axis0, A_sum_axis0.shape

结果：(tensor([40., 45., 50., 55.]), torch.Size([4]))

A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape

结果：(tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))

A.sum(axis=[0,1]), A.sum(axis=[0,1]).shape

结果：(tensor(190.), torch.Size([]))

一个与求和相关的量是平均值（mean或average）

A.mean(), A.sum()/A.numel()

结果：(tensor(9.5000), tensor(9.5000))

A.mean(axis=0), A.sum(axis=0)/A.shape[0]

结果：(tensor([ 8., 9., 10., 11.]), tensor([ 8., 9., 10., 11.]))

A.mean(axis=1), A.sum(axis=1)/A.shape[1]

结果：

(tensor([ 1.5000, 5.5000, 9.5000, 13.5000, 17.5000]),
tensor([ 1.5000, 5.5000, 9.5000, 13.5000, 17.5000]))

非降维求和

有时在调用函数来计算总和或均值时保持轴数不变会很有用。计算总和或均值时保持轴数不变

sum_A = A.sum(axis=1, keepdims=True)
sum_A, sum_A.shape

结果：

(tensor([[ 6.],
[22.],
[38.],
[54.],
[70.]]),
torch.Size([5, 1]))

由于sum_A在对每行进行求和后仍保持两个轴，通过广播将A除以sum_A

A / sum_A

结果：

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]])

某个轴计算A元素的累积总和

A.cumsum(axis=0)

结果：

tensor([[ 0., 1., 2., 3.],
[ 4., 6., 8., 10.],
[12., 15., 18., 21.],
[24., 28., 32., 36.],
[40., 45., 50., 55.]])

A.cumsum(axis=1)

结果：

tensor([[ 0., 1., 3., 6.],
[ 4., 9., 15., 22.],
[ 8., 17., 27., 38.],
[12., 25., 39., 54.],
[16., 33., 51., 70.]])

点积

点积是相同位置的按元素乘积的和

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.))

我们可以通过执行按元素乘法，然后进行求和来表示两个向量的点积

torch.sum(x * y)

结果：tensor(6.)

矩阵-向量积

矩阵向量积Ax是一个长度为m的列向量，其第i个元素是点积a_i^⊤x

A.shape, x.shape, torch.mv(A,x)

结果：(torch.Size([5, 4]), torch.Size([4]), tensor([ 14., 38., 62., 86., 110.]))

矩阵-矩阵乘法

我们可以将矩阵-矩阵乘法AB看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成一个n×m矩阵

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.]])

范数

线性代数中最有用的一些运算符是范数（norm）。 非正式地说，一个向量的范数告诉我们一个向量有多大。 这里考虑的大小（size）概念不涉及维度，而是分量的大小。

L2范数是向量元素平方和的平方根：

u = torch.tensor([3.0, -4.0])
torch.norm(u)

结果：tensor(5.)

L1范数表示为向量元素的绝对值之和：

torch.abs(u).sum()

结果：tensor(7.)

矩阵的弗罗贝尼乌斯范数（Frobenius norm）是矩阵元素平方和的平方根：

torch.norm(torch.ones((4,9)))

结果：tensor(6.)

范数和目标：

在深度学习中，经常试图解决优化问题： 最大化分配给观测数据的概率；最小化预测和真实观测之间的距离。 用向量表示物品（如单词、产品或新闻文章），以便最小化相似项目之间的距离，最大化不同项目之间的距离。 目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。

小结

• 一个张量可以通过sum和mean沿指定的轴降低维度。
• 两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。
• 在深度学习中，经常使用范数，如L1范数、L2范数和Frobenius范数。