Pytorch 2.3.2 预备知识 Pytorch下的线代

线代

1. 标量:单个数字、加减乘除等运算
2. 向量:维度问题
3. 矩阵:矩阵取数、方阵、对称矩阵、转置
4. 张量:n维数组的通用办法
5. 张量算法的基本性质:哈达玛积
6. 降维:沿轴卷动，求和或平均、非降为求和等
7. 点积（Dot Product):用处很大、加权平均
8. 矩阵-向量积:点积推广
9. 矩阵-矩阵乘法:点积推广、注意维度
10. 范数:一个向量的范数告诉我们一个向量有多大

1.标量

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

2.向量

x = torch.arange(4)
x

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

3.矩阵

A = torch.arange(20).reshape(5, 4)

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

矩阵转置

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B.T == B #转置候相等

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

4.张量

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

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

5.哈达玛积（Hadamard product）

对应元素相乘组成新的张量，也就是我们numpy，scipy最常用的矩阵相乘相除之类的操作

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通过分配新内存，将A的一个副本分配给B
A*B,A

6.求和降维

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

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

指定张量沿哪一个轴来通过求和降低维度

A_sum_axis0 = A.sum(axis=0)
A.shape,A_sum_axis0, A_sum_axis0.shape #保留行，上下压缩

(torch.Size([5, 4]), 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])  # Same as `A.sum()`

tensor(190.)

非降维求和,keepdims立大功

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

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

例如，由于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]])

7.点积（Dot Product）

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

8.矩阵-向量积

A.shape, x.shape, torch.mv(A, x) #这个mv指的是矩阵对向量

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

9.矩阵-矩阵乘法

B = torch.ones(4, 3)
torch.mm(A, B),A.shape,B.shape

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

10.范数

在 𝐿2 范数中常常省略下标 2 ，也就是说， ‖𝐱‖ 等同于 ‖𝐱‖2 。在代码中，我们可以按如下方式计算向量的 𝐿2 范数。

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

在深度学习中，我们更经常地使用 𝐿2 范数的平方。你还会经常遇到[ 𝐿1 范数，它表示为向量元素的绝对值之和：]与 𝐿2 范数相比， 𝐿1 范数受异常值的影响较小。为了计算 𝐿1 范数，我们将绝对值函数和按元素求和组合起来。

torch.abs(u).sum() # tensor(7.) 其实用到的不多，要用的时候再回来查看就好了