文章目录
前言
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]])