机器学习之线性代数

最新推荐文章于 2024-05-16 22:32:24 发布

HelloWorld白

最新推荐文章于 2024-05-16 22:32:24 发布

阅读量1.8k

点赞数 29

分类专栏：机器学习文章标签：机器学习线性代数 python

本文链接：https://blog.csdn.net/weixin_53801305/article/details/136101845

版权

机器学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

线性代数

1.标量

由只有一个张量表示

import torch

x = torch.tensor(3.0)
y = torch.tensor(2.0)

print(x+y,x-y,x*y,x/y,x**y)

2.向量

由一组标量组成的列表，这些标量值被称为向量的元素和分量，向量通常使用小写粗体表示(x,y,z)

具有一个轴的张量，是一阶张量，单个向量的默认方向是列向量，向量的索引机制为：通过张量的索引机制来访问任意元素，例如： a[3]

向量图示

import torch
a = torch.arange(4)

向量的长度

向量长度通常称为向量的维度,可以利用 len(a)来求出

向量的形状

当用向量表示一个张量时（只有一个轴时），可以使用 .shape来访问向量的长度

向量的维数

向量或轴的维数，也称为向量或轴的长度，或者是向量或轴的元素数量，张量的维度表示张量具有的轴数
张量在某个轴上的维数就表示轴的长度

3.矩阵

具有2个轴的张量，是二阶张量，通常使用大写粗体表示(X,Y,Z)

矩阵图示

import torch
# 矩阵
b = torch.arange(20).reshape(4,5)
print(b)

# 矩阵的转置
print('转置后的矩阵为：\n',b.T)

# 对称矩阵 c = c.T
c = torch.tensor([[1,2,3],
                  [2,0,4],
                  [3,4,1]])
print(c==c.T)

4.张量

是矩阵的推广，通常使用特殊大写字母表示(X,Y,Z)，例如，在处理图像时，图像以n维数组的形式呈现，其中3个轴代表
高度，宽度，通道轴（颜色通道RGB）

import torch
# 张量
d = torch.arange(24).reshape(2,3,4)
print(d)

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.张量算法的基本性质

张量的加法

每个元素对应标量相加

import torch
# 张量的加法
x = torch.arange(20,dtype=torch.float32).reshape(5,4)
y = x.clone()                             # 通过分配新内存，将x的副本复制给y
print('x+y=\n',x+y)

张量的乘法

也叫做Hadamard积，用符号⊙表示，表示对应元素相乘

hadamard积

张量乘以或加上一个标量

张量乘以或加上一个标量不会改变张量的形状

import torch
a = 2
x = torch.arange(24).reshape(2,3,4)
print('张量加上一个数:\n',x+a,(x+a).shape)
print('张量乘以一个数:\n',x*a,(x*a).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])
张量乘以一个数:
 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]]]) torch.Size([2, 3, 4])

6.降维

求和降维矩阵图示

求和

计算向量中的元素总和

使用 x.sum()函数

import torch
a = torch.arange(4)
print(a.sum())

延不同轴求和降维

import torch
# 延x轴降维，axis=0,对所有行操作
A = torch.arange(20,dtype=torch.float32).reshape(4,-1)
print(A)
print('求和\n',A.sum(axis=[0,1]))   # 延所有轴降维成一个标量
print('求和所有行\n',A.sum(axis=0))  # 延行轴（轴0）求和所有行的元素来降维
print('求和所有列\n',A.sum(axis=1))  # 延列轴（轴1）求和所有列的元素来降维

tensor([[ 0.,  1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.,  9.],
        [10., 11., 12., 13., 14.],
        [15., 16., 17., 18., 19.]])
求和
 tensor(190.)
求和所有行
 tensor([30., 34., 38., 42., 46.])
求和所有列
 tensor([10., 35., 60., 85.])

求平均值

可以使用 x.mean()函数，也可以使用总和除以元素总数 x.numel()

import torch
# 求平均值
A = torch.arange(20,dtype=torch.float32).reshape(4,-1)
print('A的平均值为：\n',A.mean())
print('A的平均值为：\n',A.sum() / A.numel())

print('A的求和所有行的平均值：\n',A.mean(axis=0))
print('A的求和所有行的平均值：\n',A.sum(axis=0)/A.shape[0])      # x.shape[0]代表x的第一个维度的长度

A的平均值为：
 tensor(9.5000)
A的平均值为：
 tensor(9.5000)
A的求和所有行的平均值：
 tensor([ 7.5000,  8.5000,  9.5000, 10.5000, 11.5000])
A的求和所有行的平均值：
 tensor([ 7.5000,  8.5000,  9.5000, 10.5000, 11.5000])

非降维求和

import torch
# 非降维求和
A = torch.arange(20,dtype=torch.float32).reshape(4,-1)
sum_A = A.sum(axis=1, keepdims=True)
print(sum_A)
print(A/sum_A)

如果想要按给定的轴进行累计总和，且不改变张量的维度，可以使用 cumsum()函数

import torch
A = torch.arange(20,dtype=torch.float32).reshape(4,-1)
print(A.cumsum(axis=0))

tensor([[ 0.,  1.,  2.,  3.,  4.],
        [ 5.,  7.,  9., 11., 13.],
        [15., 18., 21., 24., 27.],
        [30., 34., 38., 42., 46.]])

7.点积

例如，给定一组由向量x ∈ Rd表示的值，和一组由w ∈ Rd表示的权重。x中的值
根据权重w的加权和，可以表示为点积x⊤w。当权重为非负数且和为1时，点积表示加权平均（weighted average）。将两个向量规范化得到单位长度后，点积表示它们夹角的余弦。

import torch
# 点积
x = torch.arange(4,dtype=torch.float32)
y = torch.ones(4,dtype=torch.float32)
print(x,y,torch.dot(x,y))

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

8.矩阵-向量积

需要满足，矩阵的列数(轴1)要与向量的长度一致，使用时需要调用 torch.mv(A,x)函数

import torch
# 矩阵-向量积
A = torch.arange(20,dtype=torch.float32).reshape(5,-1)
x = torch.arange(4,dtype=torch.float32)
print(torch.mv(A,x))

tensor([ 14.,  38.,  62.,  86., 110.])

9.矩阵的乘法

使用 torch.mm(A,B)函数计算矩阵的乘法

import torch
# 矩阵的乘法
A = torch.arange(20,dtype=torch.float32).reshape(5,-1)
B = torch.ones(4,3)
print(torch.mm(A,B))

tensor([[ 6.,  6.,  6.],
        [22., 22., 22.],
        [38., 38., 38.],
        [54., 54., 54.],
        [70., 70., 70.]])

10.范数

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

在线性代数中，向量范数是将向量映射到标量的函数f。给定任意向量x，向量范数要满足一些属性。

第一个性质是：如果我们按常数因子α缩放向量的所有元素，其范数也会按相同常数因子的绝对值缩放：

f(αx) = |α|f(x)

第二个性质是熟悉的三角不等式:

f(x + y) ≤ f(x) + f(y)

第三个性质简单地说范数必须是非负的:

f(x) ≥ 0

import torch
# 计算2范数
u = torch.tensor([3.0,4.0])
print('2范数为：\n',torch.norm(u))

# 计算1范数
print('1范数为：\n',torch.abs(u).sum())

# 计算F范数
print('F范数为：\n',torch.norm(torch.ones(4,9)))

2范数为：
 tensor(5.)
1范数为：
 tensor(7.)
F范数为：
 tensor(6.)

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

小结

• 标量、向量、矩阵和张量是线性代数中的基本数学对象。
• 向量泛化自标量，矩阵泛化自向量。
• 标量、向量、矩阵和张量分别具有零、一、二和任意数量的轴。
• 一个张量可以通过sum和mean沿指定的轴降低维度。
• 两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。
• 在深度学习中，我们经常使用范数，如L1范数、L2范数和Frobenius范数。
• 我们可以对标量、向量、矩阵和张量执行各种操作。

练习

import torch
# 1. 证明一个矩阵A的转置的转置是A，即(A⊤)⊤ = A。
A = torch.arange(24,dtype=torch.float32).reshape(6,-1)
print((A.T).T == A)

# 2. 给出两个矩阵A和B，证明“它们转置的和”等于“它们和的转置”，即A⊤ + B⊤ = (A + B)⊤。
B = torch.ones(6,4)
print(A.T + B.T == (A+B).T)

# 3. 给定任意方阵A，A + A⊤总是对称的吗?为什么?
C = torch.randn(3,3)
print((C+C.T).T == C+C.T)

# 4. 本节中定义了形状(2, 3, 4)的张量X。len(X)的输出结果是什么？
x = torch.arange(24,dtype=torch.float32).reshape(2,3,4)
print(len(x))

# 5. 对于任意形状的张量X,len(X)是否总是对应于X特定轴的长度?这个轴是什么?
# 这个轴是轴0
a = torch.tensor([3.0])
b = torch.tensor([3.0,4.0])
c = torch.tensor([[1,2,3,4],[4,5,6,7]])
d = torch.arange(24,dtype=torch.float32).reshape(2,3,4)
print(f'a={len(a)},b={len(b)},c={len(c)},d={len(d)}')

# 6. 运行A/A.sum(axis=1)，看看会发生什么。请分析一下原因？
A = torch.arange(20,dtype=torch.float32).reshape(5,-1)
# print(A/A.sum(axis=1))   # 会报错，因为矩阵维数不一致
print(A/A.sum(axis=1, keepdims=True))  # 更正后，正确

# 7. 考虑一个具有形状(2, 3, 4)的张量，在轴0、1、2上的求和输出是什么形状?

x = torch.arange(24,dtype=torch.float32).reshape(2,3,4)
print(x)
# 输入哪轴的维度，哪轴的输出形状就会消失
print(x.sum(axis=0),x.sum(axis=0).shape)
print(x.sum(axis=1),x.sum(axis=1).shape)
print(x.sum(axis=2),x.sum(axis=2).shape)

# 8. 为linalg.norm函数提供3个或更多轴的张量，并观察其输出。对于任意形状的张量这个函数计算得到
A = torch.randn(2,3,4)
print(f'{A}\n{torch.norm(A)}\n{torch.linalg.norm(A)}')


# ***************** 代码仅供参考 *******************

tensor([[True, True, True, True],
        [True, True, True, True],
        [True, True, True, True],
        [True, True, True, True],
        [True, True, True, True],
        [True, True, True, True]])
tensor([[True, True, True, True, True, True],
        [True, True, True, True, True, True],
        [True, True, True, True, True, True],
        [True, True, True, True, True, True]])
tensor([[True, True, True],
        [True, True, True],
        [True, True, True]])
2
a=1,b=2,c=2,d=2
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]])
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([[12., 14., 16., 18.],
        [20., 22., 24., 26.],
        [28., 30., 32., 34.]]) torch.Size([3, 4])
tensor([[12., 15., 18., 21.],
        [48., 51., 54., 57.]]) torch.Size([2, 4])
tensor([[ 6., 22., 38.],
        [54., 70., 86.]]) torch.Size([2, 3])
tensor([[[ 0.5079,  1.0138, -0.7177,  0.2439],
         [ 0.7487, -1.0993, -0.9688, -1.2600],
         [-1.0228,  1.3885, -0.3269, -0.2148]],

        [[-0.8463, -1.0907, -0.9633, -1.1569],
         [-1.3557, -1.8897, -1.5504, -0.8338],
         [ 1.2226,  1.9217, -0.4163, -0.1936]]])
5.2307610511779785
5.2307610511779785

Process finished with exit code 0

补充

torch.linalg.norm(A)和torch.norm()都是PyTorch中用于计算向量或矩阵范数的函数，但有一些区别：

参数形式:

torch.linalg.norm(A)接受一个输入张量 A，并计算其范数。
torch.norm()可以接受两个参数：input 和 p。其中 input 是输入张量，p 是范数的阶数。如果不指定 p，则默认计算2范数。
功能差异:

torch.linalg.norm(A)的主要功能是计算输入张量 A 的范数。
torch.norm()除了计算范数外，还可以计算输入张量的其他类型的统计量，比如均值、标准差等。它可以通过指定不同的 p 值实现不同的功能，如 p=0 计算零范数（非零元素的数量）、p=1 计算1范数（绝对值之和）、p=2 计算2范数（默认，即欧几里得范数），以及其他更高阶的范数。
所以，torch.linalg.norm(A)是一个专门用于计算范数的函数，而torch.norm()是一个更通用的函数，可以计算范数以外的其他统计量，具体取决于所指定的参数。