docstr: Generate sequences for each example without beam search (num_beams == 1).
  All returned sequence are generated independantly.
docstr_tok: ["Generate","sequences","for","each","example","without","beam","search","(","num_beams","==","1",")",".","All","returned","sequence","are","generated","independantly","."]
code: def _generate_no_beam_search(
      self,
      input_ids,
      cur_len,
      max_length,
      min_length,
      do_sample,
      temperature,
      top_k,
      top_p,
      repetition_penalty,
      no_repeat_ngram_size,
      bad_words_ids,
      pad_token_id,
      eos_token_id,
      batch_size,
      attention_mask,
      use_cache,
      model_kwargs,
  ):
      """Generate sequences for each example without beam search (num_beams == 1).
      All returned sequence are generated independantly.
      """
      # length of generated sentences / unfinished sentences
      unfinished_sents = input_ids.new(batch_size).fill_(1)
      sent_lengths = input_ids.new(batch_size).fill_(max_length)
  
      past = None
      while cur_len < max_length:
          model_inputs = self.prepare_inputs_for_generation(
              input_ids,
              past=past,
              attention_mask=attention_mask,
              use_cache=use_cache,
              **model_kwargs,
          )
  
          outputs = self(**model_inputs, return_dict=True)
          next_token_logits = outputs.logits[:, -1, :]
          scores = self.postprocess_next_token_scores(
              scores=next_token_logits,
              input_ids=input_ids,
              no_repeat_ngram_size=no_repeat_ngram_size,
              bad_words_ids=bad_words_ids,
              cur_len=cur_len,
              min_length=min_length,
              max_length=max_length,
              eos_token_id=eos_token_id,
              repetition_penalty=repetition_penalty,
              batch_size=batch_size,
              num_beams=1,
          )
  
          # if model has past, then set the past variable to speed up decoding
          if "past_key_values" in outputs:
              past = outputs.past_key_values
          elif "mems" in outputs:
              past = outputs.mems
  
          if do_sample:
              # Temperature (higher temperature => more likely to sample low probability tokens)
              if temperature != 1.0:
                  scores = scores / temperature
              # Top-p/top-k filtering
              next_token_logscores = top_k_top_p_filtering(
                  scores, top_k=top_k, top_p=top_p
              )
              # Sample
              probs = F.softmax(next_token_logscores, dim=-1)
              next_token = torch.multinomial(
                  probs, num_samples=1
              ).squeeze(1)
          else:
              # Greedy decoding
              next_token = torch.argmax(next_token_logits, dim=-1)
  
              # print(next_token_logits[0,next_token[0]], next_token_logits[0,eos_token_id])
  
          # update generations and finished sentences
          if eos_token_id is not None:
              # pad finished sentences if eos_token_id exist
              tokens_to_add = next_token * unfinished_sents + (
                  pad_token_id
              ) * (1 - unfinished_sents)
          else:
              tokens_to_add = next_token
  
          # add token and increase length by one
          input_ids = torch.cat(
              [input_ids, tokens_to_add.unsqueeze(-1)], dim=-1
          )
          cur_len = cur_len + 1
  
          if eos_token_id is not None:
              eos_in_sents = tokens_to_add == eos_token_id
              # if sentence is unfinished and the token to add is eos, sent_lengths is filled with current length
              is_sents_unfinished_and_token_to_add_is_eos = (
                  unfinished_sents.mul(eos_in_sents.long()).bool()
              )
              sent_lengths.masked_fill_(
                  is_sents_unfinished_and_token_to_add_is_eos, cur_len
              )
              # unfinished_sents is set to zero if eos in sentence
              unfinished_sents.mul_((~eos_in_sents).long())
  
          # stop when there is a </s> in each sentence, or if we exceed the maximul length
          if unfinished_sents.max() == 0:
              break
  
          # extend attention_mask for new generated input if only decoder
          # if self.config.is_encoder_decoder is False:
          #     attention_mask = torch.cat(
          #         [attention_mask, attention_mask.new_ones((attention_mask.shape[0], 1))], dim=-1
          #     )
  
      return input_ids
  
file_path: fairseq/examples/MMPT/mmpt/models/mmfusionnlg.py
imports: import torch
  from torch.nn import functional
  from typing import Optional, Iterable
  from .mmfusion import MMFusion
  from .transformermodel import MMBertModel
  from ..modules import VideoTokenMLP
label_desc: Use image node_id 7 for calling the MMBertForNLG obj's underlying member method code with example usage: obj._generate_no_beam_search(input_ids, cur_len, max_length, min_length, do_sample, temperature, top_k, top_p, repetition_penalty, no_repeat_ngram_size, bad_words_ids, pad_token_id, eos_token_id, batch_size, attention_mask, use_cache, model_kwargs) and returns: input_ids