一、背景

        pytorch是深度学习的重要建模工具，也几乎是人工智能工程师必须掌握的一大法宝。在建模的过程中，pytorch提供了很多高效的函数以及方法便于我们对数据、模型进行处理。为了避免重复造轮子，我们来盘点下pytorch常用的函数及方法。

二、常见函数及方法

1、张量操作

• torch.tensor(data)：创建一个新的张量。
• tensor.numpy()：将PyTorch张量转换为NumPy数组。
• tensor.detach()：返回一个新的张量，与当前计算图断开连接，不会在梯度传播中跟踪。例如，在模型评估阶段，我们需要对模型的输出进行一些操作，但不希望这些操作影响模型的梯度时，使用detach()可以确保评估过程中的计算不会影响训练过程。此外，当我们需要将张量从一个设备（如GPU）移动到另一个设备（如CPU）时，detach()可以避免不必要的梯度计算。

import torch# 创建一个需要梯度的张量
x = torch.randn(2, 2, requires_grad=True)
# 执行一些操作
y = x * x
# 将y从计算图中分离
z = y.detach()
z.requires_grad_()
# 对z进行操作不会影响x的梯度
z.sum().backward()  # 这不会在x上产生梯度
# 检查x的梯度
print(x.grad)  # None，因为没有对x进行需要梯度的计算

• tensor.requires_grad_()：设置张量，使其在计算图中跟踪梯度。

import torch# 创建一个张量，默认不跟踪梯度
x = torch.randn(2, 2)
print(x.requires_grad)  # 输出: False# 开启梯度跟踪
x.requires_grad_()  # 现在x将跟踪梯度
print(x.requires_grad)  # 输出: True

• tensor.grad：获取或设置张量的梯度。
• torch.no_grad()：上下文管理器，用于禁用梯度计算，一般用在模型评估等不需要反向传播的环节。

with torch.no_grad():outputs = model(inputs)

• torch.randn(*sizes)：生成一个形状为sizes的张量，填充随机值来自标准正态分布。
• torch.zeros(*sizes)：生成一个形状为sizes的张量，填充值为0。
• torch.ones(*sizes)：生成一个形状为sizes的张量，填充值为1。
• torch.cat(tensors, dim)：沿指定维度dim连接张量序列。

import torch# 创建两个二维张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6], [7, 8]])# 沿维度0连接张量
result = torch.cat((tensor1, tensor2), dim=0)
print(result)

• torch.stack(tensors, dim)：沿新维度dim堆叠张量序列。

import torch# 创建两个张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6], [7, 8]])# 沿新的维度堆叠张量
stacked_tensor = torch.stack((tensor1, tensor2), dim=0)
print(stacked_tensor)

• torch.squeeze(tensor, dim)：去除张量中大小为1的维度。

import torch# 创建一个张量，其中包含大小为1的维度
tensor = torch.tensor([[[1], [2]]])# 去除所有大小为1的维度
squeezed_tensor = torch.squeeze(tensor)
print(squeezed_tensor)

• torch.unsqueeze(tensor, dim)：在指定维度dim插入大小为1的维度。

import torch# 创建一个向量
tensor = torch.tensor([1, 2])# 在第1维插入大小为1的维度
unsqueezed_tensor = torch.unsqueeze(tensor, dim=1)
print(unsqueezed_tensor)

2、数字和聚合操作

• torch.sum(tensor, dim)：沿指定维度dim计算张量的和。

import torch# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]])# 计算所有元素的和
sum_all = torch.sum(tensor)
# 计算每一列的和
sum_columns = torch.sum(tensor, dim=0)
print("Sum of all elements:", sum_all)
print("Sum of each column:", sum_columns)

• torch.mean(tensor, dim)：沿指定维度dim计算张量的平均值。

import torch# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]], dtype=torch.float)# 计算所有元素的平均值
mean_all = torch.mean(tensor)
# 计算每一列的平均值
mean_columns = torch.mean(tensor, dim=0)
print("Mean of all elements:", mean_all)
print("Mean of each column:", mean_columns)

• torch.min(tensor, dim)：沿指定维度dim找到张量的最小值。

import torch# 创建一个张量
tensor = torch.tensor([[1, 3], [2, 0]])# 计算所有元素中的最小值
min_all = torch.min(tensor)# 计算每一列的最小值
min_columns = torch.min(tensor, dim=0)[0]  # Returns a tuple, so we take the first elementprint("Min of all elements:", min_all)
print("Min of each column:", min_columns)

• torch.max(tensor, dim)：沿指定维度dim找到张量的最大值。

import torch# 创建一个张量
tensor = torch.tensor([[1, 3], [2, 0]])# 计算所有元素中的最大值
max_all = torch.max(tensor)
# 计算每一列的最大值
max_columns = torch.max(tensor, dim=0)[0]  # Returns a tuple, so we take the first element
print("Max of all elements:", max_all)
print("Max of each column:", max_columns)

• torch.argmax(tensor, dim)：沿指定维度dim找到张量最大值的索引。

import torch# 创建一个张量
tensor = torch.tensor([[1, 3], [2, 0]])# 计算每一列最大值的索引
argmax_columns = torch.argmax(tensor, dim=0)print("Argmax of each column:", argmax_columns)

• torch.exp(tensor)：计算张量中每个元素的指数。

import torch# 创建一个张量
tensor = torch.tensor([0.0, 1.0, 2.0])# 计算每个元素的指数
exp_tensor = torch.exp(tensor)print("Exponential of tensor:", exp_tensor)

• torch.log(tensor)：计算张量中每个元素的自然对数。

import torch# 创建一个张量
tensor = torch.tensor([1.0, 2.0, 3.0])# 计算每个元素的自然对数
log_tensor = torch.log(tensor)print("Natural logarithm of tensor:", log_tensor)

3、张量计算

• torch.matmul(tensor1, tensor2)：计算两个张量的矩阵乘积。

import torch# 创建两个2x2矩阵
matrix1 = torch.tensor([[1, 2], [3, 4]])
matrix2 = torch.tensor([[5, 6], [7, 8]])# 计算矩阵乘积
result = torch.matmul(matrix1, matrix2)print("Matrix multiplication result:\n", result)

• torch.inverse(tensor)：计算方阵张量的逆。

import torch# 创建一个2x2方阵
matrix = torch.tensor([[1, 2], [3, 4]], dtype=torch.float)# 计算矩阵的逆
# 注意：只有方阵才有逆
inverse_matrix = torch.inverse(matrix)print("Inverse of matrix:\n", inverse_matrix)

• torch.norm(tensor, p)：计算张量的Lp范数。

import torch# 创建一个向量
vector = torch.tensor([3, 4], dtype=torch.float)# 计算L1范数（绝对值之和）
norm_l1 = torch.norm(vector, p=1)# 计算L2范数（欧几里得距离）
norm_l2 = torch.norm(vector, p=2)print("L1 norm of vector:", norm_l1)
print("L2 norm of vector:", norm_l2)