【深度学习】— 线性代数基础-标量、向量、矩阵、张量、张量算法的基本性质、按元素运算示例、Hadamard积、标量与张量运算、广播机制、降维、点积、矩阵-向量积、矩阵-矩阵乘法、范数

标量

标量是仅包含一个数值的量，如温度52°F。在将其转换为摄氏温度时，公式
$$c=\frac{5}{9}(f-32)$$
中，$5$、$9$、$32$都是标量，而$c$和$f$是变量。用数学表示，$x\in \mathbb{R}$ 表示$x$是实数标量，符号$\in$表示“属于”。

标量可以用一个元素的张量表示，代码示例如下：

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

向量

向量可以视为标量值组成的列表，这些标量称为向量的元素或分量。在数据集中，向量的每个分量通常代表现实中的特征。例如，在预测贷款违约风险时，向量可能表示一个申请人的收入、工作年限、违约次数等信息。在数学中，向量通常用粗体小写字母（如$x$、$y$、$z$）表示。

我们使用一维张量来处理向量。张量的长度取决于计算机的内存限制。例如：

import torch
x = torch.arange(4)
x
# 输出: tensor([0, 1, 2, 3])

向量中的任一元素可以通过下标引用，如$x_i$表示第$i$个元素。在数学中，列向量通常表示为：

$$\mathbf{x}=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]$$

其中，$x_1,\dots ,x_n$是向量的元素。在代码中，可以通过索引访问向量元素，例如：

x[3]
# 输出: tensor(3)

长度、维度和形状

向量是一个数字数组，每个向量都有一个长度。在数学表示中，如果一个向量$\mathbf{x}$由$n$个实值标量组成，则表示为 $\mathbf{x}\in {\mathbb{R}}^n$。向量的长度通常称为维度（dimension）。

与Python数组类似，我们可以通过len()函数获取张量的长度：

len(x)
# 输出: 4

当用张量表示一个向量（只有一个轴）时，可以通过.shape属性访问其长度。形状（shape）是一个包含张量沿每个轴的长度的元组，对于只有一个轴的张量，形状只有一个元素：

x.shape
# 输出: torch.Size([4])

请注意，“维度”在不同上下文中可能有不同含义。为了避免混淆：

• 向量或轴的维度：表示向量或轴的长度，即元素的数量。
• 张量的维度：表示张量的轴数。张量的某个轴的维数就是该轴的长度。

矩阵

矩阵是向量的扩展，可以看作是由标量组成的二维数组。我们通常用粗体、大写字母（如$X$、$Y$、$Z$）表示矩阵。在代码中，矩阵是具有两个轴的张量。

在数学表示中，一个矩阵 $A\in {\mathbb{R}}^{m\times n}$ 表示由 $m$ 行 $n$ 列的实值标量组成的矩阵$A$，其中每个元素$a_{ij}$位于第$i$行第$j$列：

$$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}\end{array}\right]$$

对于任意矩阵$A\in {\mathbb{R}}^{m\times n}$，它的形状为$(m,n)$，当行和列相等时，矩阵称为方阵。我们可以在代码中创建一个5×4的矩阵：

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

可以通过行索引$i$和列索引$j$访问矩阵中的元素$a_{ij}$。矩阵的转置（transpose）将行和列互换，表示为$A^{\top }$。例如，$B=A^{\top }$表示转置矩阵$B$，代码如下：

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^{\top }$。示例如下：

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

矩阵是非常有用的数据结构，可以用于组织不同模式的数据。通常，矩阵的行代表不同样本，列代表属性，这在深度学习和表格数据处理中非常常见。

张量

张量是对具有更多轴的数据结构的推广，可以看作是$n$维数组的通用描述方式。向量是一阶张量，矩阵是二阶张量，而更高阶的张量可以拥有更多的轴。通常用特殊字体的大写字母（如$X$、$Y$、$Z$）来表示张量，索引方式与矩阵类似（如$x_{ijk}$或$[X{]}_{1,2i-1,3}$）。

当处理图像时，张量非常重要，图像可以用一个三维张量表示，三个轴分别对应于高度、宽度和通道（例如红色、绿色和蓝色通道）。我们可以通过以下代码构建一个三维张量：

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

这里的张量$X$是一个三阶张量，形状为$(2,3,4)$，分别对应于张量的三个轴。高阶张量将帮助我们处理更复杂的数据结构。

张量算法的基本性质

标量、向量、矩阵和任意数量轴的张量都具有一些常见的性质。例如，任何按元素的一元操作（如取负、平方）不会改变张量的形状。同样，对于两个具有相同形状的张量，按元素的二元运算（如加法、乘法）的结果也将是相同形状的张量。

按元素运算示例

以下代码展示了两个形状相同的矩阵按元素相加的结果：

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通过分配新内存，将A的一个副本分配给B
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.]]))

Hadamard积

两个矩阵的按元素乘法称为Hadamard积（Hadamard product），记作 $A\odot B$。对于矩阵 $A\in {\mathbb{R}}^{m\times n}$ 和 $B\in {\mathbb{R}}^{m\times n}$，其Hadamard积为：

$$A\odot B=\left[\begin{array}{cccc}{a}_{11}{b}_{11}& a_{12}{b}_{12}& \cdots & a_{1n}{b}_{1n}\\ a_{21}{b}_{21}& a_{22}{b}_{22}& \cdots & a_{2n}{b}_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}{b}_{m1}& a_{m2}{b}_{m2}& \cdots & a_{mn}{b}_{mn}\end{array}\right]$$

在代码中，使用*运算符实现Hadamard积：

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

广播机制

在前面的部分中，我们介绍了如何对相同形状的两个张量进行按元素操作。但在某些情况下，即使张量形状不同，我们仍然可以使用广播机制来执行按元素操作。

广播机制的工作原理

1. 通过适当复制元素，将一个或两个张量扩展为相同的形状。
2. 对扩展后的张量进行按元素操作。

通常，广播沿着长度为1的轴进行。以下示例展示了这一机制：

import torch
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
# 输出:
# (tensor([[0],
#          [1],
#          [2]]),
#  tensor([[0, 1]]))

在这个例子中，$a$ 是一个 $3\times 1$ 的矩阵，$b$ 是一个 $1\times 2$ 的矩阵。它们的形状不匹配，但通过广播机制，矩阵 $a$ 的列被复制，矩阵 $b$ 的行被复制，形成一个 $3\times 2$ 的矩阵，随后进行按元素相加：

a + b
# 输出:
# tensor([[0, 1],
#         [1, 2],
#         [2, 3]])

降维

张量的一个常用操作是计算其元素的和，表示为 $\sum$。对于长度为 $d$ 的向量 $\mathbf{x}$，其元素和可记为 ${\sum }_{i=1}^d{x}_i$。在代码中，我们可以使用 sum() 函数：

import torch
x = torch.arange(4, dtype=torch.float32)
x, x.sum()
# 输出: (tensor([0., 1., 2., 3.]), tensor(6.))

对于任意形状的张量，我们也可以计算其元素和。例如，矩阵 $A$ 的元素和表示为 ${\sum }_{i=1}^m{\sum }_{j=1}^n{a}_{ij}$：

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
A.shape, A.sum()
# 输出: (torch.Size([5, 4]), tensor(190.))

默认情况下，sum() 会沿所有轴求和，使张量变为一个标量。可以通过指定 axis 参数来沿特定轴求和。例如，axis=0 将对所有行进行求和（沿轴0降维）：

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
# 输出: (tensor([40., 45., 50., 55.]), torch.Size([4]))

指定 axis=1 将对所有列求和（沿轴1降维）：

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()
# 输出: tensor(190.)

平均值

平均值（mean）通过将总和除以元素总数计算，可使用 mean() 函数：

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

非降维求和

有时，我们希望在求和时保持张量的轴数不变，可使用 keepdims=True：

sum_A = A.sum(axis=1, keepdims=True)
sum_A
# 输出: tensor([[ 6.],
#              [22.],
#              [38.],
#              [54.],
#              [70.]])

保持维度不变后，我们可以通过广播将 $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]])

累积总和

如果要沿某个轴计算元素的累积总和，可以使用 cumsum() 函数，例如沿 axis=0：

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

点积（Dot Product）

除了按元素操作、求和和平均值外，点积也是一个基本操作。给定两个向量 $\mathbf{x},\mathbf{y}\in {\mathbb{R}}^d$，它们的点积 ${\mathbf{x}}^{\top }\mathbf{y}$ （或 $⟨\mathbf{x},\mathbf{y}⟩$）是对应位置元素乘积的和：

$${\mathbf{x}}^{\top }\mathbf{y}=\sum _{i=1}^d{x}_i{y}_i$$

在代码中可以通过 torch.dot() 计算点积：

import torch
x = torch.arange(4, dtype=torch.float32)
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.)

点积的应用

点积在许多场合非常有用。例如，对于向量 $\mathbf{x}\in {\mathbb{R}}^d$ 和权重向量 $\mathbf{w}\in {\mathbb{R}}^d$，${\mathbf{x}}^{\top }\mathbf{w}$ 表示 $\mathbf{x}$ 中的值根据权重 $\mathbf{w}$ 的加权和。当权重 $\mathbf{w}$ 为非负数且和为1（即 ${\sum }_{i=1}^d{w}_i=1$）时，点积表示加权平均。此外，将两个向量规范化为单位长度后，点积表示它们夹角的余弦。

矩阵-向量积

在理解了点积之后，我们可以进一步讨论矩阵-向量积（matrix-vector product）。给定矩阵 $A\in {\mathbb{R}}^{m\times n}$ 和向量 $\mathbf{x}\in {\mathbb{R}}^n$，可以将矩阵 $A$ 表示为它的行向量的集合：

$$A=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_m^{\top }\end{array}\right]$$

其中，${\mathbf{a}}_i^{\top }\in {\mathbb{R}}^n$ 是矩阵 $A$ 的第 $i$ 行。矩阵-向量积 $A\mathbf{x}$ 是一个长度为 $m$ 的列向量，其第 $i$ 个元素是 ${\mathbf{a}}_i^{\top }\mathbf{x}$ 的点积：

$$A\mathbf{x}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\mathbf{x}\\ {\mathbf{a}}_2^{\top }\mathbf{x}\\ ⋮\\ {\mathbf{a}}_m^{\top }\mathbf{x}\end{array}\right]$$

矩阵 $A\in {\mathbb{R}}^{m\times n}$ 的乘法可以视为一个从 ${\mathbb{R}}^n$ 到 ${\mathbb{R}}^m$ 的向量转换。这在各种应用中非常有用，例如，方阵的乘法可以表示旋转操作。在神经网络中，矩阵-向量积用于描述从一层到下一层的计算。

代码示例

在代码中，可以使用 torch.mv() 计算矩阵-向量积。请注意，矩阵 $A$ 的列数（轴1的长度）必须与向量 $\mathbf{x}$ 的维数（长度）相同：

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
x = torch.arange(4, dtype=torch.float32)
A.shape, x.shape, torch.mv(A, x)
# 输出: (torch.Size([5, 4]), torch.Size([4]), tensor([ 14., 38., 62., 86., 110.]))

矩阵-矩阵乘法

在掌握了点积和矩阵-向量积后，理解矩阵-矩阵乘法（matrix-matrix multiplication）会更加容易。

假设我们有两个矩阵 $A\in {\mathbb{R}}^{n\times k}$ 和 $B\in {\mathbb{R}}^{k\times m}$：

$$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1k}\\ a_{21}& a_{22}& \cdots & a_{2k}\\ ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& \cdots & a_{nk}\end{array}\right],B=\left[\begin{array}{cccc}{b}_{11}& b_{12}& \cdots & b_{1m}\\ b_{21}& b_{22}& \cdots & b_{2m}\\ ⋮& ⋮& \ddots & ⋮\\ b_{k1}& b_{k2}& \cdots & b_{km}\end{array}\right]$$

矩阵 $A$ 的第 $i$ 行向量表示为 ${\mathbf{a}}_i^{\top }\in {\mathbb{R}}^k$，矩阵 $B$ 的第 $j$ 列向量表示为 ${\mathbf{b}}_j\in {\mathbb{R}}^k$。为了生成矩阵积 $C=AB$，我们可以将每个元素 $c_{ij}$ 表示为 ${\mathbf{a}}_i^{\top }{\mathbf{b}}_j$ 的点积：

$$C=AB=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_n^{\top }\end{array}\right]\cdot \left[\begin{array}{cccc}{\mathbf{b}}_1& {\mathbf{b}}_2& \cdots & {\mathbf{b}}_m\end{array}\right]=\left[\begin{array}{cccc}{\mathbf{a}}_1^{\top }{\mathbf{b}}_1& {\mathbf{a}}_1^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_1^{\top }{\mathbf{b}}_m\\ {\mathbf{a}}_2^{\top }{\mathbf{b}}_1& {\mathbf{a}}_2^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_2^{\top }{\mathbf{b}}_m\\ ⋮& ⋮& \ddots & ⋮\\ {\mathbf{a}}_n^{\top }{\mathbf{b}}_1& {\mathbf{a}}_n^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_n^{\top }{\mathbf{b}}_m\end{array}\right]$$

矩阵-矩阵乘法 $AB$ 可以看作是对矩阵 $B$ 的 $m$ 个列向量分别执行 $m$ 次矩阵-向量积，并将结果拼接成一个 $n\times m$ 矩阵。

代码示例

在代码中，可以使用 torch.mm() 执行矩阵-矩阵乘法。例如，$A$ 是一个 5×4 的矩阵，$B$ 是一个 4×3 的矩阵，两者相乘后得到一个 5×3 的矩阵：

import torch
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
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.]])

请注意，矩阵-矩阵乘法是矩阵乘法的标准定义，与之前提到的Hadamard积不同。

范数

在线性代数中，范数（norm）是用于测量向量大小的函数，表示向量有多大。它将向量映射到标量并满足一些属性：

1. 缩放不变性：给定常数因子 $\alpha$，向量 $x$ 的范数满足：
   $$f(\alpha x)=|\alpha |f(x)$$

2. 三角不等式：两个向量 $x$ 和 $y$ 的范数满足：
   $$f(x+y)\le f(x)+f(y)$$

3. 非负性：范数总是非负的：
   $$f(x)\ge 0$$

4. 零向量的范数为0：只有当向量所有元素都为0时，范数才为0：
   $$\forall i,[x{]}_i=0⟺f(x)=0$$

L2范数

L2范数（Euclidean norm）是最常用的范数，表示为：
$$\Vert x{\Vert }_2=\sqrt{\sum _{i=1}^n{x}_i^2}$$
在代码中，我们可以使用 torch.norm() 来计算L2范数：

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

L1范数

L1范数是向量元素绝对值的和：
$$\Vert x{\Vert }_1=\sum _{i=1}^n|x_i|$$
计算L1范数的代码如下：

torch.abs(u).sum()
# 输出: tensor(7.)

Lp范数

Lp范数是L1和L2范数的推广，定义为：
$$\Vert x{\Vert }_p={\left(\sum _{i=1}^n|x_i{|}^p\right)}^{1/p}$$

Frobenius范数

对于矩阵 $X\in {\mathbb{R}}^{m\times n}$，Frobenius范数定义为：
$$\Vert X{\Vert }_F=\sqrt{\sum _{i=1}^m\sum _{j=1}^n{x}_{ij}^2}$$
在代码中，可以通过 torch.norm() 计算矩阵的Frobenius范数：

torch.norm(torch.ones((4, 9)))
# 输出: tensor(6.)

范数与目标

在深度学习中，范数常用于表示目标函数，帮助我们解决优化问题，例如最大化观测数据的概率或最小化预测与真实观测之间的距离。

小结

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

练习

1. 证明：一个矩阵 $A$ 的转置的转置等于 $A$，即 $(A^{\top }{)}^{\top }=A$。

证明：

设矩阵 $A$ 的元素为 $A_{ij}$，则其转置矩阵 $A^{\top }$ 的元素为：

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

再对 $A^{\top }$ 取转置：

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

因此，$(A^{\top }{)}^{\top }=A$。

---

2. 证明：给定两个矩阵 $A$ 和 $B$，它们转置的和等于它们和的转置，即 $A^{\top }+B^{\top }=(A+B{)}^{\top }$。

证明：

对于任意元素 $i,j$，有：

$$\begin{array}{rl}(A^{\top }+B^{\top }{)}_{ij}& =A_{ij}^{\top }+B_{ij}^{\top }=A_{ji}+B_{ji}\\ (A+B{)}_{ij}^{\top }& =(A+B{)}_{ji}=A_{ji}+B_{ji}\end{array}$$

因此：

$$A^{\top }+B^{\top }=(A+B{)}^{\top }$$

---

3. 问题：给定任意方阵 $A$，$A+A^{\top }$ 总是对称的吗？为什么？

回答：

是的，任意方阵 $A$ 与其转置之和 $A+A^{\top }$ 总是对称矩阵。

证明：

计算 $A+A^{\top }$ 的转置：

$$(A+A^{\top }{)}^{\top }=A^{\top }+(A^{\top }{)}^{\top }=A^{\top }+A$$

由于矩阵加法满足交换律：

$$A^{\top }+A=A+A^{\top }$$

因此：

$$(A+A^{\top }{)}^{\top }=A+A^{\top }$$

这表明 $A+A^{\top }$ 是对称矩阵。

---

4. 问题：在本节中，我们定义了形状为 (2, 3, 4) 的张量 $X$，len(X) 的输出结果是什么？

回答：

len(X) 的输出结果是 2，即张量 $X$ 在第 0 轴（第一个维度）的长度。

---

5. 问题：对于任意形状的张量 $X$，len(X) 是否总是对应于 $X$ 特定轴的长度？这个轴是什么？

回答：

是的，len(X) 总是返回张量 $X$ 在 第 0 轴（第一个维度）的长度。

---

6. 实验：运行 A / A.sum(axis=1)，看看会发生什么。你能分析原因吗？

回答：

运行 A / A.sum(axis=1) 会将矩阵 $A$ 的每个元素除以其所在行的元素之和。

分析：

• A.sum(axis=1) 计算矩阵 $A$ 每一行的元素之和，得到一个形状为 $(n,)$ 的一维数组，其中 $n$ 是 $A$ 的行数。
• 当执行 A / A.sum(axis=1) 时，利用了广播机制，将每一行的元素分别除以对应的行和。
• 结果是对矩阵 $A$ 进行行归一化，使得每一行的元素之和为 1。

---

7. 问题：考虑一个形状为 (2, 3, 4) 的张量，在轴 0、1、2 上的求和输出是什么形状？

回答：

• 轴 0 求和：输出形状为 (3, 4)
• 轴 1 求和：输出形状为 (2, 4)
• 轴 2 求和：输出形状为 (2, 3)

解释：

• 轴 0：消除了第一个维度（大小为 2），剩余维度为 (3, 4)。
• 轴 1：消除了第二个维度（大小为 3），剩余维度为 (2, 4)。
• 轴 2：消除了第三个维度（大小为 4），剩余维度为 (2, 3)。

---

8. 实验：为 linalg.norm 函数提供一个有 3 个或更多轴的张量，并观察其输出。对于任意形状的张量，这个函数计算得到什么？

回答：

当将一个具有 3 个或更多轴的张量传递给 linalg.norm 函数时，它将计算张量所有元素的平方和的平方根，即弗罗贝尼乌斯范数。

解释：

• linalg.norm 默认计算 2-范数，对于多维张量，会将其展平成一维向量后计算范数。

• 计算公式为：

  $$\Vert X\Vert =\sqrt{\sum _{i,j,k,\dots }|X_{i,j,k,\dots }{|}^2}$$

• 这表示对张量中所有元素进行平方求和，然后取平方根。

---