code: def beam_search(
      self,
      input_ids,
      encoder_output,
      attention_mask,
      num_beams,
      max_length,
      pad_token_id: int,
      eos_token_id: int,
  ):
      batch_size = self.beam_scorer.batch_size
  
      num_beams = self.beam_scorer.num_beams
      batch_beam_size, cur_len = input_ids.shape
  
      assert (
          num_beams * batch_size == batch_beam_size
      ), f"Batch dimension of `input_ids` should be {num_beams * batch_size}, but is {batch_beam_size}."
  
      beam_scores = torch.zeros(
          (batch_size, num_beams),
          dtype=torch.float,
          device=input_ids.device,
      )
      beam_scores[:, 1:] = -1e9
      beam_scores = beam_scores.view((batch_size * num_beams,))
      next_tokens = torch.zeros(
          (batch_size, num_beams),
          dtype=torch.long,
          device=input_ids.device,
      )
      next_indices = torch.zeros(
          (batch_size, num_beams),
          dtype=torch.long,
          device=input_ids.device,
      )
  
      past: List[torch.Tensor] = []
      while cur_len < max_length:
          logits, past = self._decoder_forward(
              input_ids, encoder_output, attention_mask, past
          )
          next_token_logits = logits[:, -1, :]
  
          # adjust tokens for Bart, *e.g.*
          next_token_logits = self.adjust_logits_during_generation(
              next_token_logits, cur_len=cur_len, max_length=max_length
          )
  
          next_token_scores = F.log_softmax(
              next_token_logits, dim=-1
          )  # (batch_size * num_beams, vocab_size)
  
          # pre-process distribution
          next_token_scores = self.logits_processor(
              input_ids, next_token_scores
          )
          next_token_scores = next_token_scores + beam_scores[
              :, None
          ].expand_as(next_token_scores)
  
          # reshape for beam search
          vocab_size = next_token_scores.shape[-1]
          next_token_scores = next_token_scores.view(
              batch_size, num_beams * vocab_size
          )
  
          next_token_scores, next_tokens = torch.topk(
              next_token_scores,
              2 * num_beams,
              dim=1,
              largest=True,
              sorted=True,
          )
  
          next_indices = next_tokens // vocab_size
          next_tokens = next_tokens % vocab_size
  
          (
              beam_scores,
              beam_next_tokens,
              beam_idx,
          ) = self.beam_scorer.process(
              input_ids,
              next_token_scores,
              next_tokens,
              next_indices,
              pad_token_id=pad_token_id,
              eos_token_id=eos_token_id,
          )
  
          input_ids = torch.cat(
              [input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)],
              dim=-1,
          )
  
          cur_len = cur_len + 1
  
          if len(past) > 0:
              past = self._reorder_cache(past, beam_idx)
  
          if self.beam_scorer.is_done():
              break
  
      sequences, sequence_scores = self.beam_scorer.finalize(
          input_ids,
          beam_scores,
          next_tokens,
          next_indices,
          pad_token_id=pad_token_id,
          eos_token_id=eos_token_id,
      )
  
      return sequences
  
imports: import copy
  import itertools
  from typing import List, Optional, Tuple
  import torch
  import torch.nn.functional
  from transformers import BartConfig
  from transformers.generation import GenerationMixin
label_desc: Use image node_id 6 for calling the BARTBeamSearchGenerator obj's underlying member method code with example usage: obj.beam_search(input_ids, encoder_output, attention_mask, num_beams, max_length, pad_token_id, eos_token_id) and returns: sequences