Question

我想在网络中添加单词dropout，以便我可以有足够的训练样例来训练嵌入“unk”标记。据我所知，这是标准做法。假设unk标记的索引为0，填充的索引为1（如果更方便的话，我们可以切换它们。）

这是一个简单的CNN网络，它按照我预期的方式实现字丢失：

class Classifier(nn.Module):
    def __init__(self, params):
        super(Classifier, self).__init__()
        self.params = params
        self.word_dropout = nn.Dropout(params["word_dropout"])
        self.pad = torch.nn.ConstantPad1d(max(params["window_sizes"])-1, 1)
        self.embedding = nn.Embedding(params["vocab_size"], params["word_dim"], padding_idx=1)
        self.convs = nn.ModuleList([nn.Conv1d(1, params["feature_num"], params["word_dim"] * window_size, stride=params["word_dim"], bias=False) for window_size in params["window_sizes"]])
        self.dropout = nn.Dropout(params["dropout"])
        self.fc = nn.Linear(params["feature_num"] * len(params["window_sizes"]), params["num_classes"])

    def forward(self, x, l):
        x = self.word_dropout(x)
        x = self.pad(x)
        embedded_x = self.embedding(x)
        embedded_x = embedded_x.view(-1, 1, x.size()[1] * self.params["word_dim"]) # [batch_size, 1, seq_len * word_dim]
        features = [F.relu(conv(embedded_x)) for conv in self.convs]
        pooled = [F.max_pool1d(feat, feat.size()[2]).view(-1, params["feature_num"]) for feat in features]
        pooled = torch.cat(pooled, 1)
        pooled = self.dropout(pooled)
        logit = self.fc(pooled)
        return logit

不介意填充 - pytorch没有在CNN中使用非零填充的简单方法，更不用说可训练的非零填充，所以我是手动完成的。 Dropout也不允许我使用非零丢失，我想将填充令牌与unk令牌分开。我将它保留在我的例子中，因为这是这个问题存在的原因。

这不起作用，因为dropout想要Float Tensors以便它可以正确缩放它们，而我的输入是不需要缩放的Long Tensors。

在pytorch中有一种简单的方法吗？我本质上想要使用LongTensor友好的丢失（奖励：如果它允许我指定一个不为0的丢失常量，那么我可以使用零填充）。

Answer 1

实际上，在将输入转换为LongTensor之前，我会在模型之外进行此操作。

这看起来像这样：

import random

def add_unk(input_token_id, p):
    #random.random() gives you a value between 0 and 1
    #to avoid switching your padding to 0 we add 'input_token_id > 1'
    if random.random() < p and input_token_id > 1:
        return 0
    else:
        return input_token_id

#than you have your input token_id
#for this example I take just a random number, lets say 127
input_token_id = 127

#let p be your probability for UNK
p = 0.01

your_input_tensor = torch.LongTensor([add_unk(input_token_id, p)])

修改

因此，有两个选项出现在我的脑海中，实际上是GPU友好的。通常，两种解决方案都应该更有效。

选项一 - 直接在 forward()进行计算：

如果您未使用torch.utils并且之后没有计划使用它，那么这可能就是您的选择。

在我们在主PyTorch类的forward()方法中执行之前，而不是进行计算。但是我在torch 0.3.1.中看不到（简单）这样做，因此您需要升级到版本0.4.0：

因此，想象x是您的输入向量：

>>> x = torch.tensor(range(10)) >>> x tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

probs是一个包含统一丢失概率的向量，因此我们可以稍后检查我们丢失的可能性：

>>> probs = torch.empty(10).uniform_(0, 1) >>> probs tensor([ 0.9793, 0.1742, 0.0904, 0.8735, 0.4774, 0.2329, 0.0074, 0.5398, 0.4681, 0.5314])

现在我们在输入probs上应用了辍学概率x：

>>> torch.where(probs > 0.2, x, torch.zeros(10, dtype=torch.int64)) tensor([ 0, 0, 0, 3, 4, 5, 0, 7, 8, 9])

注意：为了看到一些效果，我在这里选择了0.2的辍学概率。我认为你可能希望它更小。

您可以选择您喜欢的任何令牌/ ID，以下是42作为未知令牌ID的示例：

>>> unk_token = 42 >>> torch.where(probs > 0.2, x, torch.empty(10, dtype=torch.int64).fill_(unk_token)) tensor([ 0, 42, 42, 3, 4, 5, 42, 7, 8, 9])
{p> torch.where附带PyTorch 0.4.0： https://pytorch.org/docs/master/torch.html#torch.where

我不知道您的网络形状，但您的forward()应该看起来像这样（当使用迷你批处理时，您需要在应用辍学之前展平输入）：

def forward_train(self, x, l): # probabilities probs = torch.empty(x.size(0)).uniform_(0, 1) # applying word dropout x = torch.where(probs > 0.02, x, torch.zeros(x.size(0), dtype=torch.int64)) # continue like before ... x = self.pad(x) embedded_x = self.embedding(x) embedded_x = embedded_x.view(-1, 1, x.size()[1] * self.params["word_dim"]) # [batch_size, 1, seq_len * word_dim] features = [F.relu(conv(embedded_x)) for conv in self.convs] pooled = [F.max_pool1d(feat, feat.size()[2]).view(-1, params["feature_num"]) for feat in features] pooled = torch.cat(pooled, 1) pooled = self.dropout(pooled) logit = self.fc(pooled) return logit

注意：我将函数命名为forward_train()，因此您应该使用另一个forward()而不使用dropout进行评估/预测。但您也可以将一些if conditions与train()一起使用。

选项二：使用 torch.utils.data.Dataset ：

如果您使用Dataset提供的torch.utils，则可以非常轻松地进行此类预处理。 Dataset默认情况下使用强大的多处理加速，因此上面的代码示例必须在__getitem__类的Dataset方法中执行。

这可能是这样的：

def __getitem__(self, index): 'Generates one sample of data' # Select sample ID = self.input_tokens[index] # Load data and get label # using add ink_unk function from code above X = torch.LongTensor(add_unk(ID, p=0.01)) y = self.targets[index] return X, y

这有点脱离背景，看起来并不优雅，但我认为你明白了。根据这个blog post of Shervine Amidi at Stanford，在这个函数中做更复杂的预处理步骤应该没问题：

由于我们的代码[Dataset的意思是]被设计为多核友好的，请注意可以做更复杂的操作（例如来自源的计算）文件）而不用担心数据生成成为瓶颈培训过程。

关联的博客文章"A detailed example of how to generate your data in parallel with PyTorch" - 为使用Dataset和DataLoader实施数据生成提供了一个很好的指南。

我想你会更喜欢第一种选择 - 只有两行，它应该非常有效。：）
祝你好运！

在pytorch

1 个答案: