Bootstrap

【PyTorch入门】 常用统计函数【二】

#PyTorch统计函数

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

torch.prod()用于计算张量 a 中所有元素的乘积。返回一个张量，表示输入张量所有元素的累积乘积。如果输入是一个多维张量，则默认计算所有元素的乘积。

  • input: 输入张量。
  • dim: 可选参数，用于指定沿哪个维度计算乘积。如果没有指定（默认值为 None），则会对所有元素计算乘积。
  • keepdim: 可选参数，是否保持原来的维度。如果为 True，则结果张量的维度和原张量相同，否则会去除指定维度。
  • dtype: 可选参数，指定输出数据类型。如果没有指定，会自动推断。
import torch

a = torch.tensor([1, 2, 3, 4])
result = torch.prod(a)
print(result)

tensor(24)

2.torch.rand(*size, dtype=None, layout=torch.strided, device=None, requires_grad=False)

用来生成一个由均匀分布的随机数构成的张量函数。它生成的张量中的每个元素都遵循 𝑈(0,1) 均匀分布，即每个数值都在 0 和 1 之间，包含 0，但不包含 1。

  • size: 输出张量的形状，表示张量的维度。可以传入一个或多个整数，指定返回张量的形状。
  • dtype: 可选参数，指定输出张量的数据类型。如果没有指定，默认为 float32。
  • layout: 可选参数，默认为 torch.strided，决定张量存储的布局。
  • device: 可选参数，指定张量要存放的设备（如 CPU 或 GPU）。如果没有指定，默认为 CPU。
  • requires_grad: 可选参数，是否需要计算梯度，默认为 False。
import torch

# 生成一个形状为 (5,) 的随机张量
tensor = torch.rand(5)
print(tensor)

tensor([0.9516, 0.0753, 0.8860, 0.5832, 0.3376])

这个张量包含 5 个随机数，范围在 [0, 1) 之间，且符合均匀分布。

如果希望生成张量并将其直接存储在 GPU 上，可以通过 device 参数指定：

# 生成一个形状为 (2, 2) 的随机张量，并存储在 GPU 上
tensor = torch.rand(2, 2, device='cuda')
print(tensor)
  1. torch.sum(input, dim=None, keepdim=False, dtype=None)
    用于计算输入张量所有元素的和，或者沿指定的维度计算元素的和。
  • input: 输入的张量。
  • dim: 可选参数，指定沿哪个维度计算和。如果没有指定（默认值为 None），则计算所有元素的和。
  • keepdim: 可选参数，指定是否保持原来张量的维度。如果 True，则返回的张量会保持原维度，结果会变成一个与输入张量形状相同的张量，只是某些维度会变成 1。如果 False（默认值），则会去除指定的维度。
  • dtype: 可选参数，指定输出张量的数据类型。如果没有指定，输出会使用 input 张量的类型。
import torch

# 生成一个一维张量
a = torch.tensor([1, 2, 3, 4])

# 计算所有元素的和
result = torch.sum(a)
print(result)

tensor(10)

计算沿着某个维度的和。

a = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 沿着第0维（行）计算和
sum_dim0 = torch.sum(a, dim=0)
print(sum_dim0)

tensor([5, 7, 9])

沿着第0维（行）计算和，得到的结果是每列的和：

  • 第一列的和：1 + 4 = 5
  • 第二列的和：2 + 5 = 7
  • 第三列的和：3 + 6 = 9

沿着第1维（列）计算和

# 沿着第1维（列）计算和
sum_dim1 = torch.sum(a, dim=1)
print(sum_dim1)

tensor([6, 15])

沿着第1维（列）计算和，得到的结果是每行的和：

  • 第一行的和：1 + 2 + 3 = 6
  • 第二行的和：4 + 5 + 6 = 15
  1. torch.mean(input, dim=None, keepdim=False, dtype=None)
    用于计算张量的均值。它可以计算整个张量的均值，或者沿着指定的维度计算均值。
  • input: 输入张量。
  • dim: 可选参数，指定沿哪个维度计算均值。如果没有指定（默认值为 None），则计算整个张量的均值。
  • keepdim: 可选参数，指定是否保持原来张量的维度。如果 True，则返回的张量会保持原维度，结果会变成一个与输入张量形状相同的张量，只是某些维度会变成 1。如果 False（默认值），则会去除指定的维度。
  • dtype: 可选参数，指定输出张量的数据类型。如果没有指定，输出会使用 input 张量的类型。
import torch

# 生成一个一维张量
a = torch.tensor([1, 2, 3, 4])

# 计算所有元素的均值
result = torch.mean(a.float())  # 需要将整型张量转换为浮点型
print(result)

tensor(2.5000)
  1. torch.max(input, dim=None, keepdim=False, out=None)

用于计算张量的最大值。它有两种常用的用法：

  • 计算张量的最大值：返回张量中所有元素的最大值。
  • 沿指定维度计算最大值：可以指定维度，并返回该维度上每个元素的最大值。

参数：

  • input: 输入张量。
  • dim: 可选参数，指定沿哪个维度计算最大值。如果没有指定（默认值为 None），则返回张量中所有元素的最大值。
  • keepdim: 可选参数，是否保持原来的维度。如果 True，则返回的张量会保持原维度，某些维度的大小会变成 1。如果 False（默认值），则会去除指定的维度。
  • out: 可选参数，用于存放结果的输出张量。
import torch

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

# 计算张量中所有元素的最大值
result = torch.max(a)
print(result)

tensor(4)

a = torch.tensor([[1, 5, 3], [4, 2, 6]])

# 沿着第0维（行）计算最大值
max_dim0 = torch.max(a, dim=0)
print(max_dim0)

torch.return_types.max(
values=tensor([4, 5, 6]),
indices=tensor([1, 0, 1]))

沿着第0维（行）计算最大值，得到的结果是每列的最大值：

  • 第一列的最大值是 4。
  • 第二列的最大值是 5。
  • 第三列的最大值是 6。

返回的是一个包含两个元素的命名元组：

  • values: 每列的最大值。
  • indices: 每列最大值的位置索引。

  1. torch.min(input, dim=None, keepdim=False, out=None, dtype=None)
    计算张量最小值的函数。它不仅可以返回张量的最小值，还能支持沿指定维度计算最小值，并返回最小值所在的索引。

  2. torch.median(input, dim=None, keepdim=False, out=None, dtype=None)
    用于计算张量的中位数的函数。中位数是统计学中一种常见的集中趋势的衡量方式，表示数据中间位置的值。对于一个有序的数据集，如果数据的数量是奇数，则中位数是排序后中间的值；如果是偶数，则中位数是排序后中间两个值的平均。

参数解释：

  • input: 输入张量。
  • dim: 可选参数，指定沿哪个维度计算中位数。如果为 None（默认值），则返回整个张量的中位数。
  • keepdim: 可选参数，是否保持原维度。如果为 True，则返回的张量会保持原维度，某些维度的大小会变成 1。如果为 False（默认值），则去除指定维度。
  • out: 可选参数，指定输出的张量。
  • dtype: 可选参数，指定输出数据的类型。如果没有指定，则使用输入张量的数据类型。

返回值：

  • 如果没有指定 dim 参数，返回张量的中位数。
  • 如果指定了 dim 参数，返回中位数及其对应的索引。
a = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

# 沿着第0维（列）计算中位数
median_dim0 = torch.median(a, dim=0)
print(median_dim0)

torch.return_types.median(
values=tensor([2.5000, 3.5000, 4.5000]),
indices=tensor([0, 0, 0]))

结果包含两个张量：values（中位数）和 indices（中位数的索引）。

  1. torch.mode(input, dim=None, keepdim=False, out=None)

用于计算给定张量沿指定维度的众数（即出现次数最多的元素）。它会返回一个包含两个元素的命名元组：
values：每个维度上出现次数最多的值。
indices：每个维度上最大出现次数对应的值的索引。

计算二维张量的众数

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

# 沿着第0维（列）计算众数
mode_dim0 = torch.mode(a, dim=0)
print(mode_dim0)

torch.return_types.mode(
values=tensor([3, 2, 3]),
indices=tensor([1, 0, 0])
)

沿着第0维（列）计算众数：
第一列 [1, 3] 中，众数是 3，索引为 1。
第二列 [2, 2] 中，众数是 2，索引为 0。
第三列 [3, 1] 中，众数是 3，索引为 0。
返回的是一个命名元组：

values: 每列的众数 [3, 2, 3]。
indices: 每列众数的位置索引 [1, 0, 0]。

保持维度

# 沿着第0维（列）计算众数，并保持维度
mode_dim0_keepdim = torch.mode(a, dim=0, keepdim=True)
print(mode_dim0_keepdim)

torch.return_types.mode(
values=tensor([[3, 2, 3]]),
indices=tensor([[1, 0, 0]])
)

keepdim=True会保持原来的维度，返回的张量变成了形状 (1, 3)，而不是一维的众数。

  1. torch.var(input, dim=None, unbiased=True, keepdim=False, out=None, dtype=None)
    用来计算张量的方差的函数。方差是衡量数据分散程度的指标，表示每个数据点与均值之间的平方差的平均值。对于一维张量，方差可以反映这个张量中的数值分布的离散程度；对于多维张量，方差可以按特定维度计算。

参数解释：

  • input: 输入张量。
  • dim: 可选参数，指定沿哪个维度计算方差。如果没有指定（默认 None），则计算整个张量的方差。
  • unbiased: 默认为 True，表示计算无偏方差（使用 N-1 作为分母）。如果设为 False，则计算有偏方差（使用 N 作为分母）。在样本方差估计时，通常选择无偏方差。
  • keepdim: 可选参数，是否保持原维度。如果为 True，则返回的张量会保持原维度，某些维度的大小会变成 1。如果为 False（默认值），则会去除指定的维度。
  • out: 可选参数，指定输出的张量。
  • dtype: 可选参数，指定输出数据的类型。如果没有指定，则使用输入张量的数据类型。
a = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

# 沿着第0维（列）计算方差
var_dim0 = torch.var(a, dim=0)
print(var_dim0)

tensor([4.5000, 4.5000, 4.5000])

沿着第0维（列）计算方差，即计算每列的方差：
第一列 [1.0, 4.0] 的方差是 4.5。
第二列 [2.0, 5.0] 的方差是 4.5。
第三列 [3.0, 6.0] 的方差是 4.5。

无偏方差与有偏方差的区别

# 计算无偏方差（默认为 True）
unbiased_var = torch.var(a, unbiased=True)
print(unbiased_var)

# 计算有偏方差
biased_var = torch.var(a, unbiased=False)
print(biased_var)

tensor(1.2500)  # 无偏方差
tensor(1.0000)  # 有偏方差
  • 无偏方差使用 N-1 作为分母，而有偏方差使用 N 作为分母。
    对于上面的例子，样本方差是 1.25，如果使用有偏方差，则结果会更小，变为 1.0。
  1. torch.std(input, dim=None, unbiased=True, keepdim=False, out=None, dtype=None)
    用于计算张量的标准差。标准差是衡量数据集分散程度的一个常用指标，表示数据点与均值之间的平均差异。标准差是方差的平方根，它反映了数据的波动程度。

参数解释：

  • input: 输入张量。
  • dim: 可选参数，指定沿哪个维度计算标准差。如果没有指定（默认为 None），则计算整个张量的标准差。
  • unbiased: 默认为 True，表示计算无偏标准差（使用 N-1 作为分母）。如果设为 False，则计算有偏标准差（使用 N 作为分母）。通常用于样本方差估计时选择无偏标准差。
  • keepdim: 可选参数，是否保持原维度。如果为 True，则返回的张量会保持原维度，某些维度的大小会变成 1。如果为 False（默认值），则去除指定维度。
  • out: 可选参数，指定输出的张量。
  • dtype: 可选参数，指定输出数据的类型。如果没有指定，则使用输入张量的数据类型。
a = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

# 沿着第0维（列）计算标准差
std_dim0 = torch.std(a, dim=0)
print(std_dim0)

tensor([4.5000, 4.5000, 4.5000])

沿着第0维（列）计算标准差，即计算每列的标准差：
第一列 [1.0, 4.0] 的标准差是 4.5。
第二列 [2.0, 5.0] 的标准差是 4.5。
第三列 [3.0, 6.0] 的标准差是 4.5。

无偏标准差与有偏标准差的区别

# 计算无偏标准差（默认为 True）
unbiased_std = torch.std(a, unbiased=True)
print(unbiased_std)

# 计算有偏标准差
biased_std = torch.std(a, unbiased=False)
print(biased_std)

tensor(1.1180)  # 无偏标准差
tensor(1.0000)  # 有偏标准差

无偏标准差使用 N−1 作为分母，而有偏标准差使用 N 作为分母。
对于上面的例子，样本标准差是 1.1180，如果使用有偏标准差，则结果会变为 1.0000。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
MySQL 视图（VIEW）的使用
MBD软件开发之结构体变量建模
醒醒，别睡了...讲《数据分析pandas库》了—/—＜1＞
代码随想录第25天 ● 216.组合总和III● 17.电话号码的字母组合 原创
vue项目中引入lodash、js-base64、md5加密、echarts、jQuery、 js-cookie、elementUI库、less、axios和qs
增值税电子发票的对接系统的设计
【源码+指导】Java校园二手交易平台-计算机毕业设计
转：二叉树的深度优先遍历和广度优先遍历
ROS学习记录（一）全局规划器Plugin插件
Windows安装OpenCV——利用MinGW+CMake从源码编译
;