【youcans的深度学习 10】PyTorch入门教程：张量的统计运算与比较运算

欢迎关注『youcans的深度学习』系列，持续更新中…
【youcans的深度学习 01】安装环境之 miniconda
【youcans的深度学习 02】PyTorch CPU版本安装与环境配置
【youcans的深度学习 03】PyTorch CPU版本安装与环境配置
【youcans的深度学习 04】PyTorch入门教程：基础知识
【youcans的深度学习 05】PyTorch入门教程：快速入门
【youcans的深度学习 06】PyTorch入门教程：张量的基本操作 1
【youcans的深度学习 07】PyTorch入门教程：张量的基本操作 2
【youcans的深度学习 08】PyTorch入门教程：张量的就地操作和广播机制
【youcans的深度学习 09】PyTorch入门教程：张量的逐点运算
【youcans的深度学习 10】PyTorch入门教程：张量的统计运算与比较运算

【youcans的深度学习 10】PyTorch入门教程：张量的统计运算与比较运算

- 3. 张量的统计分析运算
- - 3.1 均值、方差与求和
  - 3.2 最大值与最小值
  - 3.3 累积乘与累积和
- 4. 张量的比较操作
- 5. 张量的线性代数运算

PyTorch 中支持 100 多种张量操作，包括转置、索引、切⽚、数学运算、线性代数、随机数等等，详见【PyTorch官方文档】。

3. 张量的统计分析运算

张量的归约运算，是对张量进行某种聚合总结，而得到计算结果的函数。规约运算主要包含数据科学领域内的诸多统计分析函数，如均值、极值、方差、中位数函数等等。

3.1 均值、方差与求和

函数原型：

torch.sum(input, dim, keepdim=False, *, dtype=None) → Tensor # 张量求和
torch.mean(input, dim, keepdim=False, *, dtype=None, out=None) → Tensor # 张量的均值
torch.nanmean(input, dim=None, keepdim=False, *, dtype=None) → Tensor # 非Nan元素的均值
torch.var(input, dim=None, *, correction=1, keepdim=False, out=None) → Tensor # 张量的方差
torch.std(input, dim=None, *, correction=1, keepdim=False, out=None) → Tensor # 张量的标准差
torch.var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) # 张量的方差和均值

参数说明：

input，张量，输入张量。
dim，整数或整型元组，指定维度。
out，张量，输出张量。
keepdim，布尔值，输出张量是否保留 dim，可选项，默认为 False
correction，整数，可选项，默认值为 1 表示 Bessel 校正

函数说明：
（1）函数返回张量沿指定维度 dim 的所有元素的均值、方差与求和。参数 dim 缺省时，函数默认对张量的所有元素进行计算，返回 0 维张量。参数 dim 为整数或整型元组时，按照 dim 指定维度的所有元素进行计算。
（2）函数 torch.var_mean、torch.std_mean 返回一个元组，元组的元素分别是方差和均值。
（3）函数 torch.nanmean 返回张量沿指定维度的非Nan元素的平均值。

# (10) 张量的统计分析运算：均值、方差与求和
# 张量求和
x = torch.arange(1, 16).reshape(3, 5)  # torch.Size([3, 5])
print(x)
s1 = torch.sum(x)  # 张量所有元素求和
s2 = torch.sum(x, dim=0)  # 按指定dim求和
s3 = torch.sum(x, dim=1)  # 按指定dim求和
print("sum(x):", s1)  # torch.Size([])
print("sum(x,0):", s2)  # torch.Size([5])
print("sum(x,1):", s3)  # torch.Size([3])
print(s1.shape, s2.shape, s3.shape)
# tensor([[ 1,  2,  3,  4,  5],
#         [ 6,  7,  8,  9, 10],
#         [11, 12, 13, 14, 15]])
# sum(x): tensor(120)
# sum(x,0): tensor([18, 21, 24, 27, 30])
# sum(x,1): tensor([15, 40, 65])
# torch.Size([]) torch.Size([5]) torch.Size([3])# 张量均值
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
m1 = torch.mean(x)  # 张量所有元素求均值
m2 = torch.mean(x, dim=0)  # 按指定dim求均值
m3 = torch.mean(x, dim=1)  # 按指定dim求均值
print("mean(x):", m1)  # torch.Size([])
print("mean(x,0):", m2)  # torch.Size([5])
print("mean(x,1):", m3)  # torch.Size([3])
print(m1.shape, m2.shape, m3.shape)
# mean(x): tensor(8.)
# mean(x,0): tensor([ 6.,  7.,  8.,  9., 10.])
# mean(x,1): tensor([ 3.,  8., 13.])
# torch.Size([]) torch.Size([5]) torch.Size([3])# 张量方差
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
v1 = torch.var(x)  # 张量所有元素求方差
v2 = torch.var(x, dim=0)  # 按指定dim求方差
v3 = torch.var(x, dim=1)  # 按指定dim求方差
print("var(x):", v1)  # torch.Size([])
print("var(x,0):", v2)  # torch.Size([5])
print("var(x,1):", v3)  # torch.Size([3])
print(v1.shape, v2.shape, v3.shape)
# var(x): tensor(20.)
# var(x,0): tensor([25., 25., 25., 25., 25.])
# var(x,1): tensor([2.5000, 2.5000, 2.5000])
# torch.Size([]) torch.Size([5]) torch.Size([3])# 张量标准差
x = torch.arange(1.0, 16.0).reshape(3,5)  # torch.Size([3, 5])
s1 = torch.std(x)  # 张量所有元素求标准差
s2 = torch.std(x, dim=0)  # 按指定dim求标准差
s3 = torch.std(x, dim=1)  # 按指定dim求标准差
print("std(x):", s1)  # torch.Size([])
print("std(x,0):", s2)  # torch.Size([5])
print("std(x,1):", s3)  # torch.Size([3])
print(s1.shape, s2.shape, s3.shape)
# std(x): tensor(4.4721)
# std(x,0): tensor([5., 5., 5., 5., 5.])
# std(x,1): tensor([1.5811, 1.5811, 1.5811])
# torch.Size([]) torch.Size([5]) torch.Size([3])

3.2 最大值与最小值

函数原型：

torch.max(input, dim, keepdim=False, *, out=None) → out # 张量的最大值
torch.max(input, other, *, out=None) → out # 两个张量的最大值
torch.min(input, dim, keepdim=False, *, out=None) → out # 张量的最小值
torch.min(input, other, *, out=None) → out # 两个张量的最小值
torch.argmax(input, dim, keepdim=False) → Tensor # 张量的最大值索引
torch.argmin(input, dim, keepdim=False) → Tensor # 张量的最小值索引
torch.topk(input, k, dim=None, largest=True, sorted=True, *, out=None) # k 个最大/小值
torch.median(input, dim, keepdim=False, *, out=None) → out # 张量的中值

参数说明：

input，张量，输入张量。
dim，整数或整型元组，指定维度。
out，张量，输出张量。
keepdim，布尔值，输出张量是否保留 dim，可选项，默认为 False
other，张量，另一个输入张量，形状与 input 相同
k，整数，top-k 的 k 值
largest，布尔值，控制返回最大值或最小值
sorted，布尔值，控制返回元素是否排序

函数说明：
（1）函数返回张量沿指定维度 dim 的所有元素的最大值或最小值。
（2）参数 dim 缺省时，函数默认对张量的所有元素进行计算，返回 0 维张量。参数 dim 为整数或整型元组时，按照 dim 指定维度的所有元素进行计算，返回值是带有 2 个 key（ values, indices）的字典。
（3）函数 torch.topk 的返回值是带有 2 个 key（ values, indices）的字典。
（4）对于具有偶数个元素的输入张量，中值不是唯一的，函数 torch.median 返回两个中值中较小的一个。

# (11) 张量的统计分析运算: 最大值与最大值索引
# 张量最大值
x = torch.arange(1.0, 16.0).reshape(3, 5)  # torch.Size([3, 5])
max1 = torch.max(x)  # 张量所有元素求最大值
print("max(x):", max1)  # torch.Size([])
# max(x): tensor(15.)
max2 = torch.max(x, dim=0)  # 按指定dim求最大值
print(max2)  # 返回值是字典, 有两个key: values和indices
# torch.return_types.max(
# values=tensor([11., 12., 13., 14., 15.]),
# indices=tensor([2, 2, 2, 2, 2]))
print(max2.values)  # torch.Size([5])
# tensor([11., 12., 13., 14., 15.])
print(max2.indices)  # torch.Size([5])
# tensor([2, 2, 2, 2, 2])# 两个张量的最大值
a = torch.tensor((1, 2, -1))
b = torch.tensor((3, 0, 6))
print(torch.max(a, b))  # tensor([3, 2, 6])
print(torch.maximum(a, b))  # tensor([3, 2, 6])# 张量的最大值索引
x = torch.arange(1.0, 16.0).reshape(3, 5)  # torch.Size([3, 5])
arg1 = torch.argmax(x)  # 张量所有元素求最大值索引
print("argmax(x):", arg1)  # torch.Size([])
# argmax(x): tensor(14)
arg2 = torch.argmax(x, dim=0)  # 按指定dim求最大值
print("argmax(x,0):", arg2)  # torch.Size([5])
# argmax(x,0): tensor([2, 2, 2, 2, 2])
arg3 = torch.argmax(x, dim=1)  # 按指定dim求最大值
print("argmax(x,1):", arg3)  # torch.Size([3])
# argmax(x,1): tensor([4, 4, 4])# 返回 k 个最大值
x = torch.arange(1.0, 10.0)  # torch.Size([3, 5])
x_topk = torch.topk(x, k=2)  # 返回值是字典, 有两个key: values和indices
print(x_topk)
# torch.return_types.topk(
# values=tensor([9., 8.]),
# indices=tensor([8, 7]))
print(x_topk.values)  # tensor([9., 8.])
print(x_topk.indices)  # tensor([8, 7])

3.3 累积乘与累积和

函数原型：

torch.cumprod(input, dim, *, dtype=None, out=None) → Tensor # 张量的累积乘
torch.cumsum(input, dim, *, dtype=None, out=None) → Tensor # 张量的累积和

张量累积乘/累积和函数，返回维度dim中输入元素的累积乘积/累积和。如果输入是大小为N的向量，则结果也将是大小为N的向量，其中包含元素。

# (12) 张量的统计分析运算: 累积乘与累积和
x = torch.arange(1.0, 6.0)
x_cumprod = torch.cumprod(x, dim=0)
x_cumsum = torch.cumsum(x, dim=0)
print("x_cumprod:", x_cumprod)
# x_cumprod: tensor([  1.,   2.,   6.,  24., 120.])
print("x_cumsum:", x_cumsum)
# x_cumsum: tensor([ 1.,  3.,  6., 10., 15.])

4. 张量的比较操作

张量的比较操作，是指对多个张量进行比较运算的方法。

函数原型：

torch.equal(input, other) → bool # 比较两个张量是否相等
torch.eq(input, other, *, out=None) → Tensor # 比较两个张量的元素是否相同
torch.ne(input, other, *, out=None) → Tensor # 比较两个张量的元素是否相同
torch.gt(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足大于关系
torch.ge(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足大于等于关系
torch.lt(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足小于关系
torch.le(input, other, *, out=None) → Tensor # 比较两个张量的元素是否满足小于等于关系
torch.isnan(input) → Tensor # 检查张量的元素是否为NaN
torch.sort(input, dim=-1, descending=False, stable=False, *, out=None) # 对张量的元素按升序排列

参数说明：

input，张量，输入张量。
other，张量或浮点数，第二个输入张量。
out，张量，输出张量，布尔类型。

函数说明：
（1）函数 torch.equal 比较两个张量是否相等，结果是一个布尔值。函数 torch.eq 比较两个张量的逐个元素，结果是一个布尔型张量。
（2）函数 torch.gt、torch.ge、torch.lt、torch.le 逐个元素比较张量 input 与 other 的大小，结果是一个布尔型张量。
（3）函数 torch.sort 将输入张量的元素沿给定维度按值升序排列，返回值是带有 2 个 key（ values, indices）的字典。

# (13) 张量的比较操作
x = torch.tensor([[1,2,3],[4,5,6]])
y = torch.tensor([[1,2,3],[4,5,6]])
z = torch.tensor([[0,2,3],[0,5,6]])# 比较两个张量是否相等
x_equal_y = torch.equal(x, y)
x_equal_z = torch.equal(x, z)
print("x equal y:", x_equal_y)  # x equal y: True
print("x equal z:", x_equal_z)  # x equal z: False# 比较两个张量的逐个元素是否相等
x_eq_y = torch.eq(x, y)
x_eq_z = torch.eq(x, z)
print("x eq y:", x_eq_y)
# x eq y: tensor([[True, True, True], [True, True, True]])
print("x eq z:", x_eq_z)
# x eq z: tensor([[False, True, True], [False, True, True]])# 检查张量元素的性质
x = torch.tensor([1, float('nan'), 2])
print("isnan(x):", torch.isnan(x))  # 检查是否为 NaN
# isnan(x): tensor([False,  True, False])
print("isfinite(x):", torch.isfinite(x))  # 检查是否为有界数值
# isfinite(x): tensor([ True, False,  True])
print("isinf(x):", torch.isinf(x))  # 检查是否为无界数值
# isinf(x): tensor([False, False, False])# 对张量的元素排序
x = torch.tensor([[1, 4, 7], [3, 0, 6]])
print(x)
print(torch.sort(x))
# torch.return_types.sort(
# values=tensor([[1, 4, 7], [0, 3, 6]]),
# indices=tensor([[0, 1, 2], [1, 0, 2]]))
print(torch.sort(x, dim=0))  #
# torch.return_types.sort(
# values=tensor([[1, 0, 6], [3, 4, 7]]),
# indices=tensor([[0, 1, 1], [1, 0, 0]]))
print(torch.sort(x, dim=1))  #
# torch.return_types.sort(
# values=tensor([[1, 4, 7], [0, 3, 6]]),
# indices=tensor([[0, 1, 2], [1, 0, 2]]))

5. 张量的线性代数运算

BLAS（Basic Linear Algeria Subprograms）和 LAPACK（Linear Algeria Package）模块提供了完整的线性代数基本方法，包括：

矩阵的形变及特殊矩阵的构造方法：包括矩阵的转置、对角矩阵的创建、单位矩阵的创建、上/下三角矩阵的创建等；
矩阵的基本运算：包括矩阵乘法、向量内积、矩阵和向量的乘法等，当然，此处还包含了高维张量的基本运算，将着重探讨矩阵的基本方法
运算拓展至三维张量中的基本方法；
矩阵的线性代数运算：包括矩阵的迹、矩阵的秩、逆矩阵的求解、伴随矩阵和广义逆矩阵等；
矩阵分解运算：特征分解、奇异值分解和SVD分解等。

版权声明：
欢迎关注『youcans的深度学习』系列，转发请注明原文链接：
【youcans的深度学习 10】PyTorch入门教程：张量的统计运算(https://youcans.blog.csdn.net/article/details/130745989）
Copyright 2023 youcans, XUPT
Crated：2023-05-18