序列到序列丢失

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

好吧，我发现我在哪里犯了错误。这都要归功于HuggingFace 论坛中的这个帖子。

1. -100屏蔽版本需要有输出标签。Transoformers 库不会为你做这件事。
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()