00200 PyTorch - 常用函数

前言

简单的介绍PyTorch - 常用函数。

Operating System: Ubuntu 22.04.4 LTS

独立函数

torch.unsqueeze

api link: https://pytorch.org/docs/stable/generated/torch.unsqueeze.html#torch.unsqueeze

unsqueeze 是 PyTorch 中的一个函数，用于增加一个维度到给定张量（tensor）的指定位置。这个函数常用于在神经网络中处理数据的维度，确保数据能够正确地传递到网络的下一层。

以下是 unsqueeze 函数的基本用法：

torch.unsqueeze(input, dim)

• input：要处理的张量。
• dim：要在其中插入新维度的位置。

如果 dim 是一个整数，那么新维度将会被插入到 input 张量的指定位置。注意，PyTorch 中的维度索引是从0开始的。如果 dim 是负数，则新维度将会被添加到从末尾开始的指定位置。

这里有一个例子：

import torch
x = torch.tensor([1, 2, 3, 4])  # 创建一个一维张量
print(x.size())  # 输出: torch.Size([4])
y = x.unsqueeze(0)  # 在第0维（最外层）增加一个维度
print(y.size())  # 输出: torch.Size([1, 4])
z = x.unsqueeze(1)  # 在第1维增加一个维度
print(z.size())  # 输出: torch.Size([4, 1])

在上面的例子中，x 是一个一维张量。通过 unsqueeze(0)，我们在最外层增加了一个维度，使得 y 成为了一个 2D 张量，形状为 [1, 4]。类似地，通过 unsqueeze(1)，我们在第二个位置增加了一个维度，使得 z 成为了一个形状为 [4, 1] 的 2D 张量。

unsqueeze 常用于将一个一维张量转换为二维张量（例如，批量大小为1的情况），或者将一个二维张量转换为三维张量，其中增加的维度通常用于表示批次大小、通道数等。

torch.repeat_interleave

api link: https://pytorch.org/docs/stable/generated/torch.repeat_interleave.html#torch.repeat_interleave

torch.repeat_interleave 是PyTorch中用于张量操作的函数，它可以沿着指定的维度重复张量中的元素。这个函数对于创建具有特定模式的重复数据非常有用。

以下是 torch.repeat_interleave 的基本用法：

torch.repeat_interleave(input, repeats, dim=None)

• input: 要重复的输入张量。
• repeats: 一个1-D张量，指定了 input 张量在 dim 维度上每个元素的重复次数。
• dim: 要重复的维度，如果 dim 是None，那么 input 会被展平成一维张量后再进行重复。

下面是一个简单的例子：

import torch
x = torch.tensor([1, 2, 3])
repeats = torch.tensor([2, 3, 4])
result = torch.repeat_interleave(x, repeats, dim=0)
print(result)

这个例子中，张量 x 的元素 [1, 2, 3] 将分别被重复 2 次、3 次和 4 次，输出结果将是：

tensor([1, 1, 2, 2, 2, 3, 3, 3, 3])

如果 dim 参数未指定，input 张量首先会被展平，然后根据 repeats 张量中的值进行重复。

这个函数在进行数据预处理和创建批量数据时非常有用，尤其是在需要根据不同的样本长度进行重复操作时。

torch.bitwise_or

torch.bitwise_or 是PyTorch库中的一个函数，用于执行元素级的按位或（bitwise OR）操作。按位或操作比较两个整数值的每一位，如果至少有一个位是1，则结果的对应位为1，否则为0。

以下是 torch.bitwise_or 的基本用法：

import torch
# 创建两个张量
tensor1 = torch.tensor([1, 2, 3], dtype=torch.int32)
tensor2 = torch.tensor([4, 5, 6], dtype=torch.int32)
# 执行按位或操作
result = torch.bitwise_or(tensor1, tensor2)
print(result)

在上面的例子中，tensor1 和 tensor2 中的每个元素都进行了按位或操作，结果如下：

tensor([5, 7, 7], dtype=torch.int32)

按位操作的二进制表示如下：

tensor1: [0001, 0010, 0011]
tensor2: [0100, 0101, 0110]
result:  [0101, 0111, 0111]

torch.bitwise_or 函数要求输入的两个张量要么具有相同的形状，要么其中一个可以是标量（即只有一个元素的张量），在这种情况下，标量值将与另一个张量的每个元素进行按位或操作。此外，输入张量必须具有整数类型。

torch.argwhere

torch.argwhere 是PyTorch库中的一个函数，它用于返回输入张量（Tensor）中非零元素的索引。

具体来说，torch.argwhere 函数会返回一个二维张量，其中的行对应于非零元素的索引。如果输入张量是一个多维张量，那么返回的二维张量的每一行都是一个索引元组，指示原始张量中非零元素的位置。

以下是torch.argwhere的一些关键点：

• 输入张量可以是一维、二维或更高维的张量。
• 该函数仅返回非零元素的索引。
• 返回的张量的形状是 (num_nonzero, input.dim())，其中 num_nonzero 是非零元素的数量，input.dim() 是输入张量的维度。

使用示例：

import torch
# 创建一个张量
a = torch.tensor([[0, 1, 0], [2, 0, 3]])
# 使用torch.argwhere找到非零元素的索引
indices = torch.argwhere(a)
print(indices)

输出将会是：

tensor([[0, 1],
        [1, 0],
        [1, 2]])

在这个例子中，a 是一个2x3的矩阵，torch.argwhere(a) 返回了一个包含非零元素索引的二维张量。例如，第一个非零元素 1 在原始张量中的位置是 [0, 1]，第二个非零元素 2 的位置是 [1, 0]，以此类推。

torch.argwhere 在处理稀疏数据或者在需要找到特定条件元素的索引时非常有用。

torch.logical_or

torch.logical_or 是 PyTorch 库中的一个函数，用于执行元素级的逻辑或运算。给定两个相同形状的张量（tensor），torch.logical_or 会返回一个新的张量，其中每个位置的元素是两个输入张量对应元素逻辑或的结果。

以下是 torch.logical_or 的基本用法：

import torch
# 创建两个布尔类型的张量
tensor1 = torch.tensor([True, False, True, False], dtype=torch.bool)
tensor2 = torch.tensor([False, False, True, True], dtype=torch.bool)
# 使用 torch.logical_or 进行逻辑或运算
result = torch.logical_or(tensor1, tensor2)
print(result)

上面的代码会输出：

tensor([ True, False, True, True])

在这个例子中，tensor1 和 tensor2 在每个位置上进行逻辑或运算，只有当两个元素都是 False 时，结果才是 False，否则是 True。

需要注意的是，输入张量必须是布尔类型的张量，如果不是，你需要先将它们转换为布尔类型。如果输入张量有不同的形状，torch.logical_or 无法直接应用，你需要先对张量进行广播或其他操作以使它们的形状兼容。

reshape

在Python中的NumPy库，reshape方法是一个非常有用的功能，它允许我们改变数组的形状而不改变其数据。具体来说，reshape方法可以重新组织一个数组，使其具有不同的行数和列数，但保持相同数量的元素。

reshape方法的基本用法：

numpy_array.reshape(shape)

• numpy_array：需要重塑的NumPy数组。
• shape：一个整数或者整数元组，用来指定新的形状。

例如，如果你有一个一维数组有8个元素，你可以将其重塑为一个2行4列的二维数组：

import numpy as np
array = np.array([1, 2, 3, 4, 5, 6, 7, 8])
reshaped_array = array.reshape(2, 4)

reshape(-1)的用法：

当使用reshape(-1)时，-1是一个特殊的参数，告诉NumPy自动计算需要的大小以匹配数组中的元素数量。这在当你想要将一个数组转换为一维数组，但又不想手动计算它应该有多少元素时非常有用。

例如，将上述的2行4列的二维数组转换为一维数组：

one_dimensional_array = reshaped_array.reshape(-1)

这里的-1告诉NumPy，让它自己决定正确的维度大小，以保持元素的总数不变。

注意事项：

• 使用reshape方法时，数组的总元素数量必须与新的形状兼容。例如，一个有8个元素的数组不能被重塑为有5个元素的形状。
• reshape返回的是数据的视图，而不是数据的副本，这意味着原始数组和重塑后的数组共享相同的数据缓冲区。修改任何一个数组都会影响到另一个。

通过使用reshape方法和reshape(-1)，可以灵活地操作数组的形状，以适应不同的数据处理需求。

Module 函数

register_buffer

api link: https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.register_buffer

在PyTorch中，register_buffer是一个在模型中注册一个缓冲区（buffer）的方法，这个缓冲区在模型保存和加载时会被包含进去，但它不是一个模型参数，也就是说不会被优化器更新。

缓冲区通常用于存储一些不经常变化的数据，比如批量归一化的均值和方差，或者是在训练RNN时保存隐藏状态等。

下面是register_buffer的一些基本用法：

1. 定义

def register_buffer(self, name, tensor, persistent=True):

• name: 缓冲区的名称，通过这个名称可以在模型中访问这个缓冲区。
• tensor: 要注册的Tensor。
• persistent: 当设置为True时，这个缓冲区在调用state_dict()时会被包含，并且在模型保存和加载时会被持久化。

2. 使用示例

import torch
import torch.nn as nn
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.register_buffer('running_mean', torch.zeros(100))
    def forward(self, x):
        # 使用running_mean进行一些操作
        pass
model = MyModel()
print(model.state_dict())

在这个例子中，running_mean是一个被注册的缓冲区，它在模型的state_dict中，但不是一个参数。

3. 注意事项

• 使用register_buffer注册的缓冲区不参与梯度计算。
• 当你想要保存和恢复模型状态的一部分，但不希望这些状态作为模型参数参与优化时，使用register_buffer是非常有用的。

在实现自定义模型时，合理使用register_buffer可以使得模型的状态管理更加灵活和清晰。

结语

第二百篇博文写完，开心！！！！

今天，也是充满希望的一天。