线性代数快速回顾

前言

自从大二学完线性代数，考完试就把相关的知识忘的一干二净，没想到多年之后，线性代数又成了我学习机器学习的必备知识。这里就简单回顾一下线性代数的相关知识，以便后续学习机器学习的时候能够更好的理解。

线性代数是什么？

线性代数是数学的一个分支，研究向量空间、线性变换和线性方程组等概念及其性质。它在许多领域，如物理学、工程学、计算机图形学、经济学等中都有广泛的应用。

以下是线性代数的一些核心概念：

1. 向量空间： 向量空间是由一组向量构成的集合，这些向量遵循特定的加法和数乘规则。向量空间可以是实数域或复数域上的，并且具有封闭性、结合律、分配律等性质。
2. 线性变换： 线性变换是一个将一个向量空间的向量映射到另一个向量空间的操作，它保持向量的线性组合关系。线性变换可以用矩阵来表示，它们在几何变换、信号处理等领域中具有重要作用。
3. 线性方程组： 线性方程组是由线性方程组成的一组等式，其中未知数是向量。解线性方程组就是寻找满足所有等式的向量。线性代数提供了解决线性方程组的方法，如高斯消元法和矩阵求逆法。
4. 矩阵与行列式： 矩阵是一个由数字构成的矩形数组，它可以表示线性变换以及用于解线性方程组。行列式是一个与方阵相关的标量值，它在计算矩阵的逆、判断线性变换是否可逆等方面具有重要意义。
5. 特征值与特征向量： 对于一个线性变换，特征值是一个标量，而特征向量是与特征值相关联的向量，它们在分析线性变换的性质和应用中非常重要。
6. 内积空间与正交性： 内积空间是一个具有内积运算的向量空间，内积可以用来定义向量的长度、角度和正交性。正交向量在许多应用中具有重要作用，如傅里叶分析和正交矩阵等。
7. 线性相关性与线性无关性： 一组向量被称为线性相关，如果其中的某个向量可以表示为其他向量的线性组合。相反，如果没有任何非平凡的线性组合能够得到零向量，这组向量被称为线性无关。

线性代数的应用广泛，涵盖了从解决简单的几何问题到高级的数据分析和计算机图形学等多个领域。它为理解和解决实际问题提供了强大的数学工具。

基本数学对象

标量

标量是一个单一的数值，通常用来表示大小或数量，而不涉及方向。在线性代数中，标量可以是实数或复数，用于描述向量空间中的标量乘法操作。

具体来说：

• 在实数的情况下，标量是一个普通的实数，如 $a = 2$。
• 在复数的情况下，标量是一个复数，如 $c = 3 + 4i$，其中 $i$ 是虚数单位。

标量可以与向量或矩阵进行数乘操作，即将标量乘以每个向量或矩阵的元素。这个操作会将向量或矩阵的每个元素都缩放或拉伸，但不改变它们的方向。

在物理学、工程学、计算机图形学等领域，标量常用来表示各种物理量，如质量、温度、时间、速度等。标量可以与向量相区分，因为向量除了大小外还有方向，而标量只有大小。

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

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

在数学中，我们可以使用符号来表示一个标量属于一个特定的集合。常见的表示方式包括使用符号 $\in$（属于）和集合的名称。下面是表示方式：

使用符号 $\in$：我们可以使用符号 $\in$ 来表示一个元素属于一个集合。例如，如果 $x$ 是一个标量，而集合 $\mathbb{R}$ 表示实数集合，我们可以表示 $x$ 属于实数集合如下：

$x \in \mathbb{R}$

这表示 $x$ 是实数集合中的一个元素。

符号 $\mathbb{R}$ 通常表示实数集合。实数集合包括所有的正数、负数、零，以及这些数之间的所有有理数和无理数。实数集合用来描述实际世界中的数量，包括长度、时间、温度等各种测量。

例如，$\mathbb{R}$ 表示的是一个连续的数轴，上面的每一个点都对应一个实数。无论在数轴上选择任何一个点，它都对应一个实数，这个实数可以是正数、负数、零、有理数或无理数。

符号 $\mathbb{R}$ 用于表示实数的集合，这是数学中一个非常重要的概念，与代数、分析、几何等多个数学领域都有密切关系。

向量

向量是一个有大小和方向的数学对象，通常用来表示空间中的定位、位移、速度、力等概念。向量是线性代数的重要概念，在多个学科领域中都有广泛的应用。

一个向量可以用以下方式表示：

$$\mathbf{v} = \begin{bmatrix} v_1 \\ v_2 \\ \vdots \\ v_n \end{bmatrix}$$

其中 $v_1, v_2, \ldots, v_n$ 是向量的分量，表示向量在各个坐标轴上的投影。在三维空间中，一个向量通常被表示为 $\mathbf{v} = \begin{bmatrix} v_x \\ v_y \\ v_z \end{bmatrix}$，其中 $v_x$、$v_y$ 和 $v_z$ 分别是在 $x$、$y$ 和 $z$ 坐标轴上的分量。

向量具有以下几个重要的性质：

1. 大小（模）： 向量的大小是指从向量的起点到终点的距离，也称为向量的模。在三维空间中，向量 $\mathbf{v} = \begin{bmatrix} v_x \\ v_y \\ v_z \end{bmatrix}$ 的大小可以表示为 $|\mathbf{v}| = \sqrt{v_x^2 + v_y^2 + v_z^2}$。

2. 方向： 向量的方向是指向量指向的位置。它可以通过与坐标轴的夹角来描述。

3. 加法： 向量的加法是指将两个向量的对应分量相加，得到一个新的向量。

4. 数乘： 向量的数乘是指将一个标量与向量的每个分量相乘，得到一个新的向量。

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

x = torch.arange(4)
x

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

长度、维度和形状

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

在数学表示法中，如果我们想说一个向量 $\mathbf{x}$ 由 $n$ 个实值标量组成，可以使用大写字母 $R$ 来表示实数集合，而使用下标来表示向量的分量。具体来说，你可以这样表示一个向量 $\mathbf{x}$：

$$\mathbf{x} = \begin{bmatrix} x_1 \\ x_2 \\ \vdots \\ x_n \end{bmatrix} \in \mathbb{R}^n$$

在这里，$\mathbf{x}$ 是一个由 $n$ 个实值标量组成的向量，每个 $x_i$ 都是实数。符号 $\mathbb{R}^n$ 表示 $n$-维实数向量空间。这个表示法清晰地表达了向量的构成，以及向量的维度。

例如，如果你有一个三维向量 $\mathbf{v}$，可以表示为：

$$\mathbf{v} = \begin{bmatrix} v_1 \\ v_2 \\ v_3 \end{bmatrix} \in \mathbb{R}^3$$

这样的表示法在数学和工程领域中是标准的，可以让人明确地理解向量的构成和性质。

与普通的 Python 数组一样，我们可以通过调用 Python 的内置 len() 函数来访问张量的长度。

len(x)

4

当用张量表示一个向量（只有一个轴）时，我们也可以通过 .shape 属性访问向量的长度。 形状（shape）是一个元素组，列出了张量沿每个轴的长度（维数）。

对于只有一个轴的张量，形状只有一个元素。

x.shape

torch.Size([4])

请注意，维度（dimension）这个词在不同上下文时往往会有不同的含义，这经常会使人感到困惑。 为了清楚起见，我们在此明确一下： 向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。 然而，张量的维度用来表示张量具有的轴数。 在这个意义上，张量的某个轴的维数就是这个轴的长度。

矩阵

矩阵是由数值排列成的矩形阵列，通常用于表示线性变换、数据集合等概念。在数学表示法中，矩阵通常使用大写字母来表示，如 $A$、$B$ 等。下面是矩阵的一般表示方法：

一个 $m \times n$ 维矩阵 $A$ 可以表示为：

$$A = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix}$$

在这里，$a_{ij}$ 表示矩阵 $A$ 中位于第 $i$ 行、第 $j$ 列的元素。矩阵的行数为 $m$，列数为 $n$。矩阵的每个元素都可以是实数或复数，具体取决于上下文。

例如，一个 $2 \times 3$ 维矩阵 $B$ 可以表示为：

$$B = \begin{bmatrix} b_{11} & b_{12} & b_{13} \\ b_{21} & b_{22} & b_{23} \end{bmatrix}$$

在某些情况下，为了方便表示，也可以使用矩阵的名称和下标来表示特定的矩阵元素，例如 $A_{ij}$ 表示矩阵 $A$ 中位于第 $i$ 行、第 $j$ 列的元素。

或者把这个 $2 \times 3$ 的实数矩阵 $A$，表示为：

$$ A \in \mathbb{R}^{2 \times 3} $$

这表示矩阵 $A$ 属于 $2 \times 3$ 维的实数矩阵空间。同样，如果你有一个 $3 \times 3$ 的实数矩阵 $B$，可以表示为：

${ B \in \mathbb{R}^{3 \times 3} }$

可以直接使用 reshape 指定矩阵的形状：

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

张量

张量（Tensor）是一种广义的多维数组结构，在数学和物理学中被广泛应用。它是标量（0阶张量）、向量（1阶张量）、矩阵（2阶张量）等概念的扩展，可以表示多维数据。在不同的领域，张量具有不同的定义和应用。

在机器学习和深度学习领域，张量是非常重要的，因为神经网络的输入、输出以及中间层的数据都可以表示为张量。以下是一些关于张量的基本概念：

• 阶数（Rank）或维度（Dimension）： 张量的阶数指的是张量的维度数，也就是它有多少个轴。标量是0阶张量，向量是1阶张量，矩阵是2阶张量，以此类推。

• 形状（Shape）： 张量的形状描述了每个维度上的大小。例如，一个3x3的矩阵的形状为(3, 3)，一个形状为(2, 3, 4)的张量有三个维度，分别具有大小 2、3 和 4。

• 元素（Element）： 张量中的单个数据项称为元素。元素的数量取决于张量的形状。

在深度学习中，神经网络的权重、输入数据、梯度等都可以表示为张量。例如，在图像分类任务中，输入图像可以表示为一个4阶张量，其形状为(batch_size, channels, height, width)，其中 batch_size 表示一次性处理的图像数量，channels 表示图像的通道数（例如 RGB 通道为 3），height 和 width 表示图像的高度和宽度。

总之，张量是一个非常通用的概念，广泛应用于数学、物理学、计算机科学以及机器学习等领域，用于表示和处理多维数据。

张量用特殊字体的大写字母表示，例如 A、B、C 等。张量的元素用特殊字体的小写字母表示，例如 a、b、c 等。张量的元素可以是实数或复数。

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

基础的计算

矩阵的转置（transpose）

矩阵的转置是一种操作，通过将矩阵的行变成列，列变成行，得到一个新的矩阵。矩阵的转置可以通过交换矩阵的行和列来实现，得到一个新的矩阵，其维度是原始矩阵的列数和行数交换后的结果。

假设有一个 $m \times n$ 维的矩阵 $A$，其元素为 $a_{ij}$，其中 $1 \leq i \leq m$ 表示行索引，$1 \leq j \leq n$ 表示列索引。那么矩阵 $A$ 的转置 $A^\top$（也可以用 $A^T$ 表示）可以通过以下方式得到：

$$ (A^\top){ij} = a{ji} $$

也就是说，矩阵 $A^\top$ 的第 $i$ 行、第 $j$ 列的元素等于矩阵 $A$ 的第 $j$ 行、第 $i$ 列的元素。

例如，如果有一个 $2 \times 3$ 的矩阵 $A$：

$$A = \begin{bmatrix} a & b & c \\ d & e & f \end{bmatrix}$$

那么 $A$ 的转置 $A^\top$ 为一个 $3 \times 2$ 的矩阵：

$$A^\top = \begin{bmatrix} a & d \\ b & e \\ c & f \end{bmatrix}$$

矩阵的转置操作在线性代数中非常常见，它在许多数学和工程应用中都具有重要的作用。在一些应用中，矩阵的转置用于转换数据表示、计算等方面。

还有一种叫做对称矩阵（symmetric matrix）的特殊矩阵，它的转置等于它自己：

对称矩阵是一个非常特殊的矩阵，它满足矩阵的每个元素关于主对角线对称。也就是说，如果矩阵 $A$ 是对称矩阵，那么对于任意的 $i$ 和 $j$，都有 $A_{ij} = A_{ji}$。

对称矩阵具有一些特点和性质：

1. 主对角线上的元素保持不变，即 $A_{ii}$ 是对称矩阵的元素。
2. 对称矩阵关于主对角线对称，也就是 $A_{ij} = A_{ji}$。
3. 对称矩阵在很多情况下具有特殊的数学和物理意义，例如协方差矩阵、物理系统中的能量矩阵等。

在 PyTorch 中，可以使用库提供的函数来创建、操作和检查对称矩阵。下面是一个创建对称矩阵、进行矩阵乘法和检查是否对称的示例：

# 创建一个对称矩阵
A = torch.tensor([[1, 2, 3],
                  [2, 4, 5],
                  [3, 5, 6]], dtype=torch.float32)

# 进行矩阵乘法
B = torch.mm(A, A.t())  # A 乘以它的转置

# 检查是否对称
is_symmetric = torch.allclose(B, B.t(), rtol=1e-5)  # 使用 allclose 函数检查近似相等

print("Original Matrix A:")
print(A)

print("\nMatrix A transposed:")
print(A.t())

print("\nMatrix A multiplied by its transpose:")
print(B)

print("\nIs the result symmetric?", is_symmetric)

Original Matrix A:
tensor([[1., 2., 3.],
        [2., 4., 5.],
        [3., 5., 6.]])

Matrix A transposed:
tensor([[1., 2., 3.],
        [2., 4., 5.],
        [3., 5., 6.]])

Matrix A multiplied by its transpose:
tensor([[14., 25., 31.],
        [25., 45., 56.],
        [31., 56., 70.]])

Is the result symmetric? True

在这个示例中，我们首先创建了一个对称矩阵 $A$。然后使用矩阵乘法计算 $A$ 与它的转置相乘，得到一个新的矩阵 $B$。最后，我们使用 torch.allclose 函数检查 $B$ 是否与它的转置相等，从而判断 $B$ 是否对称。注意，由于计算机浮点数运算的不精确性，我们使用 rtol 参数来设置数值的相对容差。

这个示例展示了如何在 PyTorch 中创建、操作和检查对称矩阵。对称矩阵在许多数学和科学应用中都有重要的作用。

张量的降维求和

张量的降维操作是指将高维张量转化为低维张量的过程，从而减少数据的维度。降维有助于减少数据的复杂性、提取重要特征、减少存储和计算开销，以及可视化数据。

张量的一个常见求和方式是沿着指定的轴（维度）进行求和。这类似于矩阵的行求和和列求和。

# 创建一个示例三维张量
tensor = torch.tensor([
    # 块 1:
    [[1, 2, 3],
     [4, 5, 6]],

    # 块 2:
    [[7, 8, 9],
     [10, 11, 12]]
])

# 沿着第一个维度求和
sum_along_dim_0 = torch.sum(tensor, dim=0)
print("Sum along the first dimension:\n", sum_along_dim_0)

# 对所有元素求和
total_sum = torch.sum(tensor)
print("Total sum of all elements:", total_sum)

Sum along the first dimension:
 tensor([[ 8, 10, 12],
        [14, 16, 18]])
Total sum of all elements: tensor(78)

在 PyTorch（以及类似的数值计算库中），dim 是一个参数，即 "dimension"（维度），用于指定在哪个维度上进行操作。在 sum() 函数中，dim 参数用于指定你想要沿着哪个维度对张量进行求和。

例如，假设你有一个二维张量（即矩阵），你可以通过指定 dim=0 来沿着第一个维度（即行）求和，或者通过指定 dim=1 来沿着第二个维度（即列）求和。

具体来说，对于一个多维张量，每个维度都有一个索引，从0开始逐渐增加。在 sum() 函数中，你可以使用 dim 参数来指定你希望在哪个维度上进行求和。例如：

# 创建一个示例三维张量
tensor = torch.tensor([
    [[1, 2, 3],
     [4, 5, 6]],
    
    [[7, 8, 9],
     [10, 11, 12]]
])

# 沿着第一个维度（维度索引为0）求和
sum_along_dim_0 = torch.sum(tensor, dim=0)

# 沿着第二个维度（维度索引为1）求和
sum_along_dim_1 = torch.sum(tensor, dim=1)

# 沿着第三个维度（维度索引为2）求和
sum_along_dim_2 = torch.sum(tensor, dim=2)

sum_along_dim_0, sum_along_dim_1, sum_along_dim_2

(tensor([[ 8, 10, 12],
         [14, 16, 18]]),
 tensor([[ 5,  7,  9],
         [17, 19, 21]]),
 tensor([[ 6, 15],
         [24, 33]]))

在这个示例中，对于三维张量 tensor，dim=0 表示沿着第一个维度（即第一层的维度）求和，dim=1 表示沿着第二个维度（即第二层的维度）求和，dim=2 表示沿着第三个维度（即最内层的维度）求和。

张量的降维求平均值

在 PyTorch 中，你可以使用 torch.mean() 函数来计算张量的平均值。以下是一个示例：

# 创建一个示例张量
tensor = torch.tensor([[1.0, 2.0, 3.0],
                       [4.0, 5.0, 6.0]])

# 计算张量的平均值
mean_value = torch.mean(tensor)

print("Tensor:")
print(tensor)
print("Mean value:", mean_value.item())

Tensor:
tensor([[1., 2., 3.],
        [4., 5., 6.]])
Mean value: 3.5

在这个示例中，我们创建了一个 2x3 的张量 tensor，然后使用 torch.mean() 函数计算了整个张量的平均值。注意，使用 item() 方法来获取张量的数值值。

如果你想要沿着某个特定的维度求平均值，你可以通过 dim 参数来指定。例如，如果你想沿着列的方向求平均值，可以这样做：

column_mean = torch.mean(tensor, dim=0)
print("Column-wise mean values:", column_mean)

Column-wise mean values: tensor([2.5000, 3.5000, 4.5000])

这将计算每一列的平均值并返回一个一维张量，其中每个元素是对应列的平均值。

张量的非降维求和

"非降维求和"（cumulative sum）是指对张量中的元素进行逐元素累加操作，并保留每一步累加的结果。在 PyTorch 中，可以使用 torch.cumsum() 函数来执行非降维求和操作。以下是一个示例：

# 创建一个示例张量
tensor = torch.tensor([1, 2, 3, 4, 5])

# 计算非降维求和
cumulative_sum = torch.cumsum(tensor, dim=0)

print("Original tensor:", tensor)
print("Cumulative sum:", cumulative_sum)

Original tensor: tensor([1, 2, 3, 4, 5])
Cumulative sum: tensor([ 1,  3,  6, 10, 15])

在这个示例中，我们创建了一个一维张量 tensor，然后使用 torch.cumsum() 函数对其进行非降维求和操作。dim=0 表示在第一个维度上进行操作。

点积（Dot Product）

点积（Dot Product）是一种数学运算，用于计算两个向量之间的乘积。点积操作在线性代数中非常常见，用于衡量两个向量的相似性、计算投影、解决方程组等。点积操作也称为内积、数量积或标量积。

给定两个向量 $x, y \in \mathbb{R}^d$，它们的点积可以表示为 $x \cdot y$ 或者 $x^T y$。

提示

符号 $x, y \in \mathbb{R}^d$ 表示向量 $x$ 和 $y$ 属于实数域（$\mathbb{R}$）中的 $d$ 维向量空间。换句话说，$x$ 和 $y$ 都是由 $d$ 个实数组成的向量。

具体来说，如果 $x$ 是一个 $d$ 维向量，它可以表示为：

$$x = [x_1, x_2, \ldots, x_d]$$

其中 $x_1, x_2, \ldots, x_d$ 是 $x$ 向量的各个分量，每个分量都是实数。

同样地，向量 $y$ 也具有相同的维度 $d$，可以表示为：

$$y = [y_1, y_2, \ldots, y_d]$$

这里的 $y_1, y_2, \ldots, y_d$ 是 $y$ 向量的分量，同样都是实数。

总之，$x, y \in \mathbb{R}^d$ 表示 $x$ 和 $y$ 都是 $d$ 维实数向量。

对于两个向量 X 和 Y，它们的点积可以通过将对应位置的元素相乘，然后将所有乘积相加得到。

当涉及到数学表达式时，我将使用 KaTeX 语法来表示点积操作。点积的数学表达式如下所示：

如果有两个向量 $\mathbf{X}$ 和 $\mathbf{Y}$，它们的点积可以表示为：

$$\mathbf{X} \cdot \mathbf{Y} = \sum_{i=1}^{d} x_i y_i$$

其中 $x_i$ 和 $y_i$ 分别表示向量 $\mathbf{X}$ 和 $\mathbf{Y}$ 在索引 $i$ 处的元素，$d$ 表示向量的维度（长度）。这里，$\sum$ 表示对索引 $i$ 从 1 到 $d$ 的元素进行求和操作。

或者，我们可以将点积表示为：

$$\mathbf{X} \cdot \mathbf{Y} = x_1 y_1 + x_2 y_2 + \ldots + x_d y_d$$

其中 $x_1, x_2, \ldots, x_d$ 表示向量 $\mathbf{X}$ 的元素，$y_1, y_2, \ldots, b_d$ 表示向量 $\mathbf{Y}$ 的元素，$d$ 表示向量的维度（长度）。

点积操作的结果是一个标量，也就是一个单一的数值。点积可以帮助衡量两个向量的方向是否趋向一致，以及它们在相同方向上的相对大小。如果两个向量的点积为零，表示它们在垂直（正交）方向上；如果点积为正数，表示它们的方向相似；如果点积为负数，表示它们的方向相反。

在 PyTorch 中，可以使用 torch.dot() 函数来计算两个向量的点积。以下是一个计算点积的示例：

# 创建两个示例向量
vector_a = torch.tensor([1, 2, 3])
vector_b = torch.tensor([4, 5, 6])

# 计算点积
dot_product = torch.dot(vector_a, vector_b)

print("Vector A:", vector_a)
print("Vector B:", vector_b)
print("Dot product:", dot_product.item())

Vector A: tensor([1, 2, 3])
Vector B: tensor([4, 5, 6])
Dot product: 32

在这个示例中，我们创建了两个长度相同的向量 vector_a 和 vector_b，然后使用 torch.dot() 函数计算它们的点积。item() 方法用于获取点积的数值值。

矩阵-向量积

矩阵-向量积是一种线性代数操作，用于将一个矩阵与一个向量相乘，得到一个新的向量。矩阵-向量积是矩阵乘法的一种特例，其中一个操作数是矩阵，另一个是向量。

假设有一个矩阵 $A$，大小为 $m \times n$，和一个列向量 $\mathbf{v}$，大小为 $n \times 1$。矩阵-向量积 $A\mathbf{v}$ 的计算方法如下：

结果是一个新的列向量，其大小为 $m \times 1$，其中每个元素是矩阵的每一行与向量的对应元素相乘后的累加。

矩阵-向量积在线性代数和数值计算中非常常见，用于模拟线性变换和转换，例如在图形渲染、机器学习等领域。在编程库（如NumPy和PyTorch）中，可以使用相应的函数来执行矩阵-向量积操作。

在 PyTorch 中，你可以使用 torch.mv() 函数来执行矩阵-向量积操作。mv 表示 "matrix-vector"，它允许你将一个矩阵与一个向量相乘，得到一个新的向量。以下是一个使用 torch.mv() 函数的示例：

# 创建一个示例矩阵
matrix = torch.tensor([[1, 2, 3],
                       [4, 5, 6]])

# 创建一个示例列向量
vector = torch.tensor([2, 3, 4])

# 执行矩阵-向量积操作
result = torch.mv(matrix, vector)

print("Matrix:")
print(matrix)
print("Vector:")
print(vector)
print("\nMatrix-vector product:")
print(result)

Matrix:
tensor([[1, 2, 3],
        [4, 5, 6]])
Vector:
tensor([2, 3, 4])

Matrix-vector product:
tensor([20, 47])

在这个示例中，我们创建了一个示例 $2 \times 3$ 的矩阵 matrix 和一个示例 $3 \times 1$ 的列向量 vector。然后，我们使用 torch.mv() 函数执行了矩阵-向量积操作，得到一个新的列向量 result。

当你运行这个代码时，输出将显示矩阵、列向量以及它们的矩阵-向量积结果。请注意，torch.mv() 函数要求矩阵的列数与向量的维度相同，以便可以进行矩阵-向量积操作。

在这个示例中，我们使用了 torch.tensor() 函数来创建矩阵 A 和 B。然后，使用 torch.mm() 函数计算了矩阵乘法得到矩阵 C。你也可以用 torch.matmul() 来进行相同的操作。

注意，PyTorch 的矩阵乘法要求矩阵的数据类型为浮点型（如 dtype=torch.float32），因此需要根据需要进行数据类型的指定。

矩阵的乘法

矩阵的乘法是一种将两个矩阵相互组合以产生一个新矩阵的操作。然而，矩阵乘法不同于元素级别的乘法，而是涉及矩阵的行和列之间的组合。

设有两个矩阵 $A$ 和 $B$，其中 $A$ 是一个 $m \times n$ 维矩阵，而 $B$ 是一个 $n \times p$ 维矩阵。要获得它们的乘积 $C$，其中 $C$ 是一个 $m \times p$ 维矩阵，可以使用以下公式：

$$C_{ij} = \sum_{k=1}^{n} A_{ik} \cdot B_{kj}$$

其中 $C_{ij}$ 是 $C$ 矩阵的第 $i$ 行和第 $j$ 列的元素，$A_{ik}$ 是 $A$ 矩阵的第 $i$ 行和第 $k$ 列的元素，$B_{kj}$ 是 $B$ 矩阵的第 $k$ 行和第 $j$ 列的元素。

提示

数学符号 $\sum_{k=1}^{n}$ 表示一个求和符号，它表示将一系列数字按照特定规则相加。其中：

• $k$ 是一个变量，表示求和中的每一项。
• $n$ 是上限，表示求和的最后一项的序号。
• 下标 $k=1$ 表示从 $k$ 的值为 1 开始，即从第一项开始求和。

例如，$\sum_{k=1}^{n} k$ 表示从 $k$ 等于 1 到 $n$ 的每一个整数相加，即 $1 + 2 + 3 + \ldots + n$。这个符号在数学中常用于描述累加的过程，可以用来计算一系列数字的总和。

需要注意的是，矩阵乘法是不满足交换律的，即 $A \cdot B$ 未必等于 $B \cdot A$。此外，矩阵乘法的尺寸要求必须满足 $A$ 矩阵的列数等于 $B$ 矩阵的行数，才能进行乘法操作。

下面给个具体的计算的过程例子：

当涉及矩阵相乘时，我们要确保两个矩阵的维度满足一定的条件，具体来说，第一个矩阵的列数要等于第二个矩阵的行数。下面我将给出一个具体的矩阵相乘的例子，并逐步展示计算过程。

考虑以下两个矩阵相乘的例子：

矩阵 A（2x3）:

| 2  1  3 |
| 0 -1  4 |

矩阵 B（3x2）:

| 2  0 |
| 1 -3 |
| 2  1 |

我们将计算 $A \times B$。

步骤：

1. 确保矩阵 A 的列数等于矩阵 B 的行数。在这个例子中，矩阵 A 的列数为 3，矩阵 B 的行数为 3，满足条件。

2. 初始化结果矩阵 C（2x2）。

3. 计算结果矩阵 C 的每个元素。$C_{ij}$ 的值等于矩阵 A 第 i 行的元素与矩阵 B 第 j 列的元素相乘后的和。

   对于 $C_{11}$（第一行第一列）：

   C_{11} = (2 * 2) + (1 * 1) + (3 * 2) = 4 + 1 + 6 = 11

   对于 $C_{12}$（第一行第二列）：

   C_{12} = (2 * 0) + (1 * -3) + (3 * 1) = 0 - 3 + 3 = 0

   对于 $C_{21}$（第二行第一列）：

   C_{21} = (0 * 2) + (-1 * 1) + (4 * 2) = 0 - 1 + 8 = 7

   对于 $C_{22}$（第二行第二列）：

   C_{22} = (0 * 0) + (-1 * -3) + (4 * 1) = 0 + 3 + 4 = 7

4. 得到最终的结果矩阵 C（2x2）:

| 11  0 |
|  7  7 |

因此，矩阵 A 乘以矩阵 B 的结果为：

| 11  0 |
|  7  7 |

由上可知，乘积矩阵 $C$ 的每个元素是 $A$ 的对应行与 $B$ 的对应列之间的内积。

当使用 PyTorch 进行矩阵乘法操作时，你可以使用 torch.mm() 函数（对于二维矩阵）或者 torch.matmul() 函数（对于多维矩阵）。以下是一个使用 PyTorch 的示例：

# 创建矩阵 A 和 B
A = torch.tensor([[1, 2],
                  [3, 4]])

B = torch.tensor([[5, 6],
                  [7, 8]])

# 计算矩阵乘法
C = torch.mm(A, B)

print("Matrix A:")
print(A)

print("\nMatrix B:")
print(B)

print("\nMatrix C (A * B):")
print(C)

Matrix A:
tensor([[1, 2],
        [3, 4]])

Matrix B:
tensor([[5, 6],
        [7, 8]])

Matrix C (A * B):
tensor([[19, 22],
        [43, 50]])

在这个示例中，我们使用了 torch.tensor() 函数来创建矩阵 A 和 B。然后，使用 torch.mm() 函数计算了矩阵乘法得到矩阵 C。你也可以用 torch.matmul() 来进行相同的操作。

注意，PyTorch 的矩阵乘法要求矩阵的数据类型为浮点型（如 dtype=torch.float32），因此需要根据需要进行数据类型的指定。

范数（Norm）

范数（Norm）是一个用来衡量向量或矩阵大小的数学概念。在线性代数中，范数是一种广泛应用的概念，它是一个衡量向量或矩阵在空间中的大小的函数。范数不仅可以衡量向量的大小，还可以提供有关向量的方向和分布的信息。

在一般情况下，向量 $\mathbf{x}$ 的 $p$-范数（p-norm）可以表示为：

$$\|\mathbf{x}\|_p = \left(|x_1|^p + |x_2|^p + \ldots + |x_n|^p\right)^{\frac{1}{p}}$$

其中，$x_1, x_2, \ldots, x_n$ 是向量 $\mathbf{x}$ 的元素，$n$ 是向量的维度，$p$ 是一个正实数。特别地，当 $p = 2$ 时，得到的是欧几里得范数，也称为二范数。当 $p = 1$ 时，得到的是一范数（绝对值之和范数），当 $p = \infty$ 时，得到的是无穷范数（取绝对值后的最大值）。

矩阵的范数有多种定义，包括 Frobenius 范数、谱范数等，用来衡量矩阵的大小和性质。

当你在一个二维平面上有一个向量时，欧几里得范数（二范数）可以帮助你衡量该向量的大小。例如，假设有一个二维向量 $\mathbf{x} = [3, 4]$，我们可以使用欧几里得范数计算它的大小：

$$\|\mathbf{x}\|_2 = \sqrt{3^2 + 4^2} = 5$$

这里，向量 $\mathbf{x}$ 的欧几里得范数是 $5$，表示这个向量的长度。

事实上，欧几里得距离是一个 $L_2$ 泛数： 假设 $x_1, x_2, \ldots, x_n$，其 $L_2$ 泛数是向量元素平方和的平方根：

$$\|\mathbf{x}\|_2 = \sqrt{\sum_{i=1}^{n}x_i^2}$$

提示

欧几里得距离（Euclidean distance）是用来衡量在二维或多维空间中两点之间的直线距离的度量。它是最常见和直观的距离度量方法，基于直角坐标系中的直线距离公式。

在二维空间中，对于两个点 $P(x_1, y_1)$ 和 $Q(x_2, y_2)$，它们之间的欧几里得距离可以表示为：

$$d(P, Q) = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

在更高维的空间中，例如 $n$ 维空间，对于两个点 $P(\mathbf{p})$ 和 $Q(\mathbf{q})$，它们之间的欧几里得距离可以表示为：

$$d(P, Q) = \sqrt{(q_1 - p_1)^2 + (q_2 - p_2)^2 + \ldots + (q_n - p_n)^2}$$

其中，$p_i$ 和 $q_i$ 分别表示点 $P$ 和点 $Q$ 在第 $i$ 个坐标轴上的坐标。

欧几里得距离衡量了两个点之间的直线最短距离，即最短路径。它在几何学、机器学习、数据挖掘等领域中广泛应用，用于衡量对象的相似性、计算特征之间的距离等。

另一个例子是一范数（绝对值之和范数）。假设有一个二维向量 $\mathbf{y} = [2, -1]$，我们可以使用一范数计算它的大小：

$$\|\mathbf{y}\|_1 = |2| + |-1| = 3$$

这里，向量 $\mathbf{y}$ 的一范数是 $3$，表示这个向量的元素绝对值之和。

这些范数的计算方法是为了帮助你理解向量的大小概念。在实际应用中，范数可以在各种问题中用来衡量向量的大小、相似性和分布。

# 创建两个示例向量
vector_a = torch.tensor([1.0, 2.0, 3.0])
vector_b = torch.tensor([4.0, 5.0, 6.0])

# 计算欧几里得距离（L2 范数距离）
distance = torch.norm(vector_a - vector_b, p=2)

print("Vector A:", vector_a)
print("Vector B:", vector_b)
print("Euclidean distance:", distance.item())

Vector A: tensor([1., 2., 3.])
Vector B: tensor([4., 5., 6.])
Euclidean distance: 5.196152210235596