张量与高维数组

深度学习中所有数据都以张量（多维数组）的形式存储和计算。一张 RGB 图片是 3 阶张量 (C,H,W)=(3,224,224)；一组文本经 tokenizer 后变成 2 阶张量 (batch, seq_len)；一个 mini-batch 的图片集合则是 4 阶张量 (B,C,H,W)=(32,3,224,224)，约 480 万个浮点数在 GPU 上并行运算。Reshape 将 CNN 最后一层的 (B,512,7,7) 展平为 (B,25088) 送入全连接层；Transpose/Permute 在注意力多头切分 (B,L,H,D)↔(B,H,L,D) 以及图像通道转换 CHW↔HWC 时不可或缺；广播机制让 BatchNorm 的均值 (1,C,1,1) 能直接作用于整个 (B,C,H,W) 特征图，逐元素减均值除标准差。模型参数本身也是张量：GPT-3 拥有 1750 亿个参数张量，训练时每一步都要对等量的梯度张量做加法更新。理解张量形状变换和广播规则，是读懂和调试模型代码的第一步。

一、张量的定义与阶数

二、深度学习中常见的张量形状

三、真实数据的张量表示

四、张量的基本操作

4.1 形状变换（Reshape/View）

改变张量的形状但不改变数据。前提：元素总数不变。

4.2 转置与维度置换（Transpose/Permute）

4.3 广播机制（Broadcasting）

当两个不同形状的张量做逐元素运算时，自动扩展较小张量使其形状匹配。

五、张量在实际模型中的流动

六、代码验证（C# / Rust）

C#（.NET 10）

// dotnet run 即可执行
// ===== 不同阶的张量 =====
float scalar = 3.14f;                          // 0阶
int[] vector = { 1, 2, 3 };                    // 1阶, shape(3)
int[,] matrix = { { 1, 2 }, { 3, 4 } };       // 2阶, shape(2,2)
Console.WriteLine($"标量 shape: ()");
Console.WriteLine($"向量 shape: ({vector.Length},)");
Console.WriteLine($"矩阵 shape: ({matrix.GetLength(0)},{matrix.GetLength(1)})");
Console.WriteLine($"3阶张量 shape: (3,224,224) — 彩色图片");
Console.WriteLine($"4阶张量 shape: (32,3,224,224), 元素数: {32*3*224*224:N0}");

// ===== Reshape：索引映射 =====
int[] a = Enumerable.Range(0, 24).ToArray();  // (24,)
// reshape(2,3,4): a[i,j,k] = a[i*12+j*4+k]
Console.WriteLine($"\nreshape(2,3,4): a[1,2,3] = a[{1*12+2*4+3}] = {a[1*12+2*4+3]}");
Console.WriteLine($"reshape(6,4):   a[5,3] = a[{5*4+3}] = {a[5*4+3]}");
Console.WriteLine($"reshape(-1,6):  → ({24/6},6) 自动推断");

// ===== Flatten (CNN→FC) =====
Console.WriteLine($"\nFlatten: (16,512,7,7) → (16, {512*7*7})");

// ===== Transpose =====
int[,] m = { {1,2,3},{4,5,6} }; // (2,3)
Console.Write("\n原(2×3): ");
for (int r = 0; r < 2; r++) { Console.Write("["); for (int c = 0; c < 3; c++) Console.Write($"{m[r,c]} "); Console.Write("] "); }
Console.Write("\n转(3×2): ");
for (int c = 0; c < 3; c++) { Console.Write("["); for (int r = 0; r < 2; r++) Console.Write($"{m[r,c]} "); Console.Write("] "); }
Console.WriteLine($"\nPyTorch→显示: (3,224,224) C,H,W → (224,224,3) H,W,C");

// ===== 广播 + BatchNorm =====
double[] feat = { 2.0, 4.0, 6.0, 8.0 };
double mu = feat.Average();
double v = feat.Select(x => (x-mu)*(x-mu)).Average();
Console.Write($"\n广播: (32,100) + (100,) = (32,100)");
Console.Write($"\nBatchNorm: μ={mu}, σ²={v}\n  标准化:   ");
foreach (var x in feat) Console.Write($"{(x-mu)/Math.Sqrt(v+1e-5):F3} ");
Console.Write($"\n  缩放(γ=2,β=1): ");
foreach (var x in feat) Console.Write($"{2*((x-mu)/Math.Sqrt(v+1e-5))+1:F3} ");
Console.WriteLine($"\nBatchNorm 广播: (16,64,28,28) - (1,64,1,1)");

Rust

fn main() {
    // ===== 不同阶的张量 =====
    let _scalar = 3.14_f32;                        // 0阶
    let vector = [1, 2, 3];                         // 1阶
    let matrix = [[1, 2], [3, 4]];                  // 2阶
    println!("标量 shape: ()");
    println!("向量 shape: ({},)", vector.len());
    println!("矩阵 shape: ({},{})", matrix.len(), matrix[0].len());
    println!("3阶张量 shape: (3,224,224) — 彩色图片");
    println!("4阶张量 shape: (32,3,224,224), 元素数: {}", 32*3*224*224);

    // ===== Reshape：索引映射 =====
    let a: [i32; 24] = core::array::from_fn(|i| i as i32);
    println!("\nreshape(2,3,4): a[1,2,3] = a[{}] = {}", 1*12+2*4+3, a[1*12+2*4+3]);
    println!("reshape(6,4):   a[5,3] = a[{}] = {}", 5*4+3, a[5*4+3]);
    println!("reshape(-1,6):  → ({},6) 自动推断", 24/6);

    // ===== as_chunks (Rust 1.88+): 平坦数组 → 块结构 =====
    let (rows, _) = a.as_chunks::<4>();
    println!("as_chunks(4):   共{}行, 第2行={:?}", rows.len(), rows[1]);

    // ===== Flatten =====
    println!("\nFlatten: (16,512,7,7) → (16, {})", 512*7*7);

    // ===== Transpose =====
    let m = [[1,2,3],[4,5,6]];
    print!("\n原(2×3): ");
    for r in 0..2 { print!("["); for c in 0..3 { print!("{} ", m[r][c]); } print!("] "); }
    print!("\n转(3×2): ");
    for c in 0..3 { print!("["); for r in 0..2 { print!("{} ", m[r][c]); } print!("] "); }
    println!("\nPyTorch→显示: (3,224,224) C,H,W → (224,224,3) H,W,C");

    // ===== 广播 + BatchNorm =====
    let feat = [2.0, 4.0, 6.0, 8.0_f64];
    let mut mu = 0.0; for i in 0..4 { mu += feat[i]; } mu /= 4.0;
    let mut v = 0.0; for i in 0..4 { v += (feat[i]-mu).powi(2); } v /= 4.0;
    print!("\n广播: (32,100) + (100,) = (32,100)");
    print!("\nBatchNorm: μ={mu}, σ²={v}\n  标准化:   ");
    for i in 0..4 { print!("{:.3} ", (feat[i]-mu)/(v+1e-5).sqrt()); }
    print!("\n  缩放(γ=2,β=1): ");
    for i in 0..4 { print!("{:.3} ", 2.0_f64.mul_add((feat[i]-mu)/(v+1e-5).sqrt(), 1.0)); }
    println!("\nBatchNorm 广播: (16,64,28,28) - (1,64,1,1)");
}