import json import copy import numpy as np from functools import cached_property import math from typing import Optional, Tuple, Union, List, Dict, Sequence, Any import random import torch from torch import nn import torch.distributed as dist from torch.nn import CrossEntropyLoss import torch.nn.functional as F import torch.utils.checkpoint from transformers.generation.logits_process import ( LogitsProcessor, TopKLogitsWarper, ) from transformers.generation.logits_process import LogitsWarper from transformers.generation import PrefixConstrainedLogitsProcessor import time def check_eol_in_multitokens(tokenlen, new_pred_tokenlen, line_len): L, R = (tokenlen + 1), (tokenlen + new_pred_tokenlen) check_interval_l = L // line_len + 1 if L % line_len != 0 else L // line_len check_interval_r = R // line_len return (check_interval_l <= check_interval_r) def get_eol_in_multitokens(logits, eol_cls, tokenlen, new_pred_tokenlen, line_len, min_dtype=-math.inf): logits_forced_eol = logits.clone() # torch.argmax(logits[:,-3]) L, R = (tokenlen + 1), (tokenlen + new_pred_tokenlen) check_interval_l = L // line_len + 1 if L % line_len != 0 else L // line_len check_interval_r = R // line_len eol_position_ids = [ line_len * multi_num - (tokenlen + 1) for multi_num in range(check_interval_l, check_interval_r + 1) ] for i in eol_position_ids: logits_forced_eol[..., i, :] = min_dtype logits_forced_eol[..., i, eol_cls] = 0 return logits_forced_eol, eol_position_ids def get_eol_in_multitokens_with_cache_position(logits, eol_cls, tokenlen, new_pred_tokenlen, line_len, cache_position, min_dtype=-math.inf): logits_forced_eol = logits.clone() # torch.argmax(logits[:,-3]) L, R = (tokenlen + 1), (tokenlen + new_pred_tokenlen) check_interval_l = L // line_len + 1 if L % line_len != 0 else L // line_len check_interval_r = R // line_len eol_position_ids = [ line_len * multi_num - (tokenlen + 1) for multi_num in range(check_interval_l, check_interval_r + 1) ] cache_position_line = torch.unique(cache_position) for i in eol_position_ids: assert i < len(cache_position_line) matching_indices = torch.where(cache_position == cache_position_line[i])[0] # logits_forced_eol[..., i, :] = min_dtype # logits_forced_eol[..., i, eol_cls] = 0 logits_forced_eol[..., matching_indices, :] = min_dtype logits_forced_eol[..., matching_indices, eol_cls] = 0 return logits_forced_eol, eol_position_ids class MultiTokensVLLogitsProcessor(LogitsProcessor): def __init__( self, image_start_token_id=None, image_end_token_id=None, image_next_line_token_id=None, patch_size=None, voc_size=None, device = 'cpu', ): self.image_start_token_id = image_start_token_id # 8197 self.image_end_token_id = image_end_token_id # 8196 self.image_next_line_token_id = image_next_line_token_id # 8803 self.image_start_token_id_index = None self.patch_size = patch_size self.h_latent_dim = None self.w_latent_dim = None self.vocab_list = [i for i in range(voc_size)] self.image_token_list = [i for i in range(4, 8195 + 1)] self.suppress_tokens = torch.tensor( [x for x in self.vocab_list if x not in self.image_token_list], device=device ) self.vocab_tensor = torch.arange(voc_size, device=device) self.suppress_token_mask = torch.isin(self.vocab_tensor, self.suppress_tokens) # not [ 4, 5, 6, ..., 8193, 8194, 8195] self.new_line_force_token_mask = torch.isin( self.vocab_tensor, torch.tensor([self.image_next_line_token_id], device=device) ) self.eos_image_force_token_mask = torch.isin( self.vocab_tensor, torch.tensor([self.image_end_token_id], device=device) ) self.flag = False self.num_image_start_tokens = None self.num_image_end_tokens = None # @add_start_docstrings(LOGITS_PROCESSOR_INPUTS_DOCSTRING) def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: self.num_image_start_tokens = (input_ids[0] == self.image_start_token_id).sum() self.num_image_end_tokens = (input_ids[0] == self.image_end_token_id).sum() if self.num_image_start_tokens == self.num_image_end_tokens: self.h_latent_dim, self.w_latent_dim = None, None self.image_start_token_id_index = None return scores elif self.num_image_start_tokens == self.num_image_end_tokens + 1: if self.image_start_token_id_index is None: self.image_start_token_id_index = torch.where(input_ids[0] == self.image_start_token_id)[0] self.image_start_token_id_index = torch.where(input_ids[0] == self.image_start_token_id)[0][-1].item() new_logit_token_len = scores.shape[-2] if len(scores.shape) >= 3 else 1 new_token_num = len(input_ids[0][self.image_start_token_id_index + 1 :]) if new_token_num >= 2: pad_eol_len = 1 # TODO: to check if self.h_latent_dim is None or self.w_latent_dim is None: h_grids, w_grids = ( input_ids[0][self.image_start_token_id_index + 1] - 8804, input_ids[0][self.image_start_token_id_index + 2] - 8804, ) self.h_latent_dim, self.w_latent_dim = h_grids * 2, w_grids * 2 print('self.h_latent_dim, self.w_latent_dim', self.h_latent_dim, self.w_latent_dim) tokens = input_ids[0][self.image_start_token_id_index + 3 :] is_new_seq_ids_containing_end_of_line = check_eol_in_multitokens( len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len ) is_new_seq_ids_containing_end_of_img = check_eol_in_multitokens( len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len ) # TODO: is_pre_seq_containing_end_of_img: scores = torch.where( self.suppress_token_mask.to(scores.device), -float("inf"), scores ) # containing ONE end-of-line if is_new_seq_ids_containing_end_of_line: scores, eol_position_ids = get_eol_in_multitokens( scores, self.image_next_line_token_id, len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len ) # containing ONE end-of-image if is_new_seq_ids_containing_end_of_img: scores, eol_position_ids = get_eol_in_multitokens( scores, self.image_end_token_id, len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len, ) return scores else: print(f"Something wrong in the decoding process. MultiTokensVLLogitsProcessor. \ st: id {torch.where(input_ids[0] == self.image_start_token_id)} num {self.num_image_start_tokens} \ ed: id {torch.where(input_ids[0] == self.image_end_token_id)} num {self.num_image_end_tokens} \ input_ids.shape {input_ids.shape} scores.shape {scores.shape} " ) return scores class MultiTreeTokensVLLogitsProcessor(LogitsProcessor): def __init__( self, image_start_token_id=None, image_end_token_id=None, image_next_line_token_id=None, patch_size=None, voc_size=None, device = 'cpu', ): self.image_start_token_id = image_start_token_id # 8197 self.image_end_token_id = image_end_token_id # 8196 self.image_next_line_token_id = image_next_line_token_id # 8803 self.image_start_token_id_index = None self.patch_size = patch_size self.h_latent_dim = None self.w_latent_dim = None self.vocab_list = [i for i in range(voc_size)] self.image_token_list = [i for i in range(4, 8195 + 1)] self.suppress_tokens = torch.tensor( [x for x in self.vocab_list if x not in self.image_token_list], device=device ) self.vocab_tensor = torch.arange(voc_size, device=device) self.suppress_token_mask = torch.isin(self.vocab_tensor, self.suppress_tokens) # not [ 4, 5, 6, ..., 8193, 8194, 8195] self.new_line_force_token_mask = torch.isin( self.vocab_tensor, torch.tensor([self.image_next_line_token_id], device=device) ) self.eos_image_force_token_mask = torch.isin( self.vocab_tensor, torch.tensor([self.image_end_token_id], device=device) ) self.flag = False self.num_image_start_tokens = None self.num_image_end_tokens = None self.cache_position = None # @add_start_docstrings(LOGITS_PROCESSOR_INPUTS_DOCSTRING) def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: self.num_image_start_tokens = (input_ids[0] == self.image_start_token_id).sum() self.num_image_end_tokens = (input_ids[0] == self.image_end_token_id).sum() if self.num_image_start_tokens == self.num_image_end_tokens: self.h_latent_dim, self.w_latent_dim = None, None self.image_start_token_id_index = None return scores elif self.num_image_start_tokens == self.num_image_end_tokens + 1: if self.image_start_token_id_index is None: self.image_start_token_id_index = torch.where(input_ids[0] == self.image_start_token_id)[0] self.image_start_token_id_index = torch.where(input_ids[0] == self.image_start_token_id)[0][-1].item() new_logit_token_len = scores.shape[-2] if len(scores.shape) >= 3 else 1 new_token_num = len(input_ids[0][self.image_start_token_id_index + 1 :]) if new_token_num >= 2: pad_eol_len = 1 # TODO: to check if self.h_latent_dim is None or self.w_latent_dim is None: h_grids, w_grids = ( input_ids[0][self.image_start_token_id_index + 1] - 8804, input_ids[0][self.image_start_token_id_index + 2] - 8804, ) self.h_latent_dim, self.w_latent_dim = h_grids * 2, w_grids * 2 print('self.h_latent_dim, self.w_latent_dim', self.h_latent_dim, self.w_latent_dim) tokens = input_ids[0][self.image_start_token_id_index + 3 :] if self.cache_position is None: is_new_seq_ids_containing_end_of_line = check_eol_in_multitokens( len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len ) is_new_seq_ids_containing_end_of_img = check_eol_in_multitokens( len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len ) # TODO: is_pre_seq_containing_end_of_img: scores = torch.where( self.suppress_token_mask.to(scores.device), -float("inf"), scores ) # containing ONE end-of-line if is_new_seq_ids_containing_end_of_line: scores, eol_position_ids = get_eol_in_multitokens( scores, self.image_next_line_token_id, len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len ) # containing ONE end-of-image if is_new_seq_ids_containing_end_of_img: scores, eol_position_ids = get_eol_in_multitokens( scores, self.image_end_token_id, len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len, ) else: new_logit_token_len = self.cache_position.unique().shape[0] is_new_seq_ids_containing_end_of_line = check_eol_in_multitokens( len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len ) is_new_seq_ids_containing_end_of_img = check_eol_in_multitokens( len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len ) # TODO: is_pre_seq_containing_end_of_img: scores = torch.where( self.suppress_token_mask.to(scores.device), -float("inf"), scores ) # containing ONE end-of-line if is_new_seq_ids_containing_end_of_line: scores, eol_position_ids = get_eol_in_multitokens_with_cache_position( scores, self.image_next_line_token_id, len(tokens), new_logit_token_len, self.w_latent_dim + pad_eol_len, self.cache_position ) # containing ONE end-of-image if is_new_seq_ids_containing_end_of_img: scores, eol_position_ids = get_eol_in_multitokens_with_cache_position( scores, self.image_end_token_id, len(tokens), new_logit_token_len, (self.w_latent_dim + pad_eol_len) * self.h_latent_dim + pad_eol_len, self.cache_position ) return scores else: print(f"Something wrong in the decoding process. MultiTokensVLLogitsProcessor. \ st: id {torch.where(input_ids[0] == self.image_start_token_id)} num {self.num_image_start_tokens} \ ed: id {torch.where(input_ids[0] == self.image_end_token_id)} num {self.num_image_end_tokens} \ input_ids.shape {input_ids.shape} scores.shape {scores.shape} " ) return scores class MultiTokensInterleavedTopKLogitsWarper(LogitsWarper): r""" [`LogitsWarper`] that performs top-k, i.e. restricting to the k highest probability elements. Often used together with [`TemperatureLogitsWarper`] and [`TopPLogitsWarper`]. """ def __init__( self, image_top_k: int, text_top_k: int, image_start_token_id=None, image_end_token_id=None, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1, ): if not isinstance(text_top_k, int) or text_top_k <= 0: raise ValueError(f"`text_top_k` has to be a strictly positive integer, but is {text_top_k}") if not isinstance(image_top_k, int) or text_top_k <= 0: raise ValueError(f"`image_top_k` has to be a strictly positive integer, but is {image_top_k}") self.image_top_k = max(image_top_k, min_tokens_to_keep) self.text_top_k = max(text_top_k, min_tokens_to_keep) self.filter_value = filter_value self.image_start_token_id = image_start_token_id self.image_end_token_id = image_end_token_id self.flag = False self.num_image_start_tokens = None self.num_image_end_tokens = None # @add_start_docstrings(LOGITS_PROCESSOR_INPUTS_DOCSTRING) def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: self.num_image_start_tokens = (input_ids[0] == self.image_start_token_id).sum() self.num_image_end_tokens = (input_ids[0] == self.image_end_token_id).sum() if self.num_image_start_tokens == self.num_image_end_tokens + 1: top_k = min(self.image_top_k, scores.size(-1)) else: top_k = min(self.text_top_k, scores.size(-1)) # Safety check # Remove all tokens with a probability less than the last token of the top-k indices_to_remove = scores < torch.topk(scores, top_k)[0][..., -1, None] scores_processed = scores.masked_fill(indices_to_remove, self.filter_value) return scores_processed class AllowOnlyTokensAtRelativeOffsetLogitsProcessor3d(LogitsProcessor): r""" [`AllowOnlyTokensAtRelativeOffsetLogitsProcessor`] suppresses the logits of tokens aside from a specific set of tokens that can be generated at a relative offset from a trigger token (e.g. begin image token). If `exclusive` is set to `True`, the set of tokens allowed at this offset will not be allowed anywhere else. This is useful for enforcing multimodal generation constraints with begin and end marker tokens. Originally created for [Chameleon](https://huggingface.co/docs/transformers/model_doc/chameleon). Args: trigger_token_id (`int`): The token id that triggers the offset check. allowed_token_ids (`List[int]`): The list of token ids that are allowed at the specified offset. offset (`int`): The relative offset from the trigger token. exclusive (`bool`, *optional*, defaults to `False`): If `True`, the set of tokens allowed at this offset will not be allowed anywhere else. device (`str`, *optional*, defaults to `cpu`): The device to allocate the util tensor on. """ def __init__( self, trigger_token_id: int, allowed_token_ids: List[int], offset: int, exclusive: bool = False, device: str = "cpu", ): self.trigger_token_id = trigger_token_id self.allowed_token_ids = torch.tensor(allowed_token_ids, device=device) self.offset = offset self.exclusive = exclusive def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: if input_ids.shape[1] < self.offset and not self.exclusive: return scores disallowed_tokens_mask = torch.ones_like(scores, dtype=torch.bool) disallowed_tokens_mask[..., self.allowed_token_ids] = False if input_ids.shape[1] < self.offset: return scores.masked_fill(~disallowed_tokens_mask, torch.finfo(scores.dtype).min) trigger_positions = (input_ids[..., -self.offset] == self.trigger_token_id).unsqueeze(-1) if self.exclusive: return scores.masked_fill(~(disallowed_tokens_mask ^ trigger_positions), torch.finfo(scores.dtype).min) return scores.masked_fill(disallowed_tokens_mask & trigger_positions, torch.finfo(scores.dtype).min) class SuppressTokensInIndexRangeLogitsProcessor3d(LogitsProcessor): r""" [`SuppressTokensInIndexRangeLogitsProcessor`] supresses a list of tokens from `start_index` to `end_index` (exclusive) Args: suppress_tokens (`List[int]`): List of token ids to suppress during generation. start_index (`int`): The index at which to start suppressing tokens. end_index (`int`, *optional*): The index at which to end suppressing tokens. If `None`, it will suppress tokens indefinitely. device (`str`, *optional*, defaults to `"cpu"`): The device to allocate the tensors. """ def __init__( self, suppress_tokens: List[int], start_index: int, end_index: Optional[int] = None, device: str = "cpu" ): self.suppress_tokens = torch.tensor(suppress_tokens, device=device) self.start_index = start_index self.end_index = end_index if end_index is not None else math.inf def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: current_index = input_ids.shape[1] if self.start_index > current_index or current_index > self.end_index: return scores suppress_tokens_mask = torch.zeros_like(scores, dtype=torch.bool) suppress_tokens_mask[..., self.suppress_tokens] = True return scores.masked_fill(suppress_tokens_mask, torch.finfo(scores.dtype).min) class AllowOnlyTokensInRelativeWindowLogitsProcessor3d(LogitsProcessor): r""" [`AllowOnlyTokensInRelativeWindowLogitsProcessor`] suppresses the logits of tokens aside from a specific set of tokens that can be generated at a relative window from a trigger token (e.g. begin image token). If `exclusive` is set to `True`, the set of tokens allowed at this window will not be allowed anywhere else. This is useful for enforcing multimodal generation constraints. Originally created for [Chameleon](https://huggingface.co/docs/transformers/model_doc/chameleon). Args: trigger_token_id (`int`): The token id that triggers the window check. allowed_token_ids (`List[int]`): The list of token ids that are allowed at the specified relative window. window_width (`int`): The window_width of the window from the trigger token. exclusive (`bool`, *optional*, defaults to `False`): If `True`, the set of tokens allowed at this window will not be allowed anywhere else. device (`str`, *optional*, defaults to `cpu`): The device to allocate the util tensor on. """ def __init__( self, trigger_token_id: int, allowed_token_ids: List[int], window_width: int, exclusive: bool = False, device: str = "cpu", ): self.trigger_token_id = trigger_token_id self.allowed_token_ids = torch.tensor(allowed_token_ids, device=device).unsqueeze(0) self.window_width = window_width self.exclusive = exclusive def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: window_width = min(self.window_width, input_ids.shape[1]) trigger_positions = (input_ids[..., -window_width:] == self.trigger_token_id).any(dim=1).unsqueeze(-1) disallowed_tokens_mask = torch.ones_like(scores, dtype=torch.bool) disallowed_tokens_mask[..., self.allowed_token_ids] = False if self.exclusive: return scores.masked_fill( ~(disallowed_tokens_mask ^ trigger_positions), torch.finfo(scores.dtype).min, ) return scores.masked_fill( disallowed_tokens_mask & trigger_positions, torch.finfo(scores.dtype).min, ) class SuppressTokensAtBeginLogitsProcessor3d(SuppressTokensInIndexRangeLogitsProcessor3d): def __init__(self, begin_suppress_tokens, begin_index, device: str = "cpu"): super().__init__(begin_suppress_tokens, begin_index, begin_index + 1, device=device) self.begin_index = begin_index def set_begin_index(self, begin_index): self.start_index = begin_index self.end_index = begin_index + 1 # Keeping this here for backwards compatibility self.begin_index = begin_index class SuppressTokensLogitsProcessor3d(SuppressTokensInIndexRangeLogitsProcessor3d): def __init__(self, suppress_tokens, device: str = "cpu"): super().__init__(suppress_tokens, 0, device=device) class TopPLogitsWarper3d(LogitsProcessor): """ [`LogitsProcessor`] that performs top-p, i.e. restricting to top tokens summing to prob_cut_off <= prob_cut_off. Often used together with [`TemperatureLogitsWarper`] and [`TopKLogitsWarper`]. Args: top_p (`float`): If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or higher are kept for generation. filter_value (`float`, *optional*, defaults to -inf): All filtered values will be set to this float value. min_tokens_to_keep (`int`, *optional*, defaults to 1): Minimum number of tokens that cannot be filtered. Examples: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With `top_p` sampling, the output gets restricted to high-probability tokens. >>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range. >>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` """ def __init__(self, top_p: float, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1): top_p = float(top_p) if top_p < 0 or top_p > 1.0: raise ValueError(f"`top_p` has to be a float > 0 and < 1, but is {top_p}") if not isinstance(min_tokens_to_keep, int) or (min_tokens_to_keep < 1): raise ValueError(f"`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}") self.top_p = top_p self.filter_value = filter_value self.min_tokens_to_keep = min_tokens_to_keep def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: sorted_logits, sorted_indices = torch.sort(scores, descending=False) cumulative_probs = sorted_logits.softmax(dim=-1).cumsum(dim=-1) # Remove tokens with cumulative top_p above the threshold (token with 0 are kept) sorted_indices_to_remove = cumulative_probs <= (1 - self.top_p) # Keep at least min_tokens_to_keep sorted_indices_to_remove[..., -self.min_tokens_to_keep :] = 0 # scatter sorted tensors to original indexing indices_to_remove = sorted_indices_to_remove.scatter(-1, sorted_indices, sorted_indices_to_remove) # indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove) scores_processed = scores.masked_fill(indices_to_remove, self.filter_value) return scores_processed def get_double_cfg_input_ids(input_ids, neg_input_ids, pad_category): batchsize, prefill_num = input_ids.shape neg_prefill_num = neg_input_ids.shape[1] batchsize_cfg = 2 * batchsize max_prefill_num = max(prefill_num, neg_prefill_num) new_neg_input_ids = torch.full( (batchsize_cfg, max_prefill_num), pad_category, dtype=input_ids.dtype, device=input_ids.device ) new_neg_input_ids[:batchsize, -input_ids.shape[1]:] = input_ids new_neg_input_ids[batchsize:, -neg_input_ids.shape[1]:] = neg_input_ids return new_neg_input_ids def multinomial_token_sample(logits, generator=None): probs = nn.functional.softmax(logits, dim=-1) # TODO (joao): this OP throws "skipping cudagraphs due to ['incompatible ops']", find solution probs_shape = None if len(probs.shape) >= 3: probs_shape = probs.shape probs = probs.flatten(0, len(probs_shape)-2) next_tokens = torch.multinomial(probs, num_samples=1, generator=generator).squeeze(1) if probs_shape is not None: next_tokens = next_tokens.reshape(probs_shape[:-1]) probs = probs.reshape(probs_shape) return next_tokens, probs class SequenceSegmentDecomposer(LogitsProcessor): def __init__(self, sublogit_processors: List[LogitsProcessor], do_sample: bool = True, seed=None, fix_logits=True): self.sublogit_processors = sublogit_processors self.do_sample = do_sample self.generator = torch.Generator(seed) if seed is not None else None self.fix_logits = fix_logits def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: scores_processed = [] # a = time.time() while len(scores.shape) < 3: scores = scores.unsqueeze(1) B, L, V = scores.shape input_ids_candidates = input_ids.new_empty(B, input_ids.shape[1] + scores.shape[1]) input_ids_candidates[:, :input_ids.shape[1]] = input_ids for seq_id in range(L): next_score = scores[:, seq_id, :] input_ids_cum = input_ids_candidates[:, :input_ids.shape[1] + seq_id] for sublogit_processor in self.sublogit_processors: next_score = sublogit_processor(input_ids_cum, next_score) if self.do_sample: next_token, _ = multinomial_token_sample( next_score, self.generator, ) else: next_token = torch.argmax(next_score, dim=-1) while len(next_token.shape) < 2: next_token = next_token.unsqueeze(1) input_ids_candidates[:, input_ids.shape[1] + seq_id] = next_token.squeeze(1) if self.fix_logits: # the beam search should condition on fixed tokens, cannot sample the logits again # so mask all logits in `next_score` to -inf instead of `next_token` new_next_score = torch.full_like(next_score, -math.inf) # sampled_logits = torch.gather(next_score, 1, next_token) # new_next_score.scatter_(1, next_token, sampled_logits) new_next_score.scatter_(1, next_token, 0) # reduce='multiply' else: new_next_score = next_score scores_processed.append(new_next_score) scores_processed = torch.stack(scores_processed, dim=1) del input_ids_candidates # print(f"Time: {time.time() - a}") return scores_processed def gather_from_split_tensors( tensor_list, indexes, dim=0, prefilled_length=0, device='cuda', ): """ indexes: tensor of indexes """ cum_lengths = [prefilled_length, ] + [t.shape[dim] for t in tensor_list] cum_lengths = torch.tensor(cum_lengths, device=device).cumsum(0) gathered_tensor = [] for i, t in enumerate(tensor_list): # print(cum_lengths, indexes, i, t.shape) relative_indexes = indexes[ (indexes >= cum_lengths[i]) & (indexes < cum_lengths[i + 1]) ] - cum_lengths[i] selected_tensor = torch.index_select(t, dim=dim, index=relative_indexes, out=None) gathered_tensor.append(selected_tensor) gathered_tensor = torch.cat(gathered_tensor, dim=dim) return gathered_tensor