'''simple docstring'''






import argparse
from pathlib import Path

import fairseq
import torch
from fairseq.models.xmod import XMODModel as FairseqXmodModel
from packaging import version

from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('0.12.2'):
    raise Exception('requires fairseq >= 0.12.2')
if version.parse(fairseq.__version__) > version.parse('2'):
    raise Exception('requires fairseq < v2')

logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_	   =			logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_	   =			'Hello, World!'
SCREAMING_SNAKE_CASE_	   =			'en_XX'






def  UpperCamelCase__					(					_lowercase    :				str   ,    _lowercase    :				str   ,    _lowercase    :				bool     )							->	Optional[Any]:
  __UpperCAmelCase:					Tuple		= Path("""data_bin"""     )
  __UpperCAmelCase:					Dict		= FairseqXmodModel.from_pretrained(
      model_name_or_path=str(Path(_lowercase     ).parent     )   ,    checkpoint_file=Path(_lowercase     ).name   ,    _name="""xmod_base"""   ,    arch="""xmod_base"""   ,    task="""multilingual_masked_lm"""   ,    data_name_or_path=str(_lowercase     )   ,    bpe="""sentencepiece"""   ,    sentencepiece_model=str(Path(_lowercase     ).parent / """sentencepiece.bpe.model"""     )   ,    src_dict=str(data_dir / """dict.txt"""     )   ,    )
  xmod.eval()  # disable dropout
  print(_lowercase     )

  __UpperCAmelCase:					Optional[Any]		= xmod.model.encoder.sentence_encoder
  __UpperCAmelCase:					List[Any]		= XmodConfig(
      vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings   ,    hidden_size=xmod.cfg.model.encoder_embed_dim   ,    num_hidden_layers=xmod.cfg.model.encoder_layers   ,    num_attention_heads=xmod.cfg.model.encoder_attention_heads   ,    intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim   ,    max_position_embeddings=5_1_4   ,    type_vocab_size=1   ,    layer_norm_eps=1E-5   ,    pre_norm=xmod.cfg.model.encoder_normalize_before   ,    adapter_reduction_factor=getattr(xmod.cfg.model   ,    """bottleneck"""   ,    2     )   ,    adapter_layer_norm=xmod.cfg.model.adapter_layer_norm   ,    adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm   ,    ln_before_adapter=xmod.cfg.model.ln_before_adapter   ,    languages=xmod.cfg.model.languages   ,    )
  if classification_head:
    __UpperCAmelCase:					int		= xmod.model.classification_heads["""mnli"""].out_proj.weight.shape[0]

  print("""Our X-MOD config:"""   ,    _lowercase     )

  __UpperCAmelCase:					int		= XmodForSequenceClassification(_lowercase     ) if classification_head else XmodForMaskedLM(_lowercase     )
  model.eval()

  # Now let's copy all the weights.
  # Embeddings
  __UpperCAmelCase:					str		= xmod_sent_encoder.embed_tokens.weight
  __UpperCAmelCase:					Optional[Any]		= xmod_sent_encoder.embed_positions.weight
  __UpperCAmelCase:					str		= torch.zeros_like(
      model.roberta.embeddings.token_type_embeddings.weight     )  # just zero them out b/c xmod doesn't use them.

  __UpperCAmelCase:					str		= xmod_sent_encoder.layernorm_embedding.weight
  __UpperCAmelCase:					List[Any]		= xmod_sent_encoder.layernorm_embedding.bias

  for i in range(config.num_hidden_layers     ):
    # Encoder: start of layer
    __UpperCAmelCase:					List[Any]		= model.roberta.encoder.layer[i]
    __UpperCAmelCase:					List[str]		= xmod_sent_encoder.layers[i]

    # self attention
    __UpperCAmelCase:					List[str]		= layer.attention.self
    if not (
        xmod_layer.self_attn.k_proj.weight.data.shape
        == xmod_layer.self_attn.q_proj.weight.data.shape
        == xmod_layer.self_attn.v_proj.weight.data.shape
        == torch.Size((config.hidden_size, config.hidden_size)     )
    ):
      raise AssertionError("""Dimensions of self-attention weights do not match."""     )

    __UpperCAmelCase:					Union[str, Any]		= xmod_layer.self_attn.q_proj.weight
    __UpperCAmelCase:					Any		= xmod_layer.self_attn.q_proj.bias
    __UpperCAmelCase:					Optional[Any]		= xmod_layer.self_attn.k_proj.weight
    __UpperCAmelCase:					int		= xmod_layer.self_attn.k_proj.bias
    __UpperCAmelCase:					Dict		= xmod_layer.self_attn.v_proj.weight
    __UpperCAmelCase:					List[str]		= xmod_layer.self_attn.v_proj.bias

    # self-attention output
    __UpperCAmelCase:					str		= layer.attention.output
    if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape:
      raise AssertionError("""Dimensions of self-attention output weights do not match."""     )
    __UpperCAmelCase:					Dict		= xmod_layer.self_attn.out_proj.weight
    __UpperCAmelCase:					List[Any]		= xmod_layer.self_attn.out_proj.bias
    __UpperCAmelCase:					Union[str, Any]		= xmod_layer.self_attn_layer_norm.weight
    __UpperCAmelCase:					Optional[int]		= xmod_layer.self_attn_layer_norm.bias

    # intermediate
    __UpperCAmelCase:					Optional[Any]		= layer.intermediate
    if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape:
      raise AssertionError("""Dimensions of intermediate weights do not match."""     )
    __UpperCAmelCase:					Optional[Any]		= xmod_layer.fca.weight
    __UpperCAmelCase:					str		= xmod_layer.fca.bias

    # output
    __UpperCAmelCase:					str		= layer.output
    if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape:
      raise AssertionError("""Dimensions of feed-forward weights do not match."""     )
    __UpperCAmelCase:					Optional[int]		= xmod_layer.fca.weight
    __UpperCAmelCase:					int		= xmod_layer.fca.bias
    __UpperCAmelCase:					Optional[Any]		= xmod_layer.final_layer_norm.weight
    __UpperCAmelCase:					Any		= xmod_layer.final_layer_norm.bias
    if bert_output.adapter_layer_norm is not None:
      __UpperCAmelCase:					Optional[int]		= xmod_layer.adapter_layer_norm.weight
      __UpperCAmelCase:					Optional[int]		= xmod_layer.adapter_layer_norm.bias

    if sorted(bert_output.adapter_modules.keys()     ) != sorted(xmod_layer.adapter_modules.keys()     ):
      raise AssertionError("""Lists of language adapters do not match."""     )
    for lang_code, adapter in xmod_layer.adapter_modules.items():
      __UpperCAmelCase:					List[Any]		= bert_output.adapter_modules[lang_code]
      __UpperCAmelCase:					Optional[Any]		= xmod_layer.adapter_modules[lang_code]
      __UpperCAmelCase:					Dict		= from_adapter.fca.weight
      __UpperCAmelCase:					Optional[int]		= from_adapter.fca.bias
      __UpperCAmelCase:					Optional[Any]		= from_adapter.fca.weight
      __UpperCAmelCase:					Tuple		= from_adapter.fca.bias

    # end of layer

  if xmod_sent_encoder.layer_norm is not None:
    __UpperCAmelCase:					Dict		= xmod_sent_encoder.layer_norm.weight
    __UpperCAmelCase:					Optional[int]		= xmod_sent_encoder.layer_norm.bias

  if classification_head:
    __UpperCAmelCase:					Optional[int]		= xmod.model.classification_heads["""mnli"""].dense.weight
    __UpperCAmelCase:					List[Any]		= xmod.model.classification_heads["""mnli"""].dense.bias
    __UpperCAmelCase:					Union[str, Any]		= xmod.model.classification_heads["""mnli"""].out_proj.weight
    __UpperCAmelCase:					Optional[Any]		= xmod.model.classification_heads["""mnli"""].out_proj.bias
  else:
    # LM Head
    __UpperCAmelCase:					Tuple		= xmod.model.encoder.lm_head.dense.weight
    __UpperCAmelCase:					int		= xmod.model.encoder.lm_head.dense.bias
    __UpperCAmelCase:					Tuple		= xmod.model.encoder.lm_head.layer_norm.weight
    __UpperCAmelCase:					Any		= xmod.model.encoder.lm_head.layer_norm.bias
    __UpperCAmelCase:					List[Any]		= xmod.model.encoder.lm_head.weight
    __UpperCAmelCase:					List[Any]		= xmod.model.encoder.lm_head.bias

  # Let's check that we get the same results.
  __UpperCAmelCase:					Optional[Any]		= xmod.encode(_lowercase     ).unsqueeze(0     )  # batch of size 1
  model.roberta.set_default_language(_lowercase     )

  __UpperCAmelCase:					Dict		= model(_lowercase     )[0]
  if classification_head:
    __UpperCAmelCase:					List[str]		= xmod.model.classification_heads["""mnli"""](xmod.extract_features(_lowercase     )     )
  else:
    __UpperCAmelCase:					Union[str, Any]		= xmod.model(_lowercase   ,    lang_id=[SAMPLE_LANGUAGE]     )[0]
  print(our_output.shape   ,    their_output.shape     )
  __UpperCAmelCase:					Optional[int]		= torch.max(torch.abs(our_output - their_output     )     ).item()
  print(F'''max_absolute_diff = {max_absolute_diff}'''     )  # ~ 1e-7
  __UpperCAmelCase:					Optional[int]		= torch.allclose(_lowercase   ,    _lowercase   ,    atol=1E-3     )
  print("""Do both models output the same tensors?"""   ,    """🔥""" if success else """💩"""     )
  if not success:
    raise Exception("""Something went wRoNg"""     )

  Path(_lowercase     ).mkdir(parents=_lowercase   ,    exist_ok=_lowercase     )
  print(F'''Saving model to {pytorch_dump_folder_path}'''     )
  model.save_pretrained(_lowercase     )


if __name__ == "__main__":
    SCREAMING_SNAKE_CASE_	   =			argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--xmod_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
    )
    parser.add_argument(
        '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
    )
    parser.add_argument(
        '--classification_head', action='store_true', help='Whether to convert a final classification head.'
    )
    SCREAMING_SNAKE_CASE_	   =			parser.parse_args()
    convert_xmod_checkpoint_to_pytorch(
        args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
    )





'''simple docstring'''






import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


SCREAMING_SNAKE_CASE_	   =			get_logger(__name__)


SCREAMING_SNAKE_CASE_	   =			R'\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n'




class    a :



  """simple docstring"""







  @add_start_docstrings(snake_case_					)
  def __call__(							self   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    raise NotImplementedError(
        F'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''					)




class    a :



  """simple docstring"""







  @add_start_docstrings(snake_case_					)
  def __call__(							self   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    raise NotImplementedError(
        F'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''					)




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  @add_start_docstrings(snake_case_					)
  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_   ,    **snake_case_					):

    '''simple docstring'''







    for processor in self:
      __UpperCAmelCase:					str		= inspect.signature(processor.__call__					).parameters
      if len(snake_case_					) > 3:
        if not all(arg in kwargs for arg in list(function_args.keys()					)[2:]					):
          raise ValueError(
              F'''Make sure that all the required parameters: {list(function_args.keys()					)} for '''
              F'''{processor.__class__} are passed to the logits processor.'''					)
        __UpperCAmelCase:					List[Any]		= processor(snake_case_   ,    snake_case_   ,    snake_case_   ,    **snake_case_					)
      else:
        __UpperCAmelCase:					Optional[Any]		= processor(snake_case_   ,    snake_case_   ,    snake_case_					)
    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_					):

    '''simple docstring'''







    if not isinstance(snake_case_   ,    snake_case_					) or not (temperature > 0):
      raise ValueError(F'''`temperature` has to be a strictly positive float, but is {temperature}'''					)

    __UpperCAmelCase:					Any		= temperature







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Tuple		= scores / self.temperature
    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_ = -float("""Inf"""					)   ,    snake_case_ = 1					):

    '''simple docstring'''







    if not isinstance(snake_case_   ,    snake_case_					) or (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(snake_case_   ,    snake_case_					) 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}'''					)

    __UpperCAmelCase:					int		= top_p
    __UpperCAmelCase:					str		= filter_value
    __UpperCAmelCase:					List[Any]		= min_tokens_to_keep







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= lax.top_k(snake_case_   ,    scores.shape[-1]					)

    __UpperCAmelCase:					Tuple		= jnp.full_like(snake_case_   ,    self.filter_value					)
    __UpperCAmelCase:					Optional[int]		= jax.nn.softmax(snake_case_   ,    axis=-1					).cumsum(axis=-1					)
    __UpperCAmelCase:					List[str]		= cumulative_probs < self.top_p

    # include the token that is higher than top_p as well
    __UpperCAmelCase:					str		= jnp.roll(snake_case_   ,    1					)
    score_mask |= score_mask.at[:, 0].set(snake_case_					)

    # min tokens to keep
    __UpperCAmelCase:					str		= score_mask.at[:, : self.min_tokens_to_keep].set(snake_case_					)

    __UpperCAmelCase:					List[Any]		= jnp.where(snake_case_   ,    snake_case_   ,    snake_case_					)
    __UpperCAmelCase:					Optional[Any]		= jax.lax.sort_key_val(snake_case_   ,    snake_case_					)[-1]

    return next_scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_ = -float("""Inf"""					)   ,    snake_case_ = 1					):

    '''simple docstring'''







    if not isinstance(snake_case_   ,    snake_case_					) or top_k <= 0:
      raise ValueError(F'''`top_k` has to be a strictly positive integer, but is {top_k}'''					)

    __UpperCAmelCase:					Optional[Any]		= max(snake_case_   ,    snake_case_					)
    __UpperCAmelCase:					List[str]		= filter_value







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= scores.shape
    __UpperCAmelCase:					List[Any]		= jnp.full(batch_size * vocab_size   ,    self.filter_value					)

    __UpperCAmelCase:					Any		= min(self.top_k   ,    scores.shape[-1]					)  # Safety check
    __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= lax.top_k(snake_case_   ,    snake_case_					)
    __UpperCAmelCase:					Optional[Any]		= jnp.broadcast_to((jnp.arange(snake_case_					) * vocab_size)[:, None]   ,    (batch_size, topk)					).flatten()
    __UpperCAmelCase:					List[Any]		= topk_scores.flatten()
    __UpperCAmelCase:					str		= topk_indices.flatten() + shift

    __UpperCAmelCase:					List[Any]		= next_scores_flat.at[topk_indices_flat].set(snake_case_					)
    __UpperCAmelCase:					Any		= next_scores_flat.reshape(snake_case_   ,    snake_case_					)
    return next_scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					List[Any]		= bos_token_id







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					List[Any]		= jnp.full(scores.shape   ,    -float("""inf"""					)					)

    __UpperCAmelCase:					Optional[Any]		= 1 - jnp.bool_(cur_len - 1					)

    __UpperCAmelCase:					Any		= jnp.where(snake_case_   ,    new_scores.at[:, self.bos_token_id].set(0					)   ,    snake_case_					)

    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= max_length
    __UpperCAmelCase:					List[str]		= eos_token_id







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= jnp.full(scores.shape   ,    -float("""inf"""					)					)

    __UpperCAmelCase:					List[str]		= 1 - jnp.bool_(cur_len - self.max_length + 1					)

    __UpperCAmelCase:					Any		= jnp.where(snake_case_   ,    new_scores.at[:, self.eos_token_id].set(0					)   ,    snake_case_					)

    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    if not isinstance(snake_case_   ,    snake_case_					) or min_length < 0:
      raise ValueError(F'''`min_length` has to be a positive integer, but is {min_length}'''					)

    if not isinstance(snake_case_   ,    snake_case_					) or eos_token_id < 0:
      raise ValueError(F'''`eos_token_id` has to be a positive integer, but is {eos_token_id}'''					)

    __UpperCAmelCase:					List[Any]		= min_length
    __UpperCAmelCase:					Optional[int]		= eos_token_id







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= 1 - jnp.clip(cur_len - self.min_length   ,    0   ,    1					)

    __UpperCAmelCase:					int		= jnp.where(snake_case_   ,    scores.at[:, self.eos_token_id].set(-float("""inf"""					)					)   ,    snake_case_					)

    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= list(snake_case_					)
    __UpperCAmelCase:					Optional[Any]		= begin_index







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= 1 - jnp.bool_(cur_len - self.begin_index					)

    __UpperCAmelCase:					str		= jnp.where(snake_case_   ,    scores.at[:, self.begin_suppress_tokens].set(-float("""inf"""					)					)   ,    snake_case_					)

    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[Any]		= list(snake_case_					)







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= scores.at[..., self.suppress_tokens].set(-float("""inf"""					)					)

    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= dict(snake_case_					)
    # Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
    # index of the array corresponds to the index of the token to be forced, for XLA compatibility.
    # Indexes without forced tokens will have a negative value.
    __UpperCAmelCase:					Optional[Any]		= jnp.ones((max(force_token_map.keys()					) + 1)   ,    dtype=jnp.intaa					) * -1
    for index, token in force_token_map.items():
      if token is not None:
        __UpperCAmelCase:					Union[str, Any]		= force_token_array.at[index].set(snake_case_					)
    __UpperCAmelCase:					Union[str, Any]		= jnp.intaa(snake_case_					)







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    def _force_token(snake_case_					):
      __UpperCAmelCase:					List[Any]		= scores.shape[0]
      __UpperCAmelCase:					int		= self.force_token_array[generation_idx]

      __UpperCAmelCase:					Union[str, Any]		= jnp.ones_like(snake_case_   ,    dtype=scores.dtype					) * -float("""inf"""					)
      __UpperCAmelCase:					List[Any]		= jnp.zeros((batch_size, 1)   ,    dtype=scores.dtype					)
      __UpperCAmelCase:					List[Any]		= lax.dynamic_update_slice(snake_case_   ,    snake_case_   ,    (0, current_token)					)
      return new_scores

    __UpperCAmelCase:					Optional[int]		= lax.cond(
        cur_len >= self.force_token_array.shape[0]   ,    lambda: scores   ,    lambda: lax.cond(
            self.force_token_array[cur_len] >= 0   ,    lambda: _force_token(snake_case_					)   ,    lambda: scores   ,    )   ,    )
    return scores




class    a (       __lowerCAmelCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= generate_config.eos_token_id
    __UpperCAmelCase:					Union[str, Any]		= generate_config.no_timestamps_token_id
    __UpperCAmelCase:					Tuple		= generate_config.no_timestamps_token_id + 1

    __UpperCAmelCase:					Any		= decoder_input_length + 1

    if generate_config.is_multilingual:
      # room for language token and task token
      self.begin_index += 2
    if hasattr(snake_case_   ,    """max_initial_timestamp_index"""					):
      __UpperCAmelCase:					Optional[int]		= generate_config.max_initial_timestamp_index
    else:
      __UpperCAmelCase:					List[str]		= model_config.vocab_size
    if self.max_initial_timestamp_index is None:
      __UpperCAmelCase:					Any		= model_config.vocab_size







  def __call__(							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= scores.at[:, self.no_timestamps_token_id].set(-float("""inf"""					)					)

    def handle_pairs(snake_case_   ,    snake_case_					):
      __UpperCAmelCase:					Optional[int]		= jnp.where((cur_len - self.begin_index) >= 1   ,    snake_case_   ,    snake_case_					)
      __UpperCAmelCase:					Union[str, Any]		= jnp.where(
          input_ids_k[cur_len - 1] >= self.timestamp_begin   ,    True and last_was_timestamp   ,    snake_case_   ,    )

      __UpperCAmelCase:					Union[str, Any]		= jnp.where((cur_len - self.begin_index) < 2   ,    snake_case_   ,    snake_case_					)
      __UpperCAmelCase:					List[str]		= jnp.where(
          input_ids_k[cur_len - 2] >= self.timestamp_begin   ,    snake_case_   ,    snake_case_   ,    )

      return jnp.where(
          snake_case_   ,    jnp.where(
              penultimate_was_timestamp > 0   ,    scores_k.at[self.timestamp_begin :].set(-float("""inf"""					)					)   ,    scores_k.at[: self.eos_token_id].set(-float("""inf"""					)					)   ,    )   ,    snake_case_   ,    )

    __UpperCAmelCase:					Dict		= jax.vmap(snake_case_					)(snake_case_   ,    snake_case_					)

    __UpperCAmelCase:					Dict		= jnp.where(cur_len == self.begin_index   ,    snake_case_   ,    snake_case_					)
    __UpperCAmelCase:					List[Any]		= jnp.where(
        self.max_initial_timestamp_index is not None   ,    True and apply_max_initial_timestamp   ,    snake_case_   ,    )

    __UpperCAmelCase:					List[str]		= self.timestamp_begin + self.max_initial_timestamp_index

    __UpperCAmelCase:					List[str]		= jnp.where(
        snake_case_   ,    scores.at[:, last_allowed + 1 :].set(-float("""inf"""					)					)   ,    snake_case_   ,    )

    # if sum of probability over timestamps is above any other token, sample timestamp
    __UpperCAmelCase:					Union[str, Any]		= jax.nn.log_softmax(snake_case_   ,    axis=-1					)

    def handle_cumulative_probs(snake_case_   ,    snake_case_					):
      __UpperCAmelCase:					int		= jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]   ,    axis=-1					)
      __UpperCAmelCase:					Tuple		= jnp.max(logprobs_k[: self.timestamp_begin]					)
      return jnp.where(
          timestamp_logprob > max_text_token_logprob   ,    scores_k.at[: self.timestamp_begin].set(-float("""inf"""					)					)   ,    snake_case_   ,    )

    __UpperCAmelCase:					Tuple		= jax.vmap(snake_case_					)(snake_case_   ,    snake_case_					)

    return scores