---

前言

---

1.torch.argmax()

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

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

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 中的一个函数，用于在指定维度上获取张量中最小值的索引。

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

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() 函数用于计算张量的最大值。

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

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])

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() 函数用于计算张量的最小值。

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

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 中的一个函数，用于检查张量中的所有元素是否都满足某个条件。

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

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 中的一个函数，用于检查张量中的任意元素是否满足某个条件。

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

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 中的一个函数，用于计算张量中的最大值。

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

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])

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 中的一个函数，用于计算两个张量之间的距离。

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

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 中的一个函数，用于计算张量的对数求和指数。

torch.logsumexp(x, dim) = log(sum(exp(x), dim))

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

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 中的一个函数，用于计算张量的平均值。

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

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）。

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

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）值的元素之和。

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

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 中的一个函数，用于计算张量中元素的乘积。

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

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 中的一个函数，用于计算张量中元素的累积和（逐元素累积求和）。

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

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 中的一个函数，用于计算张量中元素的累积乘积（逐元素累积求积）。

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

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]])