code: def get_nll(
      self,
      seq_logits,
      doc_scores,
      target,
      reduce_loss=False,
      epsilon=0.0,
      exclude_bos_score=False,
      n_docs=None,
  ):
      # shift tokens left
      target = torch.cat(
          [
              target[:, 1:],
              target.new(target.shape[0], 1).fill_(
                  self.config.generator.pad_token_id
              ),
          ],
          1,
      )
  
      n_docs = n_docs if n_docs is not None else self.config.n_docs
  
      # bos_token_id is None for T5
      bos_token_id = (
          self.config.bos_token_id or self.config.generator.bos_token_id
      )
      use_bos = (
          bos_token_id is not None
          and target[:, 0].eq(bos_token_id).all()
      )
  
      def _mask_pads(ll, smooth_obj):
          pad_mask = target.eq(self.config.generator.pad_token_id)
          if pad_mask.any():
              ll.masked_fill_(pad_mask, 0.0)
              smooth_obj.masked_fill_(pad_mask, 0.0)
          return ll.squeeze(-1), smooth_obj.squeeze(-1)
  
      # seq_logits dim = (batch*n_docs, tgt_len , #vocabs)
      seq_logprobs = nn.functional.log_softmax(seq_logits, dim=-1).view(
          seq_logits.shape[0] // n_docs, n_docs, -1, seq_logits.size(-1)
      )  # batch_size x n_docs x tgt_len x #vocab_size
      doc_logprobs = (
          nn.functional.log_softmax(doc_scores, dim=1)
          .unsqueeze(-1)
          .unsqueeze(-1)
      )
  
      # RAG-sequence marginalization
      first_token_scores = seq_logprobs[:, :, :1, :]
      second_token_scores = seq_logprobs[:, :, 1:2, :]
      remainder = seq_logprobs[:, :, 2:, :]
      rag_logprobs = torch.cat(
          [
              first_token_scores,
              second_token_scores + doc_logprobs,
              remainder,
          ],
          dim=2,
      )
  
      # calculate loss
      target = target.unsqueeze(1).unsqueeze(-1).repeat(1, n_docs, 1, 1)
      assert target.dim() == rag_logprobs.dim()
  
      ll = rag_logprobs.gather(dim=-1, index=target)
      smooth_obj = rag_logprobs.sum(
          dim=-1, keepdim=True
      )  # total sum of all (normalised) logits
  
      ll, smooth_obj = _mask_pads(ll, smooth_obj)
  
      # sum over tokens, exclude bos while scoring
      ll = (
          ll[:, :, 1:].sum(2)
          if exclude_bos_score and use_bos
          else ll.sum(2)
      )
      smooth_obj = smooth_obj.sum(2)
      ll = ll.logsumexp(1)  # logsumexp over docs
      smooth_obj = smooth_obj.logsumexp(1)
  
      nll_loss = -ll
      smooth_loss = -smooth_obj
  
      if reduce_loss:
          nll_loss = nll_loss.sum()
          smooth_loss = smooth_loss.sum()
  
      eps_i = epsilon / rag_logprobs.size(-1)
      loss = (1.0 - epsilon) * nll_loss + eps_i * smooth_loss
      return loss
  
imports: import copy
  from dataclasses import dataclass
  from typing import Callable, List, Optional, Tuple, Union
  import torch
  from torch import nn
  from ...configuration_utils import PretrainedConfig
  from ...generation import BeamSearchScorer, GenerationConfig, LogitsProcessorList, StoppingCriteriaList
  from ...modeling_outputs import ModelOutput
  from ...modeling_utils import PreTrainedModel
  from ...utils import add_start_docstrings_to_model_forward, logging, replace_return_docstrings
  from .configuration_rag import RagConfig
  from .retrieval_rag import RagRetriever
label_desc: Use image node_id 9 for calling the RagSequenceForGeneration obj's underlying member method code with example usage: obj.get_nll(seq_logits, doc_scores, target, reduce_loss, epsilon, exclude_bos_score, n_docs) and returns: loss, ll,  smooth_obj