PyTorch学习笔记之基础函数篇（九）

统计运算

5.1 torch.mean()函数

torch.mean() 是 PyTorch 中的一个函数，用于计算张量（Tensor）的平均值。你可以用它来计算一个张量所有元素的平均值，或者指定某个维度上的平均值。

torch.mean() 函数在 PyTorch 中的签名如下：

torch.mean(input, dim=None, keepdim=False, dtype=None) → Tensor

参数解释：

• input (Tensor): 要计算平均值的输入张量。
• dim (int, optional): 要计算平均值的维度。如果未指定，则计算所有元素的平均值并返回一个标量。
• keepdim (bool, optional): 是否保持维度。如果设置为 True，则结果张量将具有与输入张量相同的维度，除了被规约的维度外，其他维度的大小为 1。默认为 False。
• dtype (torch.dtype, optional): 返回张量的数据类型。如果未指定，则使用输入张量的数据类型。

返回值：

• Tensor: 计算平均值后的张量。如果 dim 未指定，则返回一个标量。

基本用法

计算张量中所有元素的平均值：

import torch

x = torch.tensor([1.0, 2.0, 3.0])
mean = torch.mean(x)
print(mean)  # 输出：2.0

指定维度

你可以通过 dim 参数来指定在哪个维度上计算平均值。例如，对于一个二维张量（通常可以看作是一个矩阵），你可以计算每一列或每一行的平均值。

x = torch.tensor([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0]])

# 计算每一列的平均值
col_mean = torch.mean(x, dim=0)
print(col_mean)  # 输出：tensor([2.5000, 3.5000, 4.5000])

# 计算每一行的平均值
row_mean = torch.mean(x, dim=1)
print(row_mean)  # 输出：tensor([2., 5.])

保持维度

默认情况下，torch.mean() 函数会返回一个一维张量作为结果。如果你希望结果保持原始张量的维度，可以使用 keepdim 参数：

x = torch.tensor([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0]])

# 计算每一列的平均值，并保持维度
col_mean_keepdim = torch.mean(x, dim=0, keepdim=True)
print(col_mean_keepdim)  # 输出：tensor([[2.5000, 3.5000, 4.5000]])

注意事项

如果张量包含非数值类型（如字符串或布尔值），torch.mean() 会抛出错误。
当指定了 dim 参数时，返回的张量的大小将在指定的维度上减少一个维度。
torch.mean() 默认会计算所有元素的平均值，不包括任何可能的 NaN 或 inf 值。

这个函数在数据预处理、统计分析以及神经网络训练过程中计算损失等场景中非常有用。

5.2 torch.median()函数

torch.median() 是 PyTorch 中的一个函数，用于计算张量（Tensor）的中位数。和 torch.mean() 类似，torch.median() 也支持指定维度来计算中位数。

torch.median() 函数在 PyTorch 中的签名如下：

torch.median(input, dim=None, keepdim=False) → (Tensor, LongTensor)

参数解释：

• input (Tensor): 输入张量，其中包含了需要计算中位数的数据。
• dim (int, optional): 沿着哪个维度计算中位数。如果不指定，则在整个张量上计算并返回一个标量。默认为 None。
• keepdim (bool, optional): 是否保持维度。如果设置为 True，则输出张量将具有与输入张量相同的维度，除了被规约的维度外，其他维度的大小为 1。默认为 False。

返回值：

• (Tensor, LongTensor): 一个包含两个张量的元组。第一个张量是中位数，第二个张量是中位数的索引。

下面是一个使用 torch.median() 函数的例子：

import torch

# 创建一个一维张量
x = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])

# 计算整个张量的中位数
median_value, median_indices = torch.median(x)
print(median_value)  # 输出：3.0
print(median_indices)  # 输出：tensor(2)

# 创建一个二维张量
x = torch.tensor([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0]])

# 计算每一列的中位数
medians_column, indices_column = torch.median(x, dim=0)
print(medians_column)  # 输出：tensor([2.5000, 3.5000, 4.5000])
print(indices_column)  # 输出：tensor([0, 0, 0])

# 计算每一行的中位数
medians_row, indices_row = torch.median(x, dim=1, keepdim=True)
print(medians_row)  # 输出：tensor([[2.],
                    #               [5.]])
print(indices_row)  # 输出：tensor([[1],
                    #               [1]])

基本用法

计算张量中所有元素的中位数：

import torch

x = torch.tensor([1.0, 2.0, 3.0, 4.0])
median = torch.median(x)
print(median)  # 输出：2.5

如果张量中有偶数个元素，torch.median() 会返回中间两个数的平均值作为中位数。

指定维度

你可以通过 dim 参数来指定在哪个维度上计算中位数。例如，对于一个二维张量，你可以计算每一列或每一行的中位数。

x = torch.tensor([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0]])

# 计算每一列的中位数
col_median = torch.median(x, dim=0)
print(col_median)  # 输出：tensor([2.5000, 3.5000, 4.5000])

# 计算每一行的中位数
row_median = torch.median(x, dim=1)
print(row_median)  # 输出：tensor([2., 5.])

保持维度

和 torch.mean() 一样，torch.median() 也支持 keepdim 参数来保持结果的维度：

x = torch.tensor([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0]])

# 计算每一列的中位数，并保持维度
col_median_keepdim = torch.median(x, dim=0, keepdim=True)
print(col_median_keepdim)  # 输出：tensor([[2.5000],
                           #               [3.5000],
                           #               [4.5000]])

返回值

torch.median() 返回两个张量：中位数和对应的中位数索引。如果你只需要中位数，可以忽略索引。

median_value, median_indices = torch.median(x, dim=0)
print(median_value)  # 输出：tensor([2.5000, 3.5000, 4.5000])
print(median_indices)  # 输出：tensor([0, 0, 0])

在这个例子中，median_indices 是每一列中位数的索引，因为所有列的中位数都是第一个元素（索引为0）。
注意事项

torch.median() 不支持直接处理非数值类型（如字符串或布尔值）的张量。
如果张量中包含 NaN 或 inf 值，torch.median() 的行为可能会受到这些值的影响，具体取决于你的 PyTorch 版本和配置。

这个函数在数据分析、信号处理以及机器学习中处理分布不均匀的数据时非常有用。

5.3 torch.sum()函数

torch.sum() 是 PyTorch 中的一个函数，用于计算张量（tensor）中元素的和。它可以沿着指定的维度进行求和，也可以计算所有元素的和。

torch.sum() 函数的签名在 PyTorch 中是这样的：

torch.sum(input, dim=None, dtype=None, keepdim=False)

参数说明：

• input (Tensor): 需要计算和的输入张量。
• dim (int, optional): 要沿着哪个维度进行求和。如果为 None，则计算所有元素的和。
• dtype (torch.dtype, optional): 返回张量的所需数据类型。如果指定，则输入张量会被转换为该数据类型后再求和。
• keepdim (bool, optional): 如果为 True，则输出张量保持与输入张量相同的维度数，但在求和的维度上大小为 1。如果为 False，则输出张量减少一个维度。

返回值：

• Tensor: 一个新的张量，其元素是 input 张量按照指定维度求和的结果。

下面是一个使用 torch.sum() 函数签名的简单例子：

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2], [3, 4]])

# 计算张量中所有元素的和
total_sum = torch.sum(x)
print(total_sum)  # 输出：10

# 计算每一列的和
col_sums = torch.sum(x, dim=0)
print(col_sums)  # 输出：tensor([4, 6])

# 计算每一行的和
row_sums = torch.sum(x, dim=1)
print(row_sums)  # 输出：tensor([3, 7])

# 指定数据类型和保持维度
sum_with_dtype_keepdim = torch.sum(x, dim=1, dtype=torch.float64, keepdim=True)
print(sum_with_dtype_keepdim)  # 输出：tensor([[3.], [7.]], dtype=torch.float64)

在这个例子中，torch.sum() 被用来计算张量 x 中所有元素的和（dim=None），每一列的和（dim=0），以及每一行的和（dim=1）。通过指定 dtype 参数，可以控制输出张量的数据类型。通过指定 keepdim 参数，可以控制输出张量的维度是否保持不变。

5.4 torch.prod()函数

torch.prod() 是 PyTorch 中的一个函数，用于计算张量中所有元素的乘积12。

当我们将一个张量传递给 torch.prod() 时，它会返回该张量中所有元素的乘积。如果输入张量中有多个维度，我们可以指定 dim 参数来计算特定维度上元素的乘积。

基本用法：

import torch

# 创建一个张量
x = torch.tensor([[1, 2], [3, 4]])

# 计算张量中所有元素的乘积
prod_all = torch.prod(x)
print(prod_all)  # 输出：24

参数：

• input (Tensor)：需要计算乘积的输入张量。
• dim (int, optional)：要沿着哪个维度计算乘积。如果不指定，则默认计算所有元素的乘积。
• keepdim (bool, optional)：如果设置为 True，则输出的张量将保持与输入张量相同的维度数，但在计算的维度上大小为1。如果为 False，则输出的张量将减少一个维度。

例子：

x = torch.tensor([[1, 2], [3, 4]])

# 沿着第一个维度（行）计算乘积
prod_dim0 = torch.prod(x, dim=0)
print(prod_dim0)  # 输出：tensor([3, 8])

# 沿着第二个维度（列）计算乘积
prod_dim1 = torch.prod(x, dim=1)
print(prod_dim1)  # 输出：tensor([2, 12])

# 指定 keepdim=True
prod_dim1_keepdim = torch.prod(x, dim=1, keepdim=True)
print(prod_dim1_keepdim)  # 输出：tensor([[2], [12]])

torch.prod() 在处理多维数据时非常有用，特别是当你需要沿着特定维度聚合数据时。

5.5 torch.std()函数

torch.std() 是 PyTorch 中的一个函数，用于计算张量（tensor）中元素的标准差。这个函数可以沿着指定的维度计算标准差，也可以计算整个张量中所有元素的标准差。
函数签名

torch.std(input, dim=None, unbiased=True, keepdim=False)

参数

• input (Tensor): 需要计算标准差的输入张量。
• dim (int, optional): 要沿着哪个维度计算标准差。如果 dim 是 None，则计算整个张量中所有元素的标准差。
• unbiased (bool, optional): 是否使用无偏估计来计算标准差。默认为 True。如果是 False，则使用有偏估计（即除以 n - 1 而不是 n）。
• keepdim (bool, optional): 如果为 True，则输出张量保持与输入张量相同的维度数，但在计算标准差的维度上大小为 1。如果为 False，则输出张量的维度将减少一个维度（即去掉计算标准差的维度）。

返回值

• Tensor: 一个新的张量，其元素是输入张量 input 按照指定维度 dim 计算的标准差。

例子

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2], [3, 4]])

# 计算整个张量中所有元素的标准差
overall_std = torch.std(x)
print(overall_std)  # 输出: tensor(1.2909944)

# 计算每一列的标准差
col_stds = torch.std(x, dim=0)
print(col_stds)  # 输出: tensor([1., 1.])

# 计算每一行的标准差
row_stds = torch.std(x, dim=1)
print(row_stds)  # 输出: tensor([1., 1.])

# 使用有偏估计计算标准差
biased_std = torch.std(x, unbiased=False)
print(biased_std)  # 输出: tensor(1.1180339)

# 保持维度计算标准差
std_keepdim = torch.std(x, dim=1, keepdim=True)
print(std_keepdim)  # 输出: tensor([[1.], [1.]])

在这个例子中，torch.std() 被用来计算二维张量 x 中所有元素的标准差（dim=None），每一列的标准差（dim=0），以及每一行的标准差（dim=1）。通过设置 unbiased 参数，可以选择使用无偏或有偏的标准差估计。通过设置 keepdim 参数，可以控制输出张量的维度是否保持不变。

5.6 torch.var()函数

torch.var() 是 PyTorch 中的一个函数，用于计算张量（tensor）中元素的方差。这个函数可以沿着指定的维度计算方差，也可以计算整个张量中所有元素的方差。

函数签名

torch.var(input, dim=None, unbiased=True, keepdim=False)

参数:

• input (Tensor): 需要计算方差的输入张量。
• dim (int, optional): 要沿着哪个维度计算方差。如果 dim 是 None，则计算整个张量中所有元素的方差。
• unbiased (bool, optional): 是否使用无偏估计来计算方差。默认为 True。如果是 False，则使用有偏估计（即除以 n 而不是 n - 1）。
• keepdim (bool, optional): 如果为 True，则输出张量保持与输入张量相同的维度数，但在计算方差的维度上大小为 1。如果为 False，则输出张量的维度将减少一个维度（即去掉计算方差的维度）。

返回值

Tensor: 一个新的张量，其元素是输入张量 input 按照指定维度 dim 计算的方差。

例子

import torch

# 创建一个二维张量
x = torch.tensor([[1, 2], [3, 4]])

# 计算整个张量中所有元素的方差
overall_var = torch.var(x)
print(overall_var)  # 输出: tensor(1.25)

# 计算每一列的方差
col_vars = torch.var(x, dim=0)
print(col_vars)  # 输出: tensor([1., 1.])

# 计算每一行的方差
row_vars = torch.var(x, dim=1)
print(row_vars)  # 输出: tensor([0., 0.])

# 使用有偏估计计算方差
biased_var = torch.var(x, unbiased=False)
print(biased_var)  # 输出: tensor(1.1111111)

# 保持维度计算方差
var_keepdim = torch.var(x, dim=1, keepdim=True)
print(var_keepdim)  # 输出: tensor([[0.], [0.]])

在这个例子中，torch.var() 被用来计算二维张量 x 中所有元素的方差（dim=None），每一列的方差（dim=0），以及每一行的方差（dim=1）。通过设置 unbiased 参数，可以选择使用无偏或有偏的方差估计。通过设置 keepdim 参数，可以控制输出张量的维度是否保持不变。