When learning with Transformer, loss becomes nan after backpropagation.

[sooftware]

Currently, Seq2seq and Transformer have two models implemented, and after backpropagation when learning with Transformer, the phenomenon of loss becoming nan continues. I have tried debugging, but I have not yet confirmed which part is wrong. If you have had a similar experience or have any guesses, I would appreciate it if you could help me.

[affjljoo3581]

Applying attention masks with -np.inf may lead nan in both outputs and gradients (of course). You can simply test with:

model = SpeechTransformer(
    num_classes=10, d_model=64, input_dim=80, d_ff=256,
    num_encoder_layers=3, num_decoder_layers=3)

inputs = torch.rand((32, 16, 80), dtype=torch.float)
targets = torch.randint(0, 10, (32, 16), dtype=torch.long)
lengths = torch.empty((32,), dtype=torch.long).fill_(80)

with torch.no_grad():
    predicted = model(inputs, lengths, targets)
    print(np.isnan(predicted.numpy()).any())

Using -np.inf in masked_fill_:

True

Using -1e9 in masked_fill_:

False

The implementations of Transformer model usually choose the constant (and bounded) values instead of unusual ones (e.g. np.inf, float('inf')).

• https://github.com/huggingface/transformers/blob/b76cb1c3dfc64d1dcaddc3d6d9313dddeb626d05/src/transformers/modeling_gpt2.py#L573
• https://github.com/huggingface/transformers/blob/b76cb1c3dfc64d1dcaddc3d6d9313dddeb626d05/src/transformers/modeling_utils.py#L203
• https://github.com/affjljoo3581/GPT2/blob/cf7388417386beaf3c104f2e3c48ba86630f3681/src/gpt2/modeling/attention.py#L33

Sometimes you can see some with -np.inf, but note that they are written for evaluation, not training. Of course there is no problem with using -np.inf in inference.

[sooftware]

I never thought there was a bug in that part! Thank you, I'll try it out!

[sooftware]

After experimenting, loss becomes nan again. There was this problem, but there seems to be another problem.

[sooftware]

And if you refer to this repo, it works normally when it is -np.inf. Further checks are likely to be needed on that part.

[affjljoo3581]

Let's check why this repository works well with -np.inf. First, create two dummy tensors as follows:

pred = np.random.rand(64, 32, 1024)
pred = np.where(pred < 0.999999, pred, np.nan)
pred = torch.tensor(pred, dtype=torch.float)

target = np.random.randint(0, 1024, (64, 32), dtype=np.long)
target = np.where(np.any(np.isnan(pred), axis=-1), 0, target)
target = torch.tensor(target, dtype=torch.long)

pred tensor contains nan in random positions. Of course, target contains the information to ignore the nan elements. Let's compare the losses from two criterions (LabelSmoothedCrossEntropyLoss and cal_loss in this repository).

• LabelSmoothedCrossEntropyLoss

loss = LabelSmoothedCrossEntropyLoss(
    num_classes=1024,
    ignore_index=0,
    smoothing=0.1,
    architecture='transformer',
    reduction='mean')
print(loss(pred.view(-1, pred.size(-1)), target.view(-1)))

Output: tensor(nan)

• cal_loss in kaituoxu/Speech-Transformer

print(cal_loss(pred.view(-1, pred.size(2)), target.view(-1),
               smoothing=0.1))

Output: tensor(6.9713)

Why is it happend? Actually, they both work well without label-smoothing. The problem is in reducing the loss tensor.

• LabelSmoothedCrossEntropyLoss

# ...
with torch.no_grad():
    label_smoothed = torch.zeros_like(logit)
    label_smoothed.fill_(self.smoothing / (self.num_classes - 1))
    label_smoothed.scatter_(1, target.data.unsqueeze(1), self.confidence)
    label_smoothed[target == self.ignore_index, :] = 0
return self.reduction_method(-label_smoothed * logit)
# ...

• cal_loss in kaituoxu/Speech-Transformer

# ...
non_pad_mask = gold.ne(IGNORE_ID)
n_word = non_pad_mask.sum().item()
loss = -(one_hot * log_prb).sum(dim=1)
loss = loss.masked_select(non_pad_mask).sum() / n_word
# ...

While your code reduces the smoothed logits, cal_loss uses maksed_select to exclude nan values (precisely, IGNORE_ID elements). label_smooth contains non-zero nan weights (that is, nan values should be multiplied with non-zero weights in label_smooth) and it may lead nan of total loss.

So if you want to use -np.inf in attention masks, you should change the code as below:

with torch.no_grad():
    label_smoothed = torch.zeros_like(logit)
    label_smoothed.fill_(self.smoothing / (self.num_classes - 1))
    label_smoothed.scatter_(1, target.data.unsqueeze(1), self.confidence)
    # label_smoothed[target == self.ignore_index, :] = 0

    score = (-label_smoothed * logit).sum(1)
    score = score.masked_select(target != self.ignore_index)
return self.reduction_method(score)

Output: tensor(6.9704)

[sooftware]

oh thanks to let me know.
But loss is still nan.
I'd appreciate it if you could tell me where you can guess.

[affjljoo3581]

I've never seen RampUpLR scheduling before. Can you explain the concept of ramp up lr decay?

[sooftware]

Never mind.
I checked that it had nothing to do with turning it off and turning it on.

[affjljoo3581]

No. Basically Transformer model with post-LN needs learning rate warm-up. You need to consider that. I don't have any dataset of this project so I cannot test your code accurately. When does the loss diverge? Can you show me the training logs in detail?