学习笔记(26)：线性代数-张量的降维求和，简单示例

1.先理解 “轴（Axis）” 的含义

张量的 “轴” 可以理解为 维度的方向索引 。对于形状为 (2, 3, 4) 的张量，3 个轴的含义是：

轴 0（axis=0）：最外层维度，控制 “块” 的数量，长度为 2（即有 2 个 “子张量” 叠在这个维度上）。
轴 1（axis=1）：中间维度，控制每个 “块” 里 “行” 的数量，长度为 3（每个子张量有 3 行）。
轴 2（axis=2）：最内层维度，控制每行里 “列” 的数量，长度为 4（每行有 4 列）。

可以类比成 “2 摞书，每摞有 3 页，每页有 4 个字”，3 个轴对应 “摞 → 页 → 字” 的层级。

2. 求和操作的本质：“压缩” 目标轴

求和（sum）的核心逻辑是 对目标轴上的所有元素做聚合（相加），这会让该轴的 “长度坍缩为 1”，最终在形状里直接 “去掉该轴” 。

本质上，“轴” 只是维度的索引，求和操作通过 压缩目标轴的长度 改变形状，这是张量维度操作的基础逻辑，也和 “广播（Broadcasting）”、“降维（Reduce）” 等操作的原理相通。

一、降维概念

沿轴求和属于降维操作，核心是通过 “压缩一个维度” 减少张量的维度数量或某一维度的长度，概念结合的角度解释：

1.1、从维度数量看降维

原始张量X是3 维（形状(2, 3, 4) ），沿任意轴求和后：

沿轴 0 求和，结果是2 维（形状(3, 4) ）
沿轴 1 求和，结果是2 维（形状(2, 4) ）
沿轴 2 求和，结果是2 维（形状(2, 3) ）

直观体现：3 维→2 维，维度数量减少了 1，这是典型的降维（从更高维数变为更低维数）。

1.2、从维度长度看 “局部降维”

即使维度数量没变（比如 4 维张量沿中间轴求和），某一维度的长度会 “坍缩”：
假设张量形状是(2, 3, 4, 5)，沿轴 1 求和后：

原轴 1 长度是 3，求和后该轴长度消失（形状变为(2, 4, 5) ）
整体维度数量从 4→3，也是降维；若从 “维度长度组合” 看，轴 1 的长度被压缩掉，相当于该维度的 “信息被聚合”，也属于降维的一种表现（压缩特定维度，减少数据在该维度的分布）。

1.3、降维的本质：信息聚合

沿轴求和时，把该轴上多个元素的信息聚合为 1 个（通过相加），导致该轴 “失去独立存在的意义”：

原始轴 0 有 2 个子张量（2 条独立信息），求和后合并成 1 组，这 2 条信息被聚合了→轴 0 被 “降维”
可以类比：把多本 “书”（轴 0 的子张量）的内容按页、按行相加，相当于 “减少了书的数量” 这个维度的独立性。

1.4、和其他降维操作的对比

除了sum，常见的降维操作还有：

mean（沿轴求平均）：同样压缩轴，维度数量 / 长度减少
max/min（沿轴取最大 / 最小）：也是聚合信息，降维
flatten（展平）：直接把高维张量压成 1 维，是更极端的降维

而sum的特殊点在于通过加法聚合信息，本质上和这些操作一样，都是让张量的维度变少 / 某维度长度缩短，所以属于降维。

简单说：只要操作后，张量的维度数量减少，或者某一维度的长度从N>1变成1（甚至消失），都属于降维，沿轴求和完美符合这个特征，所以是降维操作。

二、示例：一个具有形状(2,3,4)的张量，在轴0、1、2上的求和输出是什么形状?

2.1、代码示例

import torch

# 创建一个形状为 (2, 3, 4) 的张量，每个元素是 1 到 24 的整数
X = torch.arange(1, 25).reshape(2, 3, 4)
print("原始张量 X 的形状:", X.shape)
print("X 的内容:\n", X)

# 沿轴 0 求和（压缩轴 0）
sum_axis0 = X.sum(axis=0)
print("\n沿轴 0 求和后的形状:", sum_axis0.shape)
print("沿轴 0 求和后的结果:\n", sum_axis0)

# 沿轴 1 求和（压缩轴 1）
sum_axis1 = X.sum(axis=1)
print("\n沿轴 1 求和后的形状:", sum_axis1.shape)
print("沿轴 1 求和后的结果:\n", sum_axis1)

# 沿轴 2 求和（压缩轴 2）
sum_axis2 = X.sum(axis=2)
print("\n沿轴 2 求和后的形状:", sum_axis2.shape)
print("沿轴 2 求和后的结果:\n", sum_axis2)

2.2、输出结果与解释

2.2.1. 原始张量 `X`

原始张量 X 的形状: torch.Size([2, 3, 4])
X 的内容:
 tensor([[[ 1,  2,  3,  4],
         [ 5,  6,  7,  8],
         [ 9, 10, 11, 12]],

        [[13, 14, 15, 16],
         [17, 18, 19, 20],
         [21, 22, 23, 24]]])

形状解读：
- 轴 0（长度 2）：2 个 “子张量”（用外层中括号分隔）。
- 轴 1（长度 3）：每个子张量有 3 行。
- 轴 2（长度 4）：每行有 4 列。

2.2.2. 沿轴 0 求和（`axis=0`）

沿轴 0 求和后的形状: torch.Size([3, 4])
沿轴 0 求和后的结果:
 tensor([[14, 16, 18, 20],
        [22, 24, 26, 28],
        [30, 32, 34, 36]])

操作逻辑：
将轴 0 的 2 个子张量 对应位置相加（例如 X[0,0,0] + X[1,0,0] = 1+13=14）。
形状变化：
轴 0（长度 2）被压缩，结果形状变为 (3, 4)。

2.2.3. 沿轴 1 求和（`axis=1`）

沿轴 1 求和后的形状: torch.Size([2, 4])
沿轴 1 求和后的结果:
 tensor([[15, 18, 21, 24],
        [51, 54, 57, 60]])

操作逻辑：
对每个子张量的 3 行分别求和（例如第一行 [1,2,3,4] 与第二行 [5,6,7,8]、第三行 [9,10,11,12] 按列相加，得到 [15,18,21,24]）。
形状变化：
轴 1（长度 3）被压缩，结果形状变为 (2, 4)。

2.2.4. 沿轴 2 求和（`axis=2`）

沿轴 2 求和后的形状: torch.Size([2, 3])
沿轴 2 求和后的结果:
 tensor([[10, 26, 42],
        [58, 74, 90]])

操作逻辑：
对每行的 4 个元素分别求和（例如 X[0,0] = [1,2,3,4] 求和得 10，X[0,1] = [5,6,7,8] 求和得 26）。
形状变化：
轴 2（长度 4）被压缩，结果形状变为 (2, 3)。

2.3、可视化理解

用表格形式更直观地展示求和过程：

2.3.1、原始张量 `X`

子张量 0:
┌───────┬───────┬───────┬───────┐
│ 1     │ 2     │ 3     │ 4     │
├───────┼───────┼───────┼───────┤
│ 5     │ 6     │ 7     │ 8     │
├───────┼───────┼───────┼───────┤
│ 9     │ 10    │ 11    │ 12    │
└───────┴───────┴───────┴───────┘

子张量 1:
┌───────┬───────┬───────┬───────┐
│ 13    │ 14    │ 15    │ 16    │
├───────┼───────┼───────┼───────┤
│ 17    │ 18    │ 19    │ 20    │
├───────┼───────┼───────┼───────┤
│ 21    │ 22    │ 23    │ 24    │
└───────┴───────┴───────┴───────┘

2.3.2、沿轴 0 求和（压缩子张量）

结果:
┌───────┬───────┬───────┬───────┐
│ 1+13  │ 2+14  │ 3+15  │ 4+16  │
├───────┼───────┼───────┼───────┤
│ 5+17  │ 6+18  │ 7+19  │ 8+20  │
├───────┼───────┼───────┼───────┤
│ 9+21  │ 10+22 │ 11+23 │ 12+24 │
└───────┴───────┴───────┴───────┘

2.3.3、沿轴 1 求和（压缩行）

子张量 0 结果:
┌───────────────────┐
│ 1+5+9 │ 2+6+10 │
├───────────────────┤
│ 3+7+11│ 4+8+12 │
└───────────────────┘

子张量 1 结果:
┌───────────────────┐
│ 13+17+21 │ 14+18+22 │
├───────────────────┤
│ 15+19+23 │ 16+20+24 │
└───────────────────┘

2.3.4、沿轴 2 求和（压缩列）

子张量 0 结果:
┌───────────┐
│ 1+2+3+4   │
├───────────┤
│ 5+6+7+8   │
├───────────┤
│ 9+10+11+12│
└───────────┘

子张量 1 结果:
┌──────────────┐
│ 13+14+15+16  │
├──────────────┤
│ 17+18+19+20  │
├──────────────┤
│ 21+22+23+24  │
└──────────────┘