code: def sequence_cross_entropy_with_logits(
      logits, targets, weights, batch_average=True, label_smoothing=None
  ):
      """
      Computes the cross entropy loss of a sequence, weighted with respect to
      some user provided weights. Note that the weighting here is not the same as
      in the :func:`torch.nn.CrossEntropyLoss()` criterion, which is weighting
      classes; here we are weighting the loss contribution from particular elements
      in the sequence. This allows loss computations for models which use padding.
  
      Parameters
      ----------
      logits : ``torch.FloatTensor``, required.
          A ``torch.FloatTensor`` of size (batch_size, sequence_length, num_classes)
          which contains the unnormalized probability for each class.
      targets : ``torch.LongTensor``, required.
          A ``torch.LongTensor`` of size (batch, sequence_length) which contains the
          index of the true class for each corresponding step.
      weights : ``torch.FloatTensor``, required.
          A ``torch.FloatTensor`` of size (batch, sequence_length)
      batch_average : bool, optional, (default = True).
          A bool indicating whether the loss should be averaged across the batch,
          or returned as a vector of losses per batch element.
      label_smoothing : ``float``, optional (default = None)
          Whether or not to apply label smoothing to the cross-entropy loss.
          For example, with a label smoothing value of 0.2, a 4 class classifcation
          target would look like ``[0.05, 0.05, 0.85, 0.05]`` if the 3rd class was
          the correct label.
  
      Returns
      -------
      A torch.FloatTensor representing the cross entropy loss.
      If ``batch_average == True``, the returned loss is a scalar.
      If ``batch_average == False``, the returned loss is a vector of shape (batch_size,).
  
      """
      # shape : (batch * sequence_length, num_classes)
      logits_flat = logits.view(-1, logits.size(-1))
      # shape : (batch * sequence_length, num_classes)
      log_probs_flat = torch.nn.functional.log_softmax(
          logits_flat, dim=-1
      )
      # shape : (batch * max_len, 1)
      targets_flat = targets.view(-1, 1).long()
  
      if label_smoothing is not None and label_smoothing > 0.0:
          num_classes = logits.size(-1)
          smoothing_value = label_smoothing / num_classes
          # Fill all the correct indices with 1 - smoothing value.
          one_hot_targets = torch.zeros_like(log_probs_flat).scatter_(
              -1, targets_flat, 1.0 - label_smoothing
          )
          smoothed_targets = one_hot_targets + smoothing_value
          negative_log_likelihood_flat = (
              -log_probs_flat * smoothed_targets
          )
          negative_log_likelihood_flat = (
              negative_log_likelihood_flat.sum(-1, keepdim=True)
          )
      else:
          # Contribution to the negative log likelihood only comes from the exact indices
          # of the targets, as the target distributions are one-hot. Here we use torch.gather
          # to extract the indices of the num_classes dimension which contribute to the loss.
          # shape : (batch * sequence_length, 1)
          negative_log_likelihood_flat = -torch.gather(
              log_probs_flat, dim=1, index=targets_flat
          )
      # shape : (batch, sequence_length)
      negative_log_likelihood = negative_log_likelihood_flat.view(
          *targets.size()
      )
      # shape : (batch, sequence_length)
      negative_log_likelihood = (
          negative_log_likelihood * weights.float()
      )
      # shape : (batch_size,)
      per_batch_loss = negative_log_likelihood.sum(1) / (
          weights.sum(1).float() + 1e-13
      )
  
      if batch_average:
          num_non_empty_sequences = (
              weights.sum(1) > 0
          ).float().sum() + 1e-13
          return per_batch_loss.sum() / num_non_empty_sequences
      return per_batch_loss
  
imports: from __future__ import division
  from __future__ import absolute_import
  from collections import defaultdict
  import logging
  import math
  import torch
  from allennlp.common.checks import ConfigurationError
label_desc: Use image node_id 17 for calling a global function with example usage: sequence_cross_entropy_with_logits(logits, targets, weights, batch_average, label_smoothing) and returns: per_batch_loss, unknown