序列到序列丢失

Question

我想弄清楚序列到序列的损失是如何计算的。在这种情况下，我使用的是 huggingface transformers 库，但这实际上可能与其他 DL 库相关。

所以要获取所需的数据，我们可以这样做：

from transformers import EncoderDecoderModel, BertTokenizer
import torch
import torch.nn.functional as F
torch.manual_seed(42)

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
MAX_LEN = 128
tokenize = lambda x: tokenizer(x, max_length=MAX_LEN, truncation=True, padding=True, return_tensors="pt")

model = EncoderDecoderModel.from_encoder_decoder_pretrained('bert-base-uncased', 'bert-base-uncased') # initialize Bert2Bert from pre-trained checkpoints
input_seq = ["Hello, my dog is cute", "my cat cute"]
output_seq = ["Yes it is", "ok"]
input_tokens = tokenize(input_seq)
output_tokens = tokenize(output_seq)

outputs = model(
    input_ids=input_tokens["input_ids"], 
    attention_mask=input_tokens["attention_mask"],
    decoder_input_ids=output_tokens["input_ids"], 
    decoder_attention_mask=output_tokens["attention_mask"],
    labels=output_tokens["input_ids"], 
    return_dict=True)

idx = output_tokens["input_ids"]
logits = F.log_softmax(outputs["logits"], dim=-1)
mask = output_tokens["attention_mask"]

编辑 1

感谢@cronoik，我能够将 huggingface 计算的损失复制为：

output_logits = logits[:,:-1,:]
output_mask = mask[:,:-1]
label_tokens = output_tokens["input_ids"][:, 1:].unsqueeze(-1)
select_logits = torch.gather(output_logits, -1, label_tokens).squeeze()
huggingface_loss = -select_logits.mean()

然而，由于第二个输入的最后两个标记只是填充，我们不应该将损失计算为：

seq_loss = (select_logits * output_mask).sum(dim=-1, keepdims=True) / output_mask.sum(dim=-1, keepdims=True)
seq_loss = -seq_loss.mean()

^这考虑了每行输出序列的长度，以及通过屏蔽掉的填充。当我们有不同长度的批量输出时，认为这特别有用。

Answer 1

好的，我发现我哪里出错了。这都要感谢this thread in the HuggingFace forum.

屏蔽版本的输出标签需要 -100。 transoformers 库不会为你做这件事。
我犯的一个愚蠢的错误是面具。它应该是 output_mask = mask[:, 1:] 而不是 :-1。

1。使用型号

我们需要将输出掩码设置为-100。使用克隆很重要，如下所示：

labels = output_tokens["input_ids"].clone()
labels[output_tokens["attention_mask"]==0] = -100

outputs = model(
    input_ids=input_tokens["input_ids"], 
    attention_mask=input_tokens["attention_mask"],
    decoder_input_ids=output_tokens["input_ids"], 
    decoder_attention_mask=output_tokens["attention_mask"],
    labels=labels, 
    return_dict=True)

2。计算损失

所以最终的复制方式如下：

idx = output_tokens["input_ids"]
logits = F.log_softmax(outputs["logits"], dim=-1)
mask = output_tokens["attention_mask"]

# shift things
output_logits = logits[:,:-1,:]
label_tokens = idx[:, 1:].unsqueeze(-1)
output_mask = mask[:,1:]

# gather the logits and mask
select_logits = torch.gather(output_logits, -1, label_tokens).squeeze()
-select_logits[output_mask==1].mean(), outputs["loss"]

然而，以上内容忽略了这来自两条不同线路的事实。所以另一种计算损失的方法可能是：

seq_loss = (select_logits * output_mask).sum(dim=-1, keepdims=True) / output_mask.sum(dim=-1, keepdims=True)
seq_loss.mean()

Answer 2

感谢分享。然而，今天的新版变形金刚实际上不再“移动”了。以下不需要。

#shift things 
output_logits = logits[:,:-1,:]
label_tokens = idx[:, 1:].unsqueeze(-1) 
output_mask = mask[:,1:

序列到序列丢失

Sequence to Sequence Loss

deep-learning

pytorch

huggingface-transformers

编辑 1

1。使用型号

2。计算损失