Pytorch-Reduction Ops

文章目录


前言


1.torch.argmax()

torch.argmax() 是 PyTorch 中的一个函数,用于在指定维度上获取张量中最大值的索引。

python 复制代码
torch.argmax(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,
		则默认在最后一个维度上进行操作。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。
		默认为 False,表示不保持维度
"""
python 复制代码
import torch

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

# 沿着第一个维度获取最大值的索引
max_indices = torch.argmax(x, dim=0)
print(max_indices)  # 输出: tensor([1, 1, 1])

2.torch.argmin()

torch.argmin() 是 PyTorch 中的一个函数,用于在指定维度上获取张量中最小值的索引。

python 复制代码
torch.argmin(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在最后一个维度上进行操作。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
"""
python 复制代码
import torch

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

# 沿着第一个维度获取最小值的索引
min_indices = torch.argmin(x, dim=0)
print(min_indices)  # 输出: tensor([0, 0, 0])

3.torch.amax()

在 PyTorch 中,torch.amax() 函数用于计算张量的最大值。

python 复制代码
torch.amax(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在所有维度上进行操作,返回张量的全局最大值。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
"""
python 复制代码
import torch

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

# 计算全局最大值
global_max = torch.amax(x)
print(global_max)  # 输出: tensor(6)

# 沿着第一个维度计算最大值
max_values = torch.amax(x, dim=0)
print(max_values)  # 输出: tensor([4, 5, 6])
python 复制代码
import torch

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

# 计算全局最大值
global_max = torch.amax(x)
print(global_max)  # 输出: tensor(6)

# 沿着第一个维度计算最大值
max_values = torch.amax(x, dim=0)
print(max_values)  # 输出: tensor([4, 5, 6])

4.torch.amin()

在 PyTorch 中,torch.amin() 函数用于计算张量的最小值。

python 复制代码
torch.amin(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在所有维度上进行操作,返回张量的全局最小值。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
"""
python 复制代码
import torch

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

# 计算全局最小值
global_min = torch.amin(x)
print(global_min)  # 输出: tensor(1)

# 沿着第一个维度计算最小值
min_values = torch.amin(x, dim=0)
print(min_values)  # 输出: tensor([3, 1, 2])

5.torch.all()

torch.all() 是 PyTorch 中的一个函数,用于检查张量中的所有元素是否都满足某个条件。

python 复制代码
torch.all(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在所有元素上进行操作,返回一个标量布尔值。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
"""
python 复制代码
import torch

# 创建一个张量
x = torch.tensor([[True, True], [False, True]])

# 检查全局是否所有元素都为 True
global_all = torch.all(x)
print(global_all)  # 输出: tensor(False)

# 沿着第一个维度检查是否所有元素都为 True
dim_all = torch.all(x, dim=0)
print(dim_all)  # 输出: tensor([False, True])

6.torch.any()

torch.any() 是 PyTorch 中的一个函数,用于检查张量中的任意元素是否满足某个条件。

python 复制代码
torch.any(input, dim=None, keepdim=False)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在所有元素上进行操作,返回一个标量布尔值。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
"""
python 复制代码
import torch

# 创建一个张量
x = torch.tensor([[True, True], [False, True]])

# 检查全局是否存在任意一个元素为 True
global_any = torch.any(x)
print(global_any)  # 输出: tensor(True)

# 沿着第一个维度检查是否存在任意一个元素为 True
dim_any = torch.any(x, dim=0)
print(dim_any)  # 输出: tensor([ True,  True])

7.torch.max()

torch.max() 是 PyTorch 中的一个函数,用于计算张量中的最大值。

python 复制代码
torch.max(input, dim=None, keepdim=False, out=None)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行操作。如果未指定,则默认在所有元素上进行操作,返回一个标量张量。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
out:可选参数,指定输出张量作为结果的存储位置。
"""
python 复制代码
import torch

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

# 计算全局最大值
global_max = torch.max(x)
print(global_max)  # 输出: tensor(6)

# 沿着第一维度计算最大值和对应的索引
max_values, max_indices = torch.max(x, dim=0)
print(max_values)  # 输出: tensor([4, 5, 6])
print(max_indices)  # 输出: tensor([1, 1, 1])
python 复制代码
import torch

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

# 沿着第一维度计算最大值和对应的索引
max_values, max_indices = torch.max(x, dim=1)
print(max_values)  # 输出: tensor([3, 6])
print(max_indices)  # 输出: tensor([2, 2])

8.torch.dist()

torch.dist() 是 PyTorch 中的一个函数,用于计算两个张量之间的距离。

python 复制代码
torch.dist(input, other, p=2)
"""
input:第一个输入张量。
other:第二个输入张量。
p:可选参数,表示要使用的距离度量。默认为 2,表示欧氏距离。
"""
python 复制代码
import torch

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

# 计算欧氏距离
distance = torch.dist(x, y)
print(distance)  # 输出: tensor(5.1962)

9.torch.logsumexp()

torch.logsumexp() 是 PyTorch 中的一个函数,用于计算张量的对数求和指数。

python 复制代码
torch.logsumexp(x, dim) = log(sum(exp(x), dim))
python 复制代码
torch.logsumexp(input, dim, keepdim=False, out=None)
"""
input:输入张量。
dim:指定在哪个维度上进行操作。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
out:可选参数,指定输出张量作为结果的存储位置。
"""
python 复制代码
import torch

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

# 计算对数求和指数
result = torch.logsumexp(x, dim=0)
print(result)  # 输出: tensor(4.4402)

10.torch.mean()

torch.mean() 是 PyTorch 中的一个函数,用于计算张量的平均值。

python 复制代码
torch.mean(input, dim=None, keepdim=False, out=None)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行平均值计算。如果未指定,则默认在所有元素上进行计算,返回一个标量张量。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
out:可选参数,指定输出张量作为结果的存储位置。
"""
python 复制代码
import torch

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

# 计算全局平均值
global_mean = torch.mean(x)
print(global_mean)  # 输出: tensor(3.5000)

# 沿着第一维度计算平均值
mean_values = torch.mean(x, dim=0)
print(mean_values)  # 输出: tensor([2.5000, 3.5000, 4.5000])

11.torch.norm()

torch.norm() 是 PyTorch 中的一个函数,用于计算张量的范数(norm)。

python 复制代码
torch.norm(input, p='fro', dim=None, keepdim=False, out=None)
"""
input:输入张量。
p:可选参数,表示要计算的范数类型。默认为 'fro',表示计算 Frobenius 范数。还可以指定其他值,如 1 表示计算 L1 范数,2 表示计算 L2 范数等。
dim:可选参数,指定在哪个维度上进行范数计算。如果未指定,则默认在所有元素上进行计算,返回一个标量张量。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
out:可选参数,指定输出张量作为结果的存储位置。
"""
python 复制代码
import torch

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

# 计算 Frobenius 范数
frobenius_norm = torch.norm(x)
print(frobenius_norm)  # 输出: tensor(5.4772)

# 计算 L1 范数
l1_norm = torch.norm(x, p=1)
print(l1_norm)  # 输出: tensor(10.)

# 计算 L2 范数
l2_norm = torch.norm(x, p=2)
print(l2_norm)  # 输出: tensor(5.4772)

# 沿着第一维度计算范数
norm_values = torch.norm(x, dim=0)
print(norm_values)  # 输出: tensor([3.1623, 4.4721])

12.torch.nansum()

torch.nansum() 是 PyTorch 中的一个函数,用于计算张量中忽略 NaN(Not a Number)值的元素之和。

python 复制代码
torch.nansum(input, dim=None, keepdim=False, dtype=None, out=None)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行求和。如果未指定,则默认在所有元素上进行求和,返回一个标量张量。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
dtype:可选参数,指定输出张量的数据类型。如果未指定,则默认使用输入张量的数据类型。
out:可选参数,指定输出张量作为结果的存储位置。
"""
python 复制代码
import torch

# 创建一个包含 NaN 值的张量
x = torch.tensor([[1, float('nan'), 3], [4, 5, float('nan')]])

# 沿着第一维度计算忽略 NaN 值后的求和
sum_values = torch.nansum(x, dim=0)
print(sum_values)  # 输出: tensor([5., 5., 3.])

13.torch.prod()

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

python 复制代码
torch.prod(input, dim=None, keepdim=False, dtype=None)
"""
input:输入张量。
dim:可选参数,指定在哪个维度上进行乘积计算。如果未指定,则默认在所有元素上进行乘积,返回一个标量张量。
keepdim:可选参数,指定是否保持输出张量的维度与输入张量相同。默认为 False,表示不保持维度。
dtype:可选参数,指定输出张量的数据类型。如果未指定,则默认使用输入张量的数据类型。
"""
python 复制代码
import torch

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

# 计算所有元素的乘积
product = torch.prod(x)
print(product)  # 输出: tensor(24)

# 沿着第一维度计算乘积
product_values = torch.prod(x, dim=0)
print(product_values)  # 输出: tensor([3, 8])


# 沿着多个维度同时计算乘积
product_multiple_dims = torch.prod(x, dim=0, keepdim=True)
product_multiple_dims = torch.prod(product_multiple_dims, dim=1, keepdim=True)
print(product_multiple_dims)  # 输出: tensor([[24]])

14.torch.cumsum()

torch.cumsum() 是 PyTorch 中的一个函数,用于计算张量中元素的累积和(逐元素累积求和)。

python 复制代码
torch.cumsum(input, dim, dtype=None)
"""
input:输入张量。
dim:指定在哪个维度上进行累积和计算。
dtype:可选参数,指定输出张量的数据类型。如果未指定,则默认使用输入张量的数据类型。
"""
python 复制代码
import torch

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

# 沿着第一维度计算累积和
cumulative_sum = torch.cumsum(x, dim=0)
print(cumulative_sum)
# 输出:
# tensor([[1, 2, 3],
#         [5, 7, 9]])

# 沿着第二维度计算累积和
cumulative_sum_dim1 = torch.cumsum(x, dim=1)
print(cumulative_sum_dim1)
# 输出:
# tensor([[ 1,  3,  6],
#         [ 4,  9, 15]])

15.torch.cumprod()

torch.cumprod() 是 PyTorch 中的一个函数,用于计算张量中元素的累积乘积(逐元素累积求积)。

python 复制代码
torch.cumprod(input, dim, dtype=None)
"""
input:输入张量。
dim:指定在哪个维度上进行累积乘积计算。
dtype:可选参数,指定输出张量的数据类型。如果未指定,则默认使用输入张量的数据类型
"""
python 复制代码
import torch

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

# 沿着第一维度计算累积乘积
cumulative_product = torch.cumprod(x, dim=0)
print(cumulative_product)
# 输出:
# tensor([[ 1,  2,  3],
#         [ 4, 10, 18]])

# 沿着第二维度计算累积乘积
cumulative_product_dim1 = torch.cumprod(x, dim=1)
print(cumulative_product_dim1)
# 输出:
# tensor([[ 1,  2,  6],
#         [ 4, 20, 120]])
相关推荐
roman_日积跬步-终至千里1 分钟前
【人工智能基础】计算机视觉
人工智能·计算机视觉
敲代码不忘补水2 分钟前
Python Matplotlib 经典 3D 绘图类型:从二维到三维的可视化解析
开发语言·python·3d·数据分析·numpy·pandas·matplotlib
努力的小好16 分钟前
【python】摄像头调用马赛克恶搞
python
AI小杨22 分钟前
【数据分析】一、pandas数据处理指南:100个基于pandas数据预处理方法
python·数据挖掘·数据分析·pandas·pandas使用技巧
weixin_4314708622 分钟前
文本数据分析(nlp)
开发语言·python·深度学习·自然语言处理
終不似少年遊*22 分钟前
数据分析-机器学习-第三方库使用基础
python·机器学习·数据挖掘·数据分析·numpy
天天要nx38 分钟前
D79【 python 接口自动化学习】- python基础之HTTP
python
ystraw_ah1 小时前
python 画图例子
python
Francek Chen1 小时前
【大数据分析&深度学习】在Hadoop上实现分布式深度学习
人工智能·hadoop·分布式·深度学习·数据分析
明朝百晓生1 小时前
【PyTorch][chapter 228][李宏毅深度学习][Diffusion Model-1]
人工智能