1. 什么是张量？

• 张量是一种可以包含很多维度（轴）的数据结构。就像向量是从标量（数字）扩展而来，矩阵是从向量扩展而来的，张量则是从矩阵扩展而来的。
• 张量可以用特殊的大写字母（例如X、Y、Z）表示，索引方法类似于矩阵。

2. 张量的维度

• 零阶张量：这是一个标量，比如数字5。

• 一阶张量：这是一个向量，比如 ([1, 2, 3])。

• 二阶张量：这是一个矩阵，比如：
  

• 三阶张量：这是一个包含多个矩阵的结构。比如一个形状为 (2 \times 3 \times 4) 的张量，可以想象成有两个“层”，每层是一个 (3 \times 4) 的矩阵。

举个例子

我们可以用代码创建一个三阶张量：

import numpy as np

X = np.arange(24).reshape(2, 3, 4)
print(X)

这个代码会输出：

array([[[ 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) 是一个包含24个数字的三阶张量。

3. 张量的基本性质

• 张量具有一些很好的特性，比如对其进行加法或乘法运算时，结果仍然保持相同的形状。
• 例如，如果我们将两个相同形状的矩阵相加，结果还是一个相同形状的矩阵：

A = np.arange(20).reshape(5, 4)
B = A.copy()  # 复制 A
print(A + B)

输出结果是：

array([[ 0.,  2.,  4.,  6.],
       [ 8., 10., 12., 14.],
       [16., 18., 20., 22.],
       [24., 26., 28., 30.],
       [32., 34., 36., 38.]])

4. 哈达玛积

5. 张量与标量运算

• 将一个张量加上或乘以一个标量（数字）时，张量的形状不会改变。比如：

a = 2
X = np.arange(24).reshape(2, 3, 4)
print(a + X)
print((a * X).shape)

输出结果会显示张量的每个元素都和2相加，形状保持为 (2 \times 3 \times 4)。

总结

• 张量是一种多维的数据结构，可以包含许多数字。
• 张量的运算遵循简单的规则，比如加法和乘法后，形状保持不变。
• 张量在处理复杂数据（比如图像、视频等）时非常有用。

汇总：张量的求和与平均值

在处理张量时，一个非常有用的操作是计算其元素的总和。我们通常使用符号 ∑ 来表示求和。在这部分，我们将介绍如何计算任意张量的元素和，以及如何计算平均值。

1. 计算张量元素的和

• 例如，对于一个长度为 (d) 的向量，元素的总和可以表示为：
  

• 在代码中，我们可以使用 NumPy 的 sum() 函数来实现：

import numpy as np

x = np.arange(4)
print(x)           # 输出：array([0., 1., 2., 3.])
print(x.sum())    # 输出：array(6.)

2. 矩阵元素的和

• 在代码中，我们同样可以计算：

A = np.arange(20).reshape(5, 4)
print(A.shape)    # 输出：(5, 4)
print(A.sum())    # 输出：array(190.)

• 默认情况下，sum() 函数会计算所有元素的总和，输出一个标量。

3. 指定轴进行求和

• 我们可以通过指定 axis 参数来对特定维度进行求和：

  • 沿着行（轴0）求和：

    A_sum_axis0 = A.sum(axis=0)
    print(A_sum_axis0)        # 输出：array([40., 45., 50., 55.])
    print(A_sum_axis0.shape)  # 输出：(4,)
    

    这里，输出的形状是 ( (4,) )，因为轴0的维度被丢弃。

  • 沿着列（轴1）求和：

    A_sum_axis1 = A.sum(axis=1)
    print(A_sum_axis1)        # 输出：array([ 6., 22., 38., 54., 70.])
    print(A_sum_axis1.shape)  # 输出：(5,)
    

    这里，输出的形状是 ( (5,) )，因为轴1的维度被丢弃。

• 如果同时沿着行和列求和，得到的结果与对所有元素求和相同：

total_sum = A.sum(axis=[0, 1])  # 等同于 A.sum()
print(total_sum)                 # 输出：array(190.)

4. 计算平均值

• 平均值（mean或average）是通过将总和除以元素总数计算得出的。我们可以使用 NumPy 的 mean() 函数来计算：

print(A.mean())           # 输出：array(9.5)
print(A.sum() / A.size)   # 输出：array(9.5)

• 同样，我们可以沿着指定的轴计算平均值：

print(A.mean(axis=0))                # 输出：array([ 8.,  9., 10., 11.])
print(A.sum(axis=0) / A.shape[0])    # 输出：array([ 8.,  9., 10., 11.])

总结

• 张量的元素和可以通过 sum() 函数计算，且可以指定计算的轴。
• 平均值可以通过总和除以元素总数获得，并且同样可以指定轴进行计算。
• 这些操作对于数据分析和处理非常重要，帮助我们从数据中提取有用的信息。

非汇总求和与点积

在处理张量时，有时我们希望在计算总和或均值的同时保持轴数不变。这可以通过设置 keepdims=True 参数来实现。

1. 非汇总求和

• 当我们希望在保持轴数的同时进行求和时，可以使用如下代码：

sum_A = A.sum(axis=1, keepdims=True)
print(sum_A)

输出：

array([[ 6.],
       [22.],
       [38.],
       [54.],
       [70.]])

• sum_A 仍然保持两个轴，这使得我们可以使用广播机制将 A 除以 sum_A：

normalized_A = A / sum_A
print(normalized_A)

输出：

array([[0. , 0.16666667, 0.33333334, 0.5 ],
       [0.18181819, 0.22727273, 0.27272728, 0.3181818 ],
       [0.21052632, 0.23684211, 0.2631579 , 0.28947368],
       [0.22222222, 0.24074075, 0.25925925, 0.2777778 ],
       [0.22857143, 0.24285714, 0.25714287, 0.27142859]])

• 这样，我们就得到了按行归一化的结果。

2. 累积总和

• 如果我们想计算元素的累积总和，可以使用 cumsum() 函数：

cumsum_A = A.cumsum(axis=0)
print(cumsum_A)

输出：

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  6.,  8., 10.],
       [12., 15., 18., 21.],
       [24., 28., 32., 36.],
       [40., 45., 50., 55.]])

• 这里，cumsum_A 中的每个元素是矩阵 (A) 在对应位置上所有前面元素的累积和。

1.3.8 点积（Dot Product）

• 点积是线性代数中一个基本而重要的操作。给定两个向量 (x) 和 (y)（均属于 ( \mathbb{R}^d )），它们的点积表示为：
  

• 在代码中，点积可以通过 NumPy 的 dot() 函数实现：

y = np.ones(4)
x = np.arange(4)
dot_product = np.dot(x, y)
print(x, y, dot_product)

输出：

(array([0., 1., 2., 3.]), array([1., 1., 1., 1.]), array(6.))

• 注意，点积也可以通过按元素相乘后再求和来实现：

dot_product_alternate = np.sum(x * y)
print(dot_product_alternate)

输出：

array(6.)

3. 点积的应用

• 点积在多个场合中都有用处。例如，给定向量 (x) 和权重 (w)，点积可

总结

• 通过设置 keepdims=True，我们可以在求和时保持张量的维度，从而方便后续的操作。
• 点积是一种非常基本且广泛使用的操作，它在加权平均和计算夹角余弦等应用中非常重要。