序列到序列损失

Question

我试图弄清楚如何计算序列到序列的损失。在这种情况下，我使用的是 huggingface 转换器库，但这实际上可能与其他 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。

1. 屏蔽版本的输出标签需要有-100。变压器库不适合您。
2. 我犯的一个愚蠢错误是使用面具。应该是 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: