一些python torch函数
torch.tril 和 torch.triu
`torch.tril` 和 `torch.triu` 是 PyTorch 中用于处理矩阵的下三角和上三角部分的两个函数。它们的主要区别在于它们保留和填充矩阵的不同部分。
1. torch.tril (Lower Triangular):
- 功能: 保留矩阵的下三角部分，包括主对角线，而将上三角部分填充为零。
- 用法: `torch.tril(input, diagonal=0, out=None)`
- 参数:
- `input`: 输入的张量（矩阵）。
- `diagonal`: 指定要保留的对角线。`diagonal=0` 表示主对角线，`diagonal=-1` 表示主对角线以下的一条对角线，依此类推。
- `out`: 可选的输出张量。
- 示例:
import torch
matrix = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
lower_triangular = torch.tril(matrix)
print(lower_triangular)
# 输出:
# tensor([[1, 0, 0],
# [4, 5, 0],
# [7, 8, 9]])2. torch.triu(Upper Triangular)
- 功能: 保留矩阵的上三角部分，包括主对角线，而将下三角部分填充为零。
- 用法: `torch.triu(input, diagonal=0, out=None)`
- 参数:
- `input`: 输入的张量（矩阵）。
- `diagonal`: 指定要保留的对角线。`diagonal=0` 表示主对角线，`diagonal=1` 表示主对角线以上的一条对角线，依此类推。
- `out`: 可选的输出张量。
- 示例:
import torch
matrix = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
upper_triangular = torch.triu(matrix)
print(upper_triangular)
# 输出:
# tensor([[1, 2, 3],
# [0, 5, 6],
# [0, 0, 9]])总结：
- `torch.tril` 用于获取矩阵的下三角部分，并将上三角部分置零。
- `torch.triu` 用于获取矩阵的上三角部分，并将下三角部分置零。
这两个函数在矩阵操作和线性代数计算中非常有用，尤其是在需要分解矩阵或进行特定形式的矩阵运算时。
dropout
在机器学习中，Dropout是一种常用的正则化技术，特别是在深度学习模型的训练过程中。它的主要目的是通过减少神经元之间的复杂共适应性来防止模型过拟合，从而提高模型的泛化能力。以下是对Dropout技术的详细解读：
一、Dropout的定义与原理
Dropout在训练过程中会随机选择神经网络中的一部分神经元，并将其输出暂时设置为零（或等价地，将其权重或激活值置为零）。这意味着在每次前向传播时，神经网络的结构都会有所不同，因为有一部分神经元被“丢弃”了。这种随机性有助于模型学习到更加鲁棒的特征表示，因为它不再依赖于任何特定的神经元组合。
二、Dropout的作用与优势
- 减少神经元之间的复杂共适应性：通过随机丢弃部分神经元，Dropout减少了神经元之间的复杂依赖关系，使得模型在训练过程中不会过于依赖某些特定的神经元组合。
- 防止过拟合：由于每次训练迭代时神经网络的结构都有所不同，Dropout迫使模型学习到更加广泛的特征，而不是仅仅记住训练数据中的噪声或特定模式。这有助于减少模型在未见数据上的过拟合现象。
- 提高模型的泛化能力：通过增加模型的鲁棒性和减少过拟合，Dropout显著提高了模型在新数据上的表现能力，即模型的泛化能力。
三、Dropout的实现与应用
Dropout技术主要应用于具有深度结构的人工神经网络中，特别是在卷积神经网络（CNN）和全连接神经网络（FCN）中效果显著。在实际应用中，Dropout通常通过定义一个保留概率（如0.5）来实现。每个神经元在训练过程中都有该概率被保留（即不被丢弃），否则被丢弃。保留概率的补数（如1-0.5=0.5）即为丢弃神经元的比例，这是一个可调参数，需要根据具体任务和网络结构进行调整以达到最佳效果。
四、Dropout的注意事项
- 丢弃率的选择：丢弃率是一个超参数，需要根据具体任务和网络结构进行调整。过高的丢弃率可能导致模型欠拟合，而过低的丢弃率则可能不足以缓解过拟合。
- 不在所有层中使用Dropout：通常，Dropout被应用于全连接层或卷积层之后，但在输入层或输出层中通常不使用。此外，在某些情况下，如模型已经很大或数据足够多时，可能不需要使用Dropout。
- 训练与测试时的不同处理：在训练时应用Dropout并调整输出权重，而在测试时则不应用Dropout但调整权重。具体来说，在测试阶段，所有神经元都会被保留，但它们的输出会乘以一个因子（通常是保留概率的倒数），以补偿训练时的缩放效应。
五、Dropout的发展
Dropout技术由Hinton等人在2012年提出，并在深度学习领域迅速普及。随着技术的不断发展，Dropout的变种和扩展技术也不断涌现，如R-Dropout等，它们通过不同的方式进一步提高了模型的泛化能力和性能。
综上所述，Dropout是深度学习中一种简单而有效的正则化技术，它通过随机丢弃神经网络中的部分神经元来减少模型的复杂性、防止过拟合，并提高模型的泛化能力。在训练过程中，Dropout使得每次前向传播时神经网络的结构都有所不同，这有助于模型学习到更加鲁棒的特征表示。
torch.stack
torch.stack 是 PyTorch 中的一个函数，用于将一系列的张量（Tensor）沿着一个新的维度堆叠起来。这个函数非常有用，当你有一系列形状相同的张量，并且希望将它们组合成一个更高维度的张量时。
函数签名
torch.stack(tensors, dim=0, *, out=None) → Tensor示例
假设我们有两个形状为 (2, 3) 的张量：
import torch
tensor1 = torch.tensor([[1, 2, 3], [4, 5, 6]])
tensor2 = torch.tensor([[7, 8, 9], [10, 11, 12]])
# 沿着新的维度0堆叠
stacked_tensor = torch.stack((tensor1, tensor2), dim=0)
print(stacked_tensor)输出是
tensor([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])在这个例子中，tensor1 和 tensor2 被沿着一个新的维度（维度0）堆叠，结果是一个形状为 (2, 2, 3) 的张量。
torch.stack 是处理具有相同形状的多个张量时非常有用的工具，特别是在需要将它们组合起来以进行批处理或进一步操作时。
nn.Model中的register_buffer函数
在 PyTorch 中，nn.Module 类提供了一个名为 register_buffer 的方法，它允许你将一个张量（Tensor）注册为模块的持久状态，但这个张量不会被视为模型的参数（即它不会被 optimizer 更新）。注册缓冲区（buffer）通常用于存储那些需要在模型的前向传播过程中使用，但不需要通过梯度下降等优化算法进行更新的数据。
使用 register_buffer 的场景
- 持久化状态：当你需要在模型的多个前向传播之间保持某些状态，但这些状态不需要通过训练过程来更新时。
- 模型特定的数据结构：比如，在某些自定义层中，你可能需要维护一些特定的数据结构（如缓存、索引等），这些结构不是模型的参数。
方法签名
register_buffer(name: str, tensor: Tensor, persistent: bool = True) -> None参数
- name (str)：缓冲区的名称。这个名称将用于后续通过
self访问该缓冲区。 - tensor (Tensor)：要注册的张量。这个张量将被添加到模块的缓冲区中。
- persistent (bool, optional)：如果设置为
False，则缓冲区在第一次调用to()、cpu()、cuda()等方法时不会被自动移动。默认值为True，表示缓冲区是持久的，并且会随着模块一起移动。
示例
import torch
import torch.nn as nn
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
# 初始化一个需要持久化的张量，但不作为参数
self.register_buffer('my_buffer', torch.randn(10))
def forward(self, x):
# 在前向传播中使用注册的缓冲区
return x + self.my_buffer
# 创建模型实例
model = MyModel()
# 打印模型的参数和缓冲区
for name, param in model.named_parameters():
print(f"Parameter: {name}, Data: {param.data}")
for name, buffer in model.named_buffers():
print(f"Buffer: {name}, Data: {buffer.data}")在这个例子中，MyModel 类注册了一个名为 my_buffer 的缓冲区，它是一个形状为 (10,) 的随机张量。在模型的前向传播过程中，这个缓冲区被用来与输入 x 相加。注意，my_buffer 不会被视为模型的参数，因此它不会被优化器更新。
使用 register_buffer 可以确保你的模型在保存和加载时能够正确地处理这些持久化状态，同时避免将它们错误地当作需要优化的参数。
tensor.T 和tensor.transpose的区别
在 PyTorch 中，tensor.T 和 tensor.transpose() 都是用来对张量（Tensor）进行转置操作的，但它们之间有一些细微的区别和适用场景。
tensor.T是tensor.transpose()的一个简便属性，专门用于二维张量（即矩阵）的转置。- 当张量是二维的时，
tensor.T相当于tensor.transpose(0, 1)，即将第0维和第1维互换。 - 如果张量不是二维的，使用
tensor.T可能会引发错误或者得到不符合预期的结果。
- 当张量是二维的时，
tensor.transpose(dim0, dim1)是一个更通用的方法，可以用于任意维度的张量转置。- 它接受两个参数
dim0和dim1，表示要互换的两个维度。你可以使用transpose()来交换任意两个维度，而不仅仅是第0维和第1维。 - 对于二维张量，
tensor.transpose(0, 1)和tensor.T的效果是相同的。
- 它接受两个参数
示例
import torch
# 创建一个二维张量（矩阵）
x = torch.tensor([[1, 2], [3, 4]])
# 使用 tensor.T 进行转置
x_T = x.T
print(x_T)
# 输出:
# tensor([[1, 3],
# [2, 4]])
# 使用 tensor.transpose() 进行转置，效果相同
x_transpose = x.transpose(0, 1)
print(x_transpose)
# 输出与上面相同:
# tensor([[1, 3],
# [2, 4]])
# 创建一个三维张量
y = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
# 尝试使用 tensor.T 对三维张量进行转置（通常不推荐，因为结果可能不是预期的）
y_T = y.T
print(y_T.shape)
# 输出可能是:
# torch.Size([2, 2, 2])
# 这通常不是你想要的，因为它只是简单地交换了最后两个维度，并且结果形状也变了
# 使用 tensor.transpose() 交换特定的两个维度
y_transpose = y.transpose(0, 1)
print(y_transpose)
# 输出:
# tensor([[[5, 6],
# [7, 8]],
#
# [[1, 2],
# [3, 4]]])
# 这里我们交换了第0维和第1维，得到了一个新的三维张量总结来说，tensor.T 是 tensor.transpose() 在二维张量上的一个简便属性，而 tensor.transpose() 是一个更通用、更灵活的方法，可以用于任意维度的张量转置。在使用时，你应该根据张量的维度和你的具体需求来选择合适的方法。
torch.cat
torch.cat 是 PyTorch 中的一个函数，用于将给定的张量（Tensor）序列沿着一个新的维度拼接起来。这个函数非常有用，当你需要将多个张量合并为一个更大的张量时，比如将多个批次的数据合并，或者在处理多维数据时需要将不同的特征或层拼接在一起。
使用方法
基本的使用格式如下：
torch.cat(tensors, dim=0, *, out=None) → Tensortensors：一个张量的序列（比如列表或元组），这些张量必须具有相同的形状，除了拼接的维度之外。dim：拼接的维度。这是一个整数，表示在哪个维度上进行拼接。默认值是0，表示在第一个维度上拼接。out：输出张量。这是一个可选参数，如果提供了这个参数，结果将会被写入这个张量中，而不是创建一个新的张量。
示例
假设我们有两个形状为 (2, 3) 的张量，我们希望在第一个维度上将它们拼接起来：
import torch
# 创建两个形状为 (2, 3) 的张量
x = torch.randn(2, 3)
y = torch.randn(2, 3)
# 在第一个维度上拼接张量
result = torch.cat((x, y), dim=0)
print("x:\n", x)
print("y:\n", y)
print("result:\n", result)这个例子中，result 的形状将会是 (4, 3)，因为我们沿着第一个维度（行）拼接了两个形状为 (2, 3) 的张量。结果如下：
# x:
tensor([[-0.1806, 0.2889, 0.3936],
[ 1.1293, 0.9679, 0.1404]])
# y:
tensor([[ 1.5823e+00, 4.8184e-01, 7.8513e-01],
[ 2.0792e+00, -2.1191e-02, -4.0486e-04]])
# result:
tensor([[-1.8064e-01, 2.8891e-01, 3.9362e-01],
[ 1.1293e+00, 9.6793e-01, 1.4044e-01],
[ 1.5823e+00, 4.8184e-01, 7.8513e-01],
[ 2.0792e+00, -2.1191e-02, -4.0486e-04]])dim=-1 在 torch.cat 函数里表示拼接的维度是最后一个维度。PyTorch 允许使用负数索引来指定维度，其中 -1 表示最后一个维度，-2 表示倒数第二个维度，以此类推。下面是一个使用 dim=-1 的例子，展示如何在最后一个维度上拼接张量：
import torch
# 创建两个形状为 (2, 3) 的张量
x = torch.randn(2, 3)
y = torch.randn(2, 3)
# 在最后一个维度上拼接张量
result = torch.cat((x, y), dim=-1)
print("x:\n", x)
print("y:\n", y)
print("result:\n", result)
print(result.shape) # 输出: torch.Size([2, 6])在这个例子中，result 的形状是 (2, 6)，因为我们沿着最后一个维度（列）拼接了两个形状为 (2, 3) 的张量，使得每个批次中的特征数量从 3 增加到了 6。结果如下：
# x:
tensor([[-1.0212, 0.9198, -0.2946],
[-1.3674, -1.0737, 0.0902]])
# y:
tensor([[-0.8649, 0.3595, -0.9514],
[ 0.8375, 1.1064, 0.5170]])
# result:
tensor([[-1.0212, 0.9198, -0.2946, -0.8649, 0.3595, -0.9514],
[-1.3674, -1.0737, 0.0902, 0.8375, 1.1064, 0.5170]])
torch.Size([2, 6])注意事项
- 所有输入张量在非拼接维度上的大小必须相同。
- 拼接后的张量将具有与输入张量相同的数据类型。
torch.cat 是处理多维数据时非常有用的工具，特别是在需要将数据合并为一个更大的批次或者合并来自不同来源的特征时。
torch.view
tensor.view 是 PyTorch 中的一个方法，用于改变一个张量（tensor）的形状而不改变其数据。这个方法非常有用，尤其是在进行深度学习模型的构建和数据处理时，经常需要将数据转换成不同的形状以满足模型的需求。
使用方法
基本的使用格式如下：
tensor.view(shape)这里，tensor 是你想要改变形状的张量，而 shape 是一个整数或者整数的元组，表示你想要的新形状。
注意事项
-
元素总数不变：使用
view方法时，新形状的元素总数必须与原张量的元素总数相同。如果不同，PyTorch 会抛出一个错误。 -
连续张量：
view方法要求张量是连续的（contiguous）。如果张量不连续，你需要先调用.contiguous()方法来使其连续，然后再使用view方法。 -
维度变化：你可以通过
-1来自动计算某个维度的大小，这样 PyTorch 会根据其他维度的大小和原始张量的元素总数来自动计算这个维度的大小。
示例
假设我们有一个形状为 (2, 3) 的张量，我们想要将其形状改变为 (3, 2)：
import torch
# 创建一个形状为 (2, 3) 的张量
x = torch.randn(2, 3)
# 改变张量的形状为 (3, 2)
y = x.view(3, 2)
print(y)
结果如下：
# x:
tensor([[ 0.5847, 0.1969, 0.5408],
[ 1.0218, -2.0856, 0.9794]])
# y:
tensor([[ 0.5847, 0.1969],
[ 0.5408, 1.0218],
[-2.0856, 0.9794]])如果我们想要将张量展平为一维，可以使用 -1 来自动计算维度：
import torch
# 创建一个形状为 (2, 3) 的张量
x = torch.randn(2, 3)
# 将张量展平
z = x.view(-1)
print(z)结果如下：
# x:
tensor([[-0.2855, -2.2221, 1.0111],
[ 0.8479, 1.3444, -1.1568]])
# z:
tensor([-0.2855, -2.2221, 1.0111, 0.8479, 1.3444, -1.1568])总结
tensor.view 是 PyTorch 中一个非常实用的方法，用于在不改变数据的情况下改变张量的形状。使用时需要注意张量的元素总数不变，且张量需要是连续的。通过合理使用 view 方法，可以更加灵活地处理数据，满足深度学习模型的不同需求。
torch.contiguous
tensor.contiguous 是 PyTorch 中的一个方法，它返回一个新的张量，这个新张量在内存中是连续的（contiguous）。在 PyTorch 中，张量（tensor）有时可能由于某些操作（如 transpose, view, narrow 等）而不再连续，即其数据在内存中不是按照期望的顺序连续存储的。这可能会影响某些操作的性能，特别是那些需要连续内存布局的操作，如 cuda 相关的操作或某些高效的数值计算。
为什么需要连续张量？
- 性能优化：连续的张量通常可以更有效地利用内存，并且在进行某些操作时（如与 GPU 的交互）可能更快。
- 操作要求：有些 PyTorch 操作要求输入张量是连续的。例如，当你想要使用
.view()方法改变张量形状时，如果张量不是连续的，你可能会得到一个错误。
使用方法
基本的使用格式如下：
tensor_contiguous = tensor.contiguous()这里，tensor 是你想要使其连续的张量，而 tensor_contiguous 将是一个新的、在内存中连续的张量，它与原始张量共享相同的数据（但可能有一个不同的内存布局）。
注意事项
- 性能开销：调用
.contiguous()可能会涉及数据的复制，特别是当原始张量不是连续的时。这可能会引入一些性能开销，因此应该谨慎使用。 - 不改变数据：
.contiguous()不会改变张量中的数据值，只是改变数据的内存布局。 - 判断连续性：你可以使用
.is_contiguous()方法来检查一个张量是否是连续的。
示例
import torch
# 创建一个张量
x = torch.randn(2, 3)
# 进行一些可能导致张量不再连续的操作
x_transposed = x.transpose(0, 1)
# 检查张量是否连续
print(x_transposed.is_contiguous()) # 可能输出 False
# 获取一个连续的张量
x_contiguous = x_transposed.contiguous()
# 检查新张量是否连续
print(x_contiguous.is_contiguous()) # 输出 True在这个例子中，x_transposed 可能不是连续的，因为 transpose 操作改变了张量的维度顺序。通过调用 .contiguous()，我们得到了一个新的、在内存中连续的张量 x_contiguous。
总之，.contiguous() 方法在处理需要连续内存布局的场景时非常有用，但应该谨慎使用以避免不必要的性能开销。
原文地址：https://blog.csdn.net/zaishaoyi/article/details/143481051
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！