目录
1.DatasetFolder
2.尽量少用.todevicedevice，用zeros\_like/ones\_like之类的代替
3.Register Buffer ( nn.Module.register_buffer)
4.Built-in Identity()
5.Pairwise distances: torch.cdist
6.Cosine similarity: F.cosine_similarity
7.归一化向量: F.normalize
8.线性层 + 分块技巧 (torch.chunk)
9.Masked select (torch.masked_select)
10.使用 torch.where来对tensors加条件
1.DatasetFolder
当学习PyTorch时，人们首先要做的事情之一是实现自己的某种Dataset 。这是一个低级错误，没有必要浪费时间写这样的东西。通常，数据集要么是数据列表(或者是numpy数组)，要么磁盘上的文件。所以，把数据在磁盘上组织好，要比写一个自定义的Dataset来加载某种奇怪的格式更好。分类器最常见的数据格式之一，是有一个带有子文件夹的目录，子文件夹表示类，子文件夹中的文件表示样本，如下所示:
folder/class_0/file1.txt folder/class_0/file2.txt folder/class_0/... folder/class_1/file3.txt folder/class_1/file4.txt folder/class_2/file5.txt folder/class_2/...
有一个内置的方式来加载这类数据集，不管你的数据是图像，文本文件或其他什么，只要使用'DatasetFolder就可以了。令人惊讶的是，这个类是torchvision包的一部分，而不是核心PyTorch。这个类非常全面，你可以从文件夹中过滤文件，使用自定义代码加载它们，并动态转换原始文件。例子:
from torchvision.datasets import DatasetFolder from pathlib import Path # I have text files in this folder ds = DatasetFolder("/Users/marcin/Dev/tmp/my_text_dataset", loader=lambda path: Path(path).read_text(), extensions=(".txt",), #only load .txt files transform=lambda text: text[:100], # only take first 100 characters ) # Everything you need is already there len(ds), ds.classes, ds.class_to_idx (20, ['novels', 'thrillers'], {'novels': 0, 'thrillers': 1})
如果你在处理图像，还有一个torchvision.datasets.ImageFolder类，它基于DatasetLoader，它被预先配置为加载图像。
2.尽量少用.to\(device\)，用zeros\_like/ones\_like之类的代替
很多GitHub仓库的PyTorch代码，几乎在每个repo中都有许多*.to(device)行，它们将数据从CPU或GPU转移到其他地方。这样的语句通常会出现在大量的repos或初学者教程中。个人建议尽可能少地实现这类操作，并依赖内置的PyTorch功能自动实现这类操作。到处使用.to(device)通常会导致性能下降，还会出现异常：
Expected object of device type cuda but got device type cpu
显然，有些情况下你无法回避它，但大多数情况(如果不是全部)都在这里。其中一种情况是初始化一个全0或全1的张量，这在深度神经网络计算损失的的时候是经常发生的，模型的输出已经在cuda上了，你需要另外的tensor也是在cuda上，这时，你可以使用*_like操作符：
my_output # on any device, if it's cuda then my_zeros will also be on cuda my_zeros = torch.zeros_like(my_output_from_model)
在内部，PyTorch所做的是调用以下操作：
my_zeros = torch.zeros(my_output.size(), dtype=my_output.dtype, layout=my_output.layout, device=my_output.device)
所以所有的设置都是正确的，这样就减少了代码中出现错误的概率。类似的操作包括：
torch.zeros_like() torch.ones_like() torch.rand_like() torch.randn_like() torch.randint_like() torch.empty_like() torch.full_like()
3.Register Buffer ( nn.Module.register_buffer)
这将是建议不要到处使用 .to(device) 的下一步。有时，你的模型或损失函数需要有预先设置的参数，并在调用forward时使用，例如，它可以是一个“权重”参数，它可以缩放损失或一些固定张量，它不会改变，但每次都使用。对于这种情况，请使用nn.Module.register_buffer 方法，它告诉PyTorch将传递给它的值存储在模块中，并将这些值随模块一起移动。如果你初始化你的模块，然后将它移动到GPU，这些值也会自动移动。此外，如果你保存模块的状态，buffers也会被保存！
一旦注册，这些值就可以在forward函数中访问，就像其他模块的属性一样。
from torch import nn import torch class ModuleWithCustomValues(nn.Module): def __init__(self, weights, alpha): super().__init__() self.register_buffer("weights", torch.tensor(weights)) self.register_buffer("alpha", torch.tensor(alpha)) def forward(self, x): return x * self.weights + self.alpha m = ModuleWithCustomValues( weights=[1.0, 2.0], alpha=1e-4 ) m(torch.tensor([1.23, 4.56])) tensor([1.2301, 9.1201])
4.Built-in Identity()
有时候，当你使用迁移学习时，你需要用1:1的映射替换一些层，可以用nn.Module来实现这个目的，只返回输入值。PyTorch内置了这个类。例子，你想要在分类层之前从一个预训练过的ResNet50获取图像表示。以下是如何做到这一点：
from torchvision.models import resnet50 model = resnet50(pretrained=True) model.fc = nn.Identity() last_layer_output = model(torch.rand((1, 3, 224, 224))) last_layer_output.shape torch.Size([1, 2048])
5.Pairwise distances: torch.cdist
下次当你遇到计算两个张量之间的欧几里得距离(或者一般来说:p范数)的问题时，请记住torch.cdist。它确实做到了这一点，并且在使用欧几里得距离时还自动使用矩阵乘法，从而提高了性能。
points1 = torch.tensor([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]]) points2 = torch.tensor([[0.0, 0.0], [-1.0, -1.0], [-2.0, -2.0], [-3.0, -3.0]]) # batches don't have to be equal torch.cdist(points1, points2, p=2.0) tensor([[0.0000, 1.4142, 2.8284, 4.2426], [1.4142, 2.8284, 4.2426, 5.6569], [2.8284, 4.2426, 5.6569, 7.0711]])
没有矩阵乘法或有矩阵乘法的性能，在我的机器上使用mm时，速度快了2倍以上。
%%timeit points1 = torch.rand((512, 2)) points2 = torch.rand((512, 2)) torch.cdist(points1, points2, p=2.0, compute_mode="donot_use_mm_for_euclid_dist")
867µs±142µs per loop (mean±std. dev. of 7 run, 1000 loop each)
%%timeit points1 = torch.rand((512, 2)) points2 = torch.rand((512, 2)) torch.cdist(points1, points2, p=2.0)
6.Cosine similarity: F.cosine_similarity
与上一点相同，计算欧几里得距离并不总是你需要的东西。当处理向量时，通常余弦相似度是选择的度量。PyTorch也有一个内置的余弦相似度实现。
import torch.nn.functional as F vector1 = torch.tensor([0.0, 1.0]) vector2 = torch.tensor([0.05, 1.0]) print(F.cosine_similarity(vector1, vector2, dim=0)) vector3 = torch.tensor([0.0, -1.0]) print(F.cosine_similarity(vector1, vector3, dim=0)) tensor(0.9988) tensor(-1.)
PyTorch中批量计算余弦距离
import torch.nn.functional as F batch_of_vectors = torch.rand((4, 64)) similarity_matrix = F.cosine_similarity(batch_of_vectors.unsqueeze(1), batch_of_vectors.unsqueeze(0), dim=2) similarity_matrix tensor([[1.0000, 0.6922, 0.6480, 0.6789], [0.6922, 1.0000, 0.7143, 0.7172], [0.6480, 0.7143, 1.0000, 0.7312], [0.6789, 0.7172, 0.7312, 1.0000]])
7.归一化向量: F.normalize
最后一点仍然与向量和距离有松散的联系，那就是归一化：通常是通过改变向量的大小来提高计算的稳定性。最常用的归一化是L2，可以在PyTorch中按如下方式应用:
vector = torch.tensor([99.0, -512.0, 123.0, 0.1, 6.66]) normalized_vector = F.normalize(vector, p=2.0, dim=0) normalized_vector tensor([ 1.8476e-01, -9.5552e-01, 2.2955e-01, 1.8662e-04, 1.2429e-02])
在PyTorch中执行归一化的旧方法是：
vector = torch.tensor([99.0, -512.0, 123.0, 0.1, 6.66]) normalized_vector = vector / torch.norm(vector, p=2.0) normalized_vector tensor([ 1.8476e-01, -9.5552e-01, 2.2955e-01, 1.8662e-04, 1.2429e-02])
在PyTorch中批量进行L2归一化
batch_of_vectors = torch.rand((4, 64)) normalized_batch_of_vectors = F.normalize(batch_of_vectors, p=2.0, dim=1) normalized_batch_of_vectors.shape, torch.norm(normalized_batch_of_vectors, dim=1) # all vectors will have length of 1.0 (torch.Size([4, 64]), tensor([1.0000, 1.0000, 1.0000, 1.0000]))
8.线性层 + 分块技巧 (torch.chunk)
假设你想把你的输入映射到N个不同的线性投影中。你可以通过创建N个nn.Linear来做到这一点。或者你也可以创建一个单一的线性层，做一个向前传递，然后将输出分成N块。这种方法通常会带来更高的性能，所以这是一个值得记住的技巧。
d = 1024 batch = torch.rand((8, d)) layers = nn.Linear(d, 128, bias=False), nn.Linear(d, 128, bias=False), nn.Linear(d, 128, bias=False) one_layer = nn.Linear(d, 128 * 3, bias=False) %%timeit o1 = layers[0](batch) o2 = layers[1](batch) o3 = layers[2](batch)
289 µs ± 30.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%%timeit o1, o2, o3 = torch.chunk(one_layer(batch), 3, dim=1)
202 µs ± 8.09 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
9.Masked select (torch.masked_select)
有时你只需要对输入张量的一部分进行计算。给你一个例子：你想计算的损失只在满足某些条件的张量上。为了做到这一点，你可以使用torch.masked_select，注意，当需要梯度时也可以使用这个操作。
data = torch.rand((3, 3)).requires_grad_() print(data) mask = data > data.mean() print(mask) torch.masked_select(data, mask) tensor([[0.0582, 0.7170, 0.7713], [0.9458, 0.2597, 0.6711], [0.2828, 0.2232, 0.1981]], requires_grad=True) tensor([[False, True, True], [ True, False, True], [False, False, False]]) tensor([0.7170, 0.7713, 0.9458, 0.6711], grad_fn=<MaskedSelectBackward>)
直接在tensor上应用mask
类似的行为可以通过使用mask作为输入张量的 “indexer”来实现。
data[mask] tensor([0.7170, 0.7713, 0.9458, 0.6711], grad_fn=<IndexBackward>)
有时，一个理想的解决方案是用0填充mask中所有的False值，可以这样做:
data * mask tensor([[0.0000, 0.7170, 0.7713], [0.9458, 0.0000, 0.6711], [0.0000, 0.0000, 0.0000]], grad_fn=<MulBackward0>)
10.使用 torch.where来对tensors加条件
当你想把两个张量结合在一个条件下这个函数很有用，如果条件是真，那么从第一个张量中取元素，如果条件是假，从第二个张量中取元素。
x = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0], requires_grad=True) y = -x condition_or_mask = x <= 3.0 torch.where(condition_or_mask, x, y) tensor([ 1., 2., 3., -4., -5.], grad_fn=<SWhereBackward>)
