PyTorch学习笔记之基础函数篇（十）

6 张量操作

6.1 torch.reshape()函数

torch.reshape() 是 PyTorch 中的一个函数，用于改变一个张量（tensor）的形状（shape）。这个函数并不会改变张量中的数据，而是返回一个具有新形状的张量视图。

函数原型如下：

torch.reshape(input, shape)

• input：需要改变形状的张量。
• shape：一个包含新形状大小的整数元组。

注意事项：

1. 新的形状必须与原始张量中的元素总数相匹配。换句话说，input.numel()（即张量中的元素总数）必须等于np.prod(shape)（即新形状中所有维度的乘积）。
2. 如果原始张量不是连续存储的（例如，它是一个跨步张量），则reshape操作可能会失败或返回意外的结果。
3. 返回的张量与原始张量共享数据内存，这意味着对其中一个张量所做的任何更改都会反映到另一个张量上。

示例：

import torch

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

# 改变其形状为 (3, 2)
y = x.reshape(3, 2)

print(y)
# 输出：
# tensor([[1, 2],
#         [3, 4],
#         [5, 6]])

在这个例子中，我们有一个形状为 (2, 3) 的张量 x。我们使用 reshape 函数将其改变为形状 (3, 2) 的张量 y。请注意，尽管形状发生了变化，但张量中的元素值保持不变。

6.1 torch.transpose()函数

torch.transpose() 是 PyTorch 中的一个函数，用于交换张量（tensor）的两个维度。这个函数在深度学习中常用于调整张量的形状以适应特定的操作需求。

函数原型如下：

torch.transpose(input, dim0, dim1)

• input：需要进行转置操作的张量。
• dim0：第一个要交换的维度的索引。
• dim1：第二个要交换的维度的索引。

torch.transpose() 函数会返回一个新的张量，其中 dim0 和 dim1 指定的两个维度被交换了位置，而张量中的其他维度保持不变。原始张量不会被改变，因为 PyTorch 中的大多数操作都是惰性的，并且返回的是新张量的视图。

下面是一个使用 torch.transpose() 的例子：

import torch

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

# 交换第0和第1维
y = torch.transpose(x, 0, 1)

print(y)
# 输出：
# tensor([[1, 4],
#         [2, 5],
#         [3, 6]])

在这个例子中，我们有一个形状为 (2, 3) 的张量 x。通过调用 torch.transpose(x, 0, 1)，我们交换了第0维（行）和第1维（列），得到了一个新的形状为 (3, 2) 的张量 y。

注意，torch.transpose() 和 tensor.transpose()（作为张量方法）是等价的。你也可以使用张量方法来进行转置操作：

y = x.transpose(0, 1)

这种转置操作在深度学习中经常用于调整张量的形状以适应模型的要求，比如在进行矩阵乘法或者在进行某些特定的层操作时。

6.1 torch.permute()函数

torch.permute() 是 PyTorch 中的一个函数，用于对张量（tensor）的维度进行重新排序。这个函数返回一个新的张量，其中维度按照指定的顺序重新排列，而原始张量的数据保持不变。

函数原型如下：

torch.permute(input, dims)

• input：需要进行维度重新排序的张量。
• dims：一个包含新维度顺序的整数列表或元组。

dims 中的每个元素都是原始张量维度的索引，按照这些索引的顺序重新排列维度。例如，如果原始张量有一个形状为 (a, b, c)，并且 dims = [2, 0, 1]，则新的张量将具有形状 (c, a, b)。

下面是一个使用 torch.permute() 的例子：

import torch

# 创建一个形状为 (2, 3, 4) 的张量
x = torch.arange(24).reshape(2, 3, 4)

# 打印原始张量的形状
print("Original shape:", x.shape)

# 重新排列维度，将最后一个维度移动到第一个位置
y = x.permute(2, 0, 1)

# 打印重新排列后的张量的形状
print("Permuted shape:", y.shape)

输出：

Original shape: torch.Size([2, 3, 4])
Permuted shape: torch.Size([4, 2, 3])

在这个例子中，原始张量 x 的形状是 (2, 3, 4)。通过调用 permute(2, 0, 1)，我们将最后一个维度（索引为 2）移动到了第一个位置，第二个维度（索引为 0）移动到了第二个位置，而第一个维度（索引为 1）移动到了第三个位置。因此，新的张量 y 的形状变成了 (4, 2, 3)。

torch.permute() 在深度学习中经常用于调整张量的维度顺序，以满足特定操作或模型层的要求。例如，在卷积神经网络中，可能需要将通道维度移动到特定的位置。

6.1 torch.unsqueez()函数

torch.unsqueeze() 是 PyTorch 中的一个函数，用于在张量的指定维度上增加一个大小为 1 的新维度。这通常用于调整张量的维度以满足某些操作的要求。

函数原型如下：

torch.unsqueeze(input, dim)

• input：需要增加维度的张量。
• dim：要在其中增加新维度的位置。

使用 unsqueeze() 时，指定的 dim 位置将在张量的形状中插入一个维度，该维度的大小为 1。

下面是一个使用 torch.unsqueeze() 的例子：

import torch

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

# 在第 0 维（即最前面）增加一个大小为 1 的维度
y = torch.unsqueeze(x, 0)

print(y.shape)  # 输出：torch.Size([1, 3])

# 在第 1 维（即原始形状之后）增加一个大小为 1 的维度
z = torch.unsqueeze(x, 1)

print(z.shape)  # 输出：torch.Size([3, 1])

在这个例子中，我们首先创建了一个形状为 (3,) 的张量 x。然后，我们使用 torch.unsqueeze(x, 0) 在最前面增加了一个维度，得到了形状为 (1, 3) 的张量 y。接着，我们使用 torch.unsqueeze(x, 1) 在原始形状之后增加了一个维度，得到了形状为 (3, 1) 的张量 z。

torch.unsqueeze() 在深度学习中经常用于调整张量的维度以满足特定操作或模型层的要求。例如，在某些情况下，可能需要将一个形状为 (batch_size, channels, height, width) 的图像张量调整为 (batch_size, 1, channels, height, width)，以便能够作为某些模型的输入。

6.1 torch.squeeze()函数

torch.squeeze() 是 PyTorch 中的一个函数，用于移除张量中所有大小为 1 的维度。换句话说，它会“压缩”张量，删除所有单维度条目。

函数原型如下：

torch.squeeze(input, dim=None)

• input：需要压缩维度的张量。
• dim：可选参数，指定要移除的维度的索引。如果提供，则仅移除该维度，即使它的大小不为 1。

如果不指定 dim 参数，torch.squeeze() 会移除所有大小为 1 的维度。如果指定了 dim，则只移除该特定索引的维度，无论它的大小如何。

下面是一个使用 torch.squeeze() 的例子：

import torch

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

# 移除所有大小为 1 的维度
y = torch.squeeze(x)

print(y.shape)  # 输出：torch.Size([3, 4])

# 只移除第 0 维（索引为 0）
z = torch.squeeze(x, dim=0)

print(z.shape)  # 输出：torch.Size([1, 3, 1, 4])

# 只移除第 2 维（索引为 2）
w = torch.squeeze(x, dim=2)

print(w.shape)  # 输出：torch.Size([1, 3, 4])

在这个例子中，我们首先创建了一个形状为 (1, 3, 1, 4) 的张量 x。然后，我们使用 torch.squeeze(x) 移除了所有大小为 1 的维度，得到了形状为 (3, 4) 的张量 y。

接下来，我们尝试只移除特定的维度。使用 torch.squeeze(x, dim=0) 时，我们尝试移除第 0 维，但因为这个维度的大小不为 1，所以张量的形状没有变化。使用 torch.squeeze(x, dim=2) 时，我们移除了第 2 维（即使它的大小为 1），得到了形状为 (1, 3, 4) 的张量 w。

torch.squeeze() 在深度学习中通常用于清理张量的形状，以便它们可以用于特定的操作或模型层。例如，某些层可能不接受具有大小为 1 的维度的输入，或者为了计算效率，我们可能希望移除这些维度。

6.1 torch.cat()函数

torch.cat() 是 PyTorch 中的一个函数，用于沿着指定的维度拼接张量序列。这意味着你可以将多个张量按照某个维度连接起来，形成一个更大的张量。

函数原型如下：

torch.cat(tensors, dim=0, *, out=None)

• tensors：一个张量序列，用于拼接的张量列表或元组。
• dim：拼接操作的维度。默认值是 0，表示在第一个维度上进行拼接。
• out：可选参数，指定输出张量。

下面是一个使用 torch.cat() 的例子：

import torch

# 创建两个形状为 (2, 3) 的张量
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.tensor([[7, 8, 9], [10, 11, 12]])

# 沿着第一个维度（dim=0）拼接张量
z = torch.cat((x, y), dim=0)

print(z)
# 输出：
# tensor([[ 1,  2,  3],
#         [ 4,  5,  6],
#         [ 7,  8,  9],
#         [10, 11, 12]])

# 沿着第二个维度（dim=1）拼接张量
w = torch.cat((x, y), dim=1)

print(w)
# 输出：
# tensor([[ 1,  2,  3,  7,  8,  9],
#         [ 4,  5,  6, 10, 11, 12]])

在这个例子中，我们首先创建了两个形状为 (2, 3) 的张量 x 和 y。然后，我们使用 torch.cat((x, y), dim=0) 沿着第一个维度（dim=0）将它们拼接起来，形成了一个形状为 (4, 3) 的张量 z。接着，我们使用 torch.cat((x, y), dim=1) 沿着第二个维度（dim=1）将它们拼接起来，形成了一个形状为 (2, 6) 的张量 w。

torch.cat() 在深度学习中经常用于组合多个张量，以便能够作为一个整体进行后续的操作或计算。

6.1 torch.stack()函数

torch.stack() 是 PyTorch 中的一个函数，用于沿着新的维度对张量序列进行连接。与 torch.cat() 不同，torch.stack() 会在指定的新维度上增加张量，而不是将它们连接起来。

函数原型如下：

torch.stack(tensors, dim=0, *, out=None)

• tensors：一个张量序列，这些张量将被堆叠起来。
• dim：插入新维度的位置。默认值是 0，意味着新维度将成为最前面的维度。
• out：可选参数，指定输出张量。

torch.stack() 要求所有输入张量具有相同的形状，除了沿着堆叠维度（dim）变化的维度之外。

下面是一个使用 torch.stack() 的例子：

import torch

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

# 沿着第 0 维（即最前面）堆叠张量
z = torch.stack((x, y), dim=0)

print(z)
# 输出：
# tensor([[1, 2, 3],
#         [4, 5, 6]])

# 创建一个形状为 (2, 3) 的张量
a = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 沿着第 1 维（即列方向）堆叠张量 x 和 a
b = torch.stack((x, a), dim=1)

print(b)
# 输出：
# tensor([[1, 1, 2, 3],
#         [2, 4, 5, 6],
#         [3, 7, 8, 9]])

在这个例子中，我们首先创建了两个形状为 (3,) 的张量 x 和 y。使用 torch.stack((x, y), dim=0)，我们在第 0 维（即最前面）堆叠了这两个张量，得到了一个形状为 (2, 3) 的张量 z。

然后，我们创建了一个形状为 (2, 3) 的张量 a。使用 torch.stack((x, a), dim=1)，我们在第 1 维（即列方向）堆叠了 x 和 a，得到了一个形状为 (3, 4) 的张量 b。

torch.stack() 在深度学习中通常用于将多个张量组合成一个更高维度的张量，以满足某些操作或模型的要求。