线性代数(预备知识)

最新推荐文章于 2024-07-14 00:28:22 发布

Gaolw1102

最新推荐文章于 2024-07-14 00:28:22 发布

阅读量591

点赞数

分类专栏： # 动手学深度学习----学习笔记深度学习文章标签：线性代数 python 开发语言

本文链接：https://blog.csdn.net/weixin_43479947/article/details/126978817

版权

深度学习同时被 2 个专栏收录

61 篇文章 16 订阅

订阅专栏

动手学深度学习----学习笔记

54 篇文章 15 订阅

订阅专栏

文章目录

- 线性代数

线性代数

在已经可以存储和操作数据后，让我们简要地回顾一下部分基本线性代数内容。

这些内容能够帮助了解和实现本书中介绍的大多数模型。

本节我们将介绍线性代数中的基本数学对象、算术和运算，并用数学符号和相应的代码实现来表示它们。

标量

简而言之，标量即数值。标量是相对于向量，矩阵来讲的，可以是矩阵、向量内的一个实际的数字。在本书中，我们采用了数学表示法，其中标量变量由普通小写字母表示（例如 $x$ ， $y$ 和 $z$ ）。

标量由只有一个元素的张量表示。
在下面的代码中，我们实例化两个标量，并执行一些熟悉的算术运算，即加法、乘法、除法和指数。

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

向量

可以将向量视为标量值组成的列表。我们将这些标量值称为向量的元素（element）或分量（component）。

当向量表示数据集中的样本时，它们的值具有一定的现实意义。

例如，如果我们正在训练一个模型来预测贷款违约风险，我们可能会将每个申请人与一个向量相关联，其分量与其收入、工作年限、过往违约次数和其他因素相对应。如果我们正在研究医院患者可能面临的心脏病发作风险，我们可能会用一个向量来表示每个患者，其分量为最近的生命体征、胆固醇水平、每天运动时间等。在数学表示法中，我们通常将向量记为粗体、小写的符号 （例如 $x$ ， $y$ 、 $z$ ）。

我们通过一维张量处理向量。一般来说，张量可以具有任意长度，取决于机器的内存限制。

x = torch.arange(4)                                                   #定义一个一维向量
x

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

们可以使用下标来引用向量的任一元素。例如，我们可以通过 $x_i$ 来引用第 $i$ 个元素。注意，元素 $x_i$ 是一个标量，所以我们在引用它时不会加粗。大量文献认为列向量是向量的默认方向，在本书中也是如此。在数学中，向量 $\vec{x}$ 可以写为：

$\left[ \begin{matrix} x_1 \\ x_2 \\ . \\ . \\ .\\ x_n \end{matrix} \right]$

其中是 $x_1, x_2 ... x_n$ 是向量的元素。在代码中，我们通过张量的索引来访问任一元素。

x[2]

tensor(2)

长度、维度、形状

向量只是一个数字数组，就像每个数组都有一个长度一样，每个向量也是如此。

向量的长度通常称为向量的维度（dimension）。与普通的Python数组一样，我们可以通过调用Python的内置len()函数来访问张量的长度。

len(x)                                                           #获取向量x的长度

当用张量表示一个向量（只有一个轴）时，我们也可以通过.shape属性访问向量的长度。

形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。对于只有一个轴的张量，形状只有一个元素。

x.shape                                                         #获取向量x的形状，即张量x的维度

torch.Size([4])

请注意，维度（dimension）这个词在不同上下文时往往会有不同的含义，这经常会使人感到困惑。

为了清楚起见，我们在此明确一下： 向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。

然而，张量的维度用来表示张量具有的轴数。在这个意义上，张量的某个轴的维数就是这个轴的长度。

矩阵

正如向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。

矩阵，我们通常用粗体、大写字母来表示（例如， $X 、 Y 和 Z$ ），在代码中表示为具有两个轴的张量。

在数学中，矩阵 $A$ (m行n列)常常被表示为:

$\left[ \begin{matrix} a_{11}, a_{12}, a_{13}, ..., a_{1n} \\ a_{21}, a_{22}, a_{23}, ..., a_{2n} \\ ... \\ a_{m1}, a_{m2}, a_{m3}, ..., a_{mn}\end{matrix} \right]$

当矩阵具有相同数量的行和列时，其形状将变为正方形；因此，它被称为 方阵（square matrix）。

当调用函数来实例化张量时，我们可以通过指定两个分量 $m, n$ 和来创建一个形状为** $\times 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[2,2]

tensor(10)

当我们交换矩阵的行和列时，结果称为 矩阵的转置（transpose）。

我们用 $A^{T}$ 来表示矩阵的转置，如果， $B = A^{T}$ 则对于任意 $i$ 和 $j$ ，都有 $a_{ij} = b_{ji}$ 。

在数学中，矩阵 $A^{T}$ (n行m列)常常被表示为:

$A^{T} = \left[ \begin{matrix} a_{11}, a_{21}, a_{31}, ..., a_{m1} \\ a_{12}, a_{22}, a_{32}, ..., a_{m2} \\ ... \\ a_{1n}, a_{2n}, a_{3n}, ..., a_{mn}\end{matrix} \right]$

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^{T}$ 。这里我们定义一个对称矩阵 $B$ ：

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 == B.T

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

矩阵是有用的数据结构：它们允许我们组织具有不同模式的数据，即每一行均为样本，每一列均为特征。

张量

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

张量（本小节中的“张量”指代数对象）为我们提供了描述具有任意数量轴的维数组的通用方法。

例如，向量是一阶张量，矩阵是二阶张量。张量用特殊字体的大写字母表示（例如， $X 、 Y 和 Z$ ），它们的索引机制（例如 $X_{ijk}$ 和 $X]_{1,2i-1,3}$ ）与矩阵类似。

现在我们来创建一个具三个维度的张量，如

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）（数学符号 $\bigodot$ ）。如下例:

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$ 表示求和。

为了表示长度为的向量中元素的总和，可以记为 $\sum\limits_{i=1}^{d}$ 。在代码中，我们可以调用计算求和的函数：

x = torch.arange(4, dtype=torch.float32)
x, x.sum()                                                     #sum()函数负责求和

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

我们可以表示任意形状张量的元素和。例如，矩阵中元素的和可以记为 $\sum\limits_{i=1}^{m}\sum\limits_{j=1}^{n}a_{ij}$ 。

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的维数在输出形状中消失。

A.sum(axis=0), A.sum(axis=0).shape                                                #对所有的列(特征)求和

(tensor([36., 40., 44., 48., 52., 56.]), torch.Size([6]))

指定axis=1将通过汇总所有列(这里指把所有的列加起来到第一列)的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失。

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()                                                      #调用原始的均值方法，或先求和再除总数，军输出平均值

(tensor(11.5000), tensor(11.5000))

同样，计算平均值的函数也可以沿指定轴降低张量的维度。

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

矩阵-矩阵乘法

如果已经掌握了点积和矩阵-向量积的知识，那么 矩阵-矩阵乘法（matrix-matrix multiplication） 应该很简单。

同理，矩阵-矩阵乘法也是线性代数上基本的运算。

我们可以将矩阵-矩阵乘法看作是简单地执行 $m$ 次矩阵-向量积，并将结果拼接在一起，形成一个 $\times 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）。

非正式地说，一个向量的范数告诉我们一个向量有多大。这里考虑的大小（size）概念不涉及维度，而是分量的大小。

我们这里先介绍 $L_{2}$ 范数：

假设 $n$ 维向量中的元素是 $x_1,x_2,...,x_n$ ，其 $L_2$ 范数是向量元素平方和的平方根：
$L_2 = \sqrt{\sum\limits_{i=1}^{n}|x_{i}|^{2}}$

在代码中，我们可以按如下方式计算向量的范数 $L_2$ :

u = torch.tensor([3.0, -4.0])                                               #定义一个向量u
torch.norm(u)                                                               #计算该向量的范数

tensor(5.)

在深度学习中，我们更经常地使用范数 $L_2$ 的平方。你还会经常遇到 $L_1$ 范数，它表示为向量元素的绝对值之和：

$L_1 = \sum\limits_{i=1}^{n}|x_i|.$

与范数 $L_2$ 相比，范数 $L_1$ 受异常值的影响较小。为了计算范数 $L_1$ ，我们将绝对值函数和按元素求和组合起来。

u.abs().sum()                                                                #先求绝对值，再求和

tensor(7.)

范数 $L_1$ 和范数 $L_2$ 都是更一般的范数 $L_p$ 的特例：

$||x||_p = (\sum\limits_{i=1}^{n}|x_{i}|^{p})^\frac{1}{p}$

类似于向量的 $L_2$ 范数，矩阵的Frobenius范数（Frobenius norm）是矩阵元素平方和的平方根:

$||X||_{F} = \sqrt{\sum\limits_{i=1}^m\sum\limits_{j=1}^n x_{ij}^2}$

Frobenius范数满足向量范数的所有性质，它就像是矩阵形向量的 $L_2$ 范数。调用以下函数将计算矩阵的Frobenius范数。

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