学习笔记(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 │
└──────────────┘- 沿轴
k求和：将该轴上的所有元素相加，导致该轴的长度 从N坍缩为 1，最终形状中 去掉轴k。
:LeetCode 234. 回文链表（Palindrome Linked List）详解)
