code: def process(
      self,
      input_ids: torch.Tensor,
      next_scores: torch.Tensor,
      next_tokens: torch.Tensor,
      next_indices: torch.Tensor,
      pad_token_id: Optional[int] = None,
      eos_token_id: Optional[int] = None,
  ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
      cur_len = input_ids.shape[-1]
      batch_size = len(self._beam_hyps_count)
      assert batch_size == (input_ids.shape[0] // self.group_size)
  
      device = input_ids.device
      next_beam_scores = torch.zeros(
          (batch_size, self.group_size),
          dtype=next_scores.dtype,
          device=device,
      )
      next_beam_tokens = torch.zeros(
          (batch_size, self.group_size),
          dtype=next_tokens.dtype,
          device=device,
      )
      next_beam_indices = torch.zeros(
          (batch_size, self.group_size),
          dtype=next_indices.dtype,
          device=device,
      )
  
      for batch_idx in range(batch_size):
          if self._done[batch_idx]:
              assert (
                  self.hypo_len(batch_idx) >= self.num_beams
              ), "Batch can only be done if at least {} beams have been generated".format(
                  self.num_beams
              )
              assert (
                  eos_token_id is not None and pad_token_id is not None
              ), "generated beams >= num_beams -> eos_token_id and pad_token have to be defined"
              # pad the batch
              next_beam_scores[batch_idx, :] = 0
              next_beam_tokens[batch_idx, :] = pad_token_id
              next_beam_indices[batch_idx, :] = 0
              continue
  
          # next tokens for this sentence
          beam_idx = 0
          for beam_token_rank, (
              next_token,
              next_score,
              next_index,
          ) in enumerate(
              zip(
                  next_tokens[batch_idx],
                  next_scores[batch_idx],
                  next_indices[batch_idx],
              )
          ):
              batch_beam_idx = batch_idx * self.group_size + next_index
              # add to generated hypotheses if end of sentence
              if (eos_token_id is not None) and (
                  next_token == eos_token_id
              ):
                  # if beam_token does not belong to top num_beams tokens, it should not be added
                  is_beam_token_worse_than_top_num_beams = (
                      beam_token_rank >= self.group_size
                  )
                  if is_beam_token_worse_than_top_num_beams:
                      continue
                  self.hypo_add(
                      input_ids[batch_beam_idx].clone(),
                      next_score.item(),
                      batch_idx,
                  )
              else:
                  # add next predicted token since it is not eos_token
                  next_beam_scores[batch_idx, beam_idx] = next_score
                  next_beam_tokens[batch_idx, beam_idx] = next_token
                  next_beam_indices[
                      batch_idx, beam_idx
                  ] = batch_beam_idx
                  beam_idx += 1
  
              # once the beam for next step is full, don't add more tokens to it.
              if beam_idx == self.group_size:
                  break
  
          if beam_idx < self.group_size:
              raise ValueError(
                  f"At most {self.group_size} tokens in {next_tokens[batch_idx]} can be equal to `eos_token_id:"
                  f" {eos_token_id}`. Make sure {next_tokens[batch_idx]} are corrected."
              )
  
          # Check if we are done so that we can save a pad step if all(done)
          self._done[batch_idx] = self._done[
              batch_idx
          ] or self.hypo_is_done(
              batch_idx,
              next_scores[batch_idx].max().item(),
              cur_len,
          )
  
      return (
          next_beam_scores.view(-1),
          next_beam_tokens.view(-1),
          next_beam_indices.view(-1),
      )
  
imports: import copy
  import itertools
  from typing import List, Optional, Tuple
  import torch
  import torch.nn.functional
  from transformers import BartConfig
  from transformers.generation_utils import GenerationMixin
label_desc: Use image node_id 7 for calling the BeamSearchScorerTS obj's underlying member method code with example usage: obj.process(input_ids, next_scores, next_tokens, next_indices, pad_token_id, eos_token_id) and returns: next_beam_scores,  next_beam_tokens,  next_beam_indices