


from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


UpperCamelCase								=	logging.get_logger(__name__)

UpperCamelCase								=	{
    """Helsinki-NLP/opus-mt-en-de""": """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json""",
    # See all Marian models at https://huggingface.co/models?filter=marian
}






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""
       snake_case      =    "marian"
       snake_case      =    ["past_key_values"]
       snake_case      =    {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}



       def __init__(      self				,       _SCREAMING_SNAKE_CASE=5_8101				,       _SCREAMING_SNAKE_CASE=None				,       _SCREAMING_SNAKE_CASE=1024				,       _SCREAMING_SNAKE_CASE=12				,       _SCREAMING_SNAKE_CASE=4096				,       _SCREAMING_SNAKE_CASE=16				,       _SCREAMING_SNAKE_CASE=12				,       _SCREAMING_SNAKE_CASE=4096				,       _SCREAMING_SNAKE_CASE=16				,       _SCREAMING_SNAKE_CASE=0.0				,       _SCREAMING_SNAKE_CASE=0.0				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE="gelu"				,       _SCREAMING_SNAKE_CASE=1024				,       _SCREAMING_SNAKE_CASE=0.1				,       _SCREAMING_SNAKE_CASE=0.0				,       _SCREAMING_SNAKE_CASE=0.0				,       _SCREAMING_SNAKE_CASE=0.0_2				,       _SCREAMING_SNAKE_CASE=5_8100				,       _SCREAMING_SNAKE_CASE=False				,       _SCREAMING_SNAKE_CASE=5_8100				,       _SCREAMING_SNAKE_CASE=0				,       _SCREAMING_SNAKE_CASE=0				,       _SCREAMING_SNAKE_CASE=True				,       **_SCREAMING_SNAKE_CASE				,       )->Union[str, Any]:




         '''simple docstring'''





         A_      :				str		     =					vocab_size
         A_      :				Any		     =					decoder_vocab_size or vocab_size
         A_      :				int		     =					max_position_embeddings
         A_      :				str		     =					d_model
         A_      :				List[Any]		     =					encoder_ffn_dim
         A_      :				int		     =					encoder_layers
         A_      :				List[Any]		     =					encoder_attention_heads
         A_      :				str		     =					decoder_ffn_dim
         A_      :				str		     =					decoder_layers
         A_      :				int		     =					decoder_attention_heads
         A_      :				Optional[Any]		     =					dropout
         A_      :				List[str]		     =					attention_dropout
         A_      :				str		     =					activation_dropout
         A_      :				Tuple		     =					activation_function
         A_      :				Any		     =					init_std
         A_      :				List[Any]		     =					encoder_layerdrop
         A_      :				Dict		     =					decoder_layerdrop
         A_      :				Any		     =					use_cache
         A_      :				Any		     =					encoder_layers
         A_      :				str		     =					scale_embedding  # scale factor will be sqrt(d_model) if True
         A_      :				Union[str, Any]		     =					share_encoder_decoder_embeddings
         super().__init__(
             pad_token_id=_SCREAMING_SNAKE_CASE				,       eos_token_id=_SCREAMING_SNAKE_CASE				,       is_encoder_decoder=_SCREAMING_SNAKE_CASE				,       decoder_start_token_id=_SCREAMING_SNAKE_CASE				,       forced_eos_token_id=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       @property
       # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
       def        _snake_case       (      self		)->Mapping[str, Mapping[int, str]]:




         '''simple docstring'''





         if self.task in ["default", "seq2seq-lm"]:
           A_      :				Optional[Any]		     =					OrderedDict(
               [
                   ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ]		)

           if self.use_past:
             A_      :				Union[str, Any]		     =					{0: '''batch'''}
             A_      :				Optional[Any]		     =					{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
           else:
             A_      :				int		     =					{0: '''batch''', 1: '''decoder_sequence'''}
             A_      :				Optional[int]		     =					{0: '''batch''', 1: '''decoder_sequence'''}

           if self.use_past:
             self.fill_with_past_key_values_(_SCREAMING_SNAKE_CASE				,       direction='''inputs'''		)
         elif self.task == "causal-lm":
           # TODO: figure this case out.
           A_      :				List[Any]		     =					OrderedDict(
               [
                   ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ]		)
           if self.use_past:
             A_     ,       A_      :				Optional[Any]		     =					self.num_layers
             for i in range(_SCREAMING_SNAKE_CASE		):
               A_      :				Optional[Any]		     =					{0: '''batch''', 2: '''past_sequence + sequence'''}
               A_      :				str		     =					{0: '''batch''', 2: '''past_sequence + sequence'''}
         else:
           A_      :				Tuple		     =					OrderedDict(
               [
                   ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                   ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
                   ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
               ]		)

         return common_inputs



       @property
       # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
       def        _snake_case       (      self		)->Mapping[str, Mapping[int, str]]:




         '''simple docstring'''





         if self.task in ["default", "seq2seq-lm"]:
           A_      :				Dict		     =					super().outputs
         else:
           A_      :				int		     =					super(_SCREAMING_SNAKE_CASE				,       self		).outputs
           if self.use_past:
             A_     ,       A_      :				Tuple		     =					self.num_layers
             for i in range(_SCREAMING_SNAKE_CASE		):
               A_      :				Union[str, Any]		     =					{0: '''batch''', 2: '''past_sequence + sequence'''}
               A_      :				List[Any]		     =					{0: '''batch''', 2: '''past_sequence + sequence'''}
         return common_outputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       )->Mapping[str, Any]:




         '''simple docstring'''





         A_      :				str		     =					self._generate_dummy_inputs_for_encoder_and_decoder(
             _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

         # Generate decoder inputs
         A_      :				List[Any]		     =					seq_length if not self.use_past else 1
         A_      :				Union[str, Any]		     =					self._generate_dummy_inputs_for_encoder_and_decoder(
             _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
         A_      :				Union[str, Any]		     =					dict(**_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)

         if self.use_past:
           if not is_torch_available():
             raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
           else:
             import torch
           A_     ,       A_      :				Any		     =					common_inputs['''input_ids'''].shape
           A_      :				int		     =					common_inputs['''decoder_input_ids'''].shape[1]
           A_     ,       A_      :				List[str]		     =					self.num_attention_heads
           A_      :				Tuple		     =					(
               batch,
               num_encoder_attention_heads,
               encoder_seq_length,
               self._config.hidden_size // num_encoder_attention_heads,
           )
           A_      :				Union[str, Any]		     =					decoder_seq_length + 3
           A_      :				str		     =					(
               batch,
               num_decoder_attention_heads,
               decoder_past_length,
               self._config.hidden_size // num_decoder_attention_heads,
           )

           A_      :				List[Any]		     =					torch.cat(
               [common_inputs['''decoder_attention_mask'''], torch.ones(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)]				,       dim=1		)

           A_      :				str		     =					[]
           # If the number of encoder and decoder layers are present in the model configuration, both are considered
           A_     ,       A_      :				str		     =					self.num_layers
           A_      :				List[str]		     =					min(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
           A_      :				Union[str, Any]		     =					max(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		) - min_num_layers
           A_      :				Any		     =					'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

           for _ in range(_SCREAMING_SNAKE_CASE		):
             common_inputs["past_key_values"].append(
                 (
                     torch.zeros(_SCREAMING_SNAKE_CASE		),
                     torch.zeros(_SCREAMING_SNAKE_CASE		),
                     torch.zeros(_SCREAMING_SNAKE_CASE		),
                     torch.zeros(_SCREAMING_SNAKE_CASE		),
                 )		)
           # TODO: test this.
           A_      :				List[Any]		     =					encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
           for _ in range(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
             common_inputs["past_key_values"].append((torch.zeros(_SCREAMING_SNAKE_CASE		), torch.zeros(_SCREAMING_SNAKE_CASE		))		)
         return common_inputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       )->Mapping[str, Any]:




         '''simple docstring'''





         A_      :				List[Any]		     =					self._generate_dummy_inputs_for_encoder_and_decoder(
             _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

         if self.use_past:
           if not is_torch_available():
             raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
           else:
             import torch
           A_     ,       A_      :				Optional[Any]		     =					common_inputs['''input_ids'''].shape
           # Not using the same length for past_key_values
           A_      :				Union[str, Any]		     =					seqlen + 2
           A_     ,       A_      :				Tuple		     =					self.num_layers
           A_     ,       A_      :				int		     =					self.num_attention_heads
           A_      :				Tuple		     =					(
               batch,
               num_encoder_attention_heads,
               past_key_values_length,
               self._config.hidden_size // num_encoder_attention_heads,
           )

           A_      :				Optional[Any]		     =					common_inputs['''attention_mask'''].dtype
           A_      :				int		     =					torch.cat(
               [common_inputs['''attention_mask'''], torch.ones(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       dtype=_SCREAMING_SNAKE_CASE		)]				,       dim=1		)
           A_      :				Union[str, Any]		     =					[
               (torch.zeros(_SCREAMING_SNAKE_CASE		), torch.zeros(_SCREAMING_SNAKE_CASE		)) for _ in range(_SCREAMING_SNAKE_CASE		)
           ]
         return common_inputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       )->Mapping[str, Any]:




         '''simple docstring'''





         A_      :				Dict		     =					compute_effective_axis_dimension(
             _SCREAMING_SNAKE_CASE				,       fixed_dimension=OnnxConfig.default_fixed_batch				,       num_token_to_add=0		)

         # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
         A_      :				List[str]		     =					tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					compute_effective_axis_dimension(
             _SCREAMING_SNAKE_CASE				,       fixed_dimension=OnnxConfig.default_fixed_sequence				,       num_token_to_add=_SCREAMING_SNAKE_CASE		)

         # Generate dummy inputs according to compute batch and sequence
         A_      :				List[Any]		     =					[''' '''.join([tokenizer.unk_token]		) * seq_length] * batch_size
         A_      :				str		     =					dict(tokenizer(_SCREAMING_SNAKE_CASE				,       return_tensors=_SCREAMING_SNAKE_CASE		)		)
         return common_inputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = -1				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       )->Mapping[str, Any]:




         '''simple docstring'''





         if self.task in ["default", "seq2seq-lm"]:
           A_      :				Dict		     =					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
               _SCREAMING_SNAKE_CASE				,       batch_size=_SCREAMING_SNAKE_CASE				,       seq_length=_SCREAMING_SNAKE_CASE				,       is_pair=_SCREAMING_SNAKE_CASE				,       framework=_SCREAMING_SNAKE_CASE		)

         else:
           A_      :				Optional[int]		     =					self._generate_dummy_inputs_for_causal_lm(
               _SCREAMING_SNAKE_CASE				,       batch_size=_SCREAMING_SNAKE_CASE				,       seq_length=_SCREAMING_SNAKE_CASE				,       is_pair=_SCREAMING_SNAKE_CASE				,       framework=_SCREAMING_SNAKE_CASE		)

         return common_inputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->Dict:




         '''simple docstring'''





         if self.task in ["default", "seq2seq-lm"]:
           A_      :				Dict		     =					super()._flatten_past_key_values_(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         else:
           A_      :				Optional[int]		     =					super(_SCREAMING_SNAKE_CASE				,       self		)._flatten_past_key_values_(
               _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)







       @property
       def        _snake_case       (      self		)->float:




         '''simple docstring'''





         return 1e-4








import unittest

import numpy as np

from transformers import is_flax_available
from transformers.testing_utils import require_flax

from ..test_modeling_flax_common import ids_tensor


if is_flax_available():
     import jax
     import jax.numpy as jnp

     from transformers.generation import (
         FlaxForcedBOSTokenLogitsProcessor,
         FlaxForcedEOSTokenLogitsProcessor,
         FlaxLogitsProcessorList,
         FlaxMinLengthLogitsProcessor,
         FlaxTemperatureLogitsWarper,
         FlaxTopKLogitsWarper,
         FlaxTopPLogitsWarper,
     )






@require_flax
class   _lowerCamelCase (					unittest.TestCase			):




       """simple docstring"""



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->List[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					jnp.ones((batch_size, length)		) / length
         return scores



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					None
         A_      :				Any		     =					20

         A_      :				Any		     =					self._get_uniform_logits(batch_size=2				,       length=_SCREAMING_SNAKE_CASE		)

         # tweak scores to not be uniform anymore
         A_      :				Dict		     =					scores.at[1, 5].set((1 / length) + 0.1		)  # peak, 1st batch
         A_      :				Tuple		     =					scores.at[1, 10].set((1 / length) - 0.4		)  # valley, 1st batch

         # compute softmax
         A_      :				List[str]		     =					jax.nn.softmax(_SCREAMING_SNAKE_CASE				,       axis=-1		)

         A_      :				Any		     =					FlaxTemperatureLogitsWarper(temperature=0.5		)
         A_      :				Optional[int]		     =					FlaxTemperatureLogitsWarper(temperature=1.3		)

         A_      :				Optional[Any]		     =					jax.nn.softmax(temp_dist_warper_sharper(_SCREAMING_SNAKE_CASE				,       scores.copy()				,       cur_len=_SCREAMING_SNAKE_CASE		)				,       axis=-1		)
         A_      :				List[Any]		     =					jax.nn.softmax(temp_dist_warper_smoother(_SCREAMING_SNAKE_CASE				,       scores.copy()				,       cur_len=_SCREAMING_SNAKE_CASE		)				,       axis=-1		)

         # uniform distribution stays uniform
         self.assertTrue(jnp.allclose(probs[0, :]				,       warped_prob_sharp[0, :]				,       atol=1e-3		)		)
         self.assertTrue(jnp.allclose(probs[0, :]				,       warped_prob_smooth[0, :]				,       atol=1e-3		)		)

         # sharp peaks get higher, valleys get lower
         self.assertLess(probs[1, :].max()				,       warped_prob_sharp[1, :].max()		)
         self.assertGreater(probs[1, :].min()				,       warped_prob_sharp[1, :].min()		)

         # smooth peaks get lower, valleys get higher
         self.assertGreater(probs[1, :].max()				,       warped_prob_smooth[1, :].max()		)
         self.assertLess(probs[1, :].min()				,       warped_prob_smooth[1, :].min()		)



       def        _snake_case       (      self		)->List[Any]:




         '''simple docstring'''





         A_      :				Any		     =					None
         A_      :				List[Any]		     =					10
         A_      :				str		     =					2

         # create ramp distribution
         A_      :				Any		     =					np.broadcast_to(np.arange(_SCREAMING_SNAKE_CASE		)[None, :]				,       (batch_size, vocab_size)		).copy()
         A_      :				List[Any]		     =					ramp_logits[1:, : vocab_size // 2] + vocab_size

         A_      :				Any		     =					FlaxTopKLogitsWarper(3		)

         A_      :				Tuple		     =					top_k_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # check that correct tokens are filtered
         self.assertListEqual(jnp.isinf(scores[0]		).tolist()				,       7 * [True] + 3 * [False]		)
         self.assertListEqual(jnp.isinf(scores[1]		).tolist()				,       2 * [True] + 3 * [False] + 5 * [True]		)

         # check special case
         A_      :				Optional[int]		     =					5
         A_      :				List[Any]		     =					FlaxTopKLogitsWarper(top_k=1				,       filter_value=0.0				,       min_tokens_to_keep=3		)

         A_      :				Optional[Any]		     =					np.broadcast_to(np.arange(_SCREAMING_SNAKE_CASE		)[None, :]				,       (batch_size, length)		).copy()
         A_      :				Dict		     =					top_k_warp_safety_check(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
         self.assertListEqual((scores == 0.0).sum(axis=-1		).tolist()				,       [2, 2]		)



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_      :				str		     =					None
         A_      :				Optional[Any]		     =					10
         A_      :				Any		     =					2

         # create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
         A_      :				Optional[int]		     =					np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.1_5, 0.3, 0.3, 0.2_5]]		)		)

         A_      :				str		     =					FlaxTopPLogitsWarper(0.8		)
         A_      :				Optional[int]		     =					np.exp(top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)		)

         # dist should be filtered to keep min num values so that sum is >= top_p
         # exp (-inf) => 0
         A_      :				Tuple		     =					np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.2_5]]		)
         self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       atol=1e-3		)		)

         # check edge cases with negative and extreme logits
         A_      :				Union[str, Any]		     =					np.broadcast_to(np.arange(_SCREAMING_SNAKE_CASE		)[None, :]				,       (batch_size, vocab_size)		).copy() - (
             vocab_size // 2
         )

         # make ramp_logits more extreme
         A_      :				str		     =					ramp_logits[1] * 1_0_0.0

         # make sure at least 2 tokens are kept
         A_      :				str		     =					FlaxTopPLogitsWarper(0.9				,       min_tokens_to_keep=2				,       filter_value=0.0		)
         A_      :				str		     =					top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
         self.assertListEqual((filtered_dist != 0.0).sum(axis=-1		).tolist()				,       [3, 2]		)



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_      :				str		     =					20
         A_      :				Union[str, Any]		     =					4
         A_      :				Optional[Any]		     =					0

         A_      :				Union[str, Any]		     =					FlaxMinLengthLogitsProcessor(min_length=10				,       eos_token_id=_SCREAMING_SNAKE_CASE		)

         # check that min length is applied at length 5
         A_      :				int		     =					ids_tensor((batch_size, 20)				,       vocab_size=20		)
         A_      :				List[Any]		     =					5
         A_      :				Optional[int]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					min_dist_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist()				,       4 * [-float('''inf'''		)]		)

         # check that min length is not applied anymore at length 15
         A_      :				Tuple		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					15
         A_      :				int		     =					min_dist_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertFalse(jnp.isinf(_SCREAMING_SNAKE_CASE		).any()		)



       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					20
         A_      :				Optional[int]		     =					4
         A_      :				Optional[int]		     =					0

         A_      :				Optional[Any]		     =					FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_SCREAMING_SNAKE_CASE		)

         # check that all scores are -inf except the bos_token_id score
         A_      :				Optional[Any]		     =					ids_tensor((batch_size, 1)				,       vocab_size=20		)
         A_      :				str		     =					1
         A_      :				List[str]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[str]		     =					logits_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :]		).all()		)
         self.assertListEqual(scores[:, bos_token_id].tolist()				,       4 * [0]		)  # score for bos_token_id shold be zero

         # check that bos_token_id is not forced if current length is greater than 1
         A_      :				Optional[int]		     =					3
         A_      :				List[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Tuple		     =					logits_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertFalse(jnp.isinf(_SCREAMING_SNAKE_CASE		).any()		)



       def        _snake_case       (      self		)->List[str]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					20
         A_      :				str		     =					4
         A_      :				Dict		     =					0
         A_      :				Optional[int]		     =					5

         A_      :				Tuple		     =					FlaxForcedEOSTokenLogitsProcessor(max_length=_SCREAMING_SNAKE_CASE				,       eos_token_id=_SCREAMING_SNAKE_CASE		)

         # check that all scores are -inf except the eos_token_id when max_length is reached
         A_      :				List[Any]		     =					ids_tensor((batch_size, 4)				,       vocab_size=20		)
         A_      :				Any		     =					4
         A_      :				Optional[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					logits_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :]		).all()		)
         self.assertListEqual(scores[:, eos_token_id].tolist()				,       4 * [0]		)  # score for eos_token_id should be zero

         # check that eos_token_id is not forced if max_length is not reached
         A_      :				int		     =					3
         A_      :				Union[str, Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					logits_processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         self.assertFalse(jnp.isinf(_SCREAMING_SNAKE_CASE		).any()		)



       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         A_      :				str		     =					4
         A_      :				Dict		     =					10
         A_      :				Union[str, Any]		     =					15
         A_      :				str		     =					2
         A_      :				int		     =					1
         A_      :				List[str]		     =					15

         # dummy input_ids and scores
         A_      :				Tuple		     =					ids_tensor((batch_size, sequence_length)				,       _SCREAMING_SNAKE_CASE		)
         A_      :				int		     =					input_ids.copy()

         A_      :				List[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					scores.copy()

         # instantiate all dist processors
         A_      :				Dict		     =					FlaxTemperatureLogitsWarper(temperature=0.5		)
         A_      :				Any		     =					FlaxTopKLogitsWarper(3		)
         A_      :				List[Any]		     =					FlaxTopPLogitsWarper(0.8		)

         # instantiate all logits processors
         A_      :				List[Any]		     =					FlaxMinLengthLogitsProcessor(min_length=10				,       eos_token_id=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					FlaxForcedEOSTokenLogitsProcessor(max_length=_SCREAMING_SNAKE_CASE				,       eos_token_id=_SCREAMING_SNAKE_CASE		)

         A_      :				Union[str, Any]		     =					10

         # no processor list
         A_      :				int		     =					temp_dist_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				List[str]		     =					top_k_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					min_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					bos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[Any]		     =					eos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # with processor list
         A_      :				Any		     =					FlaxLogitsProcessorList(
             [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]		)
         A_      :				List[str]		     =					processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # scores should be equal
         self.assertTrue(jnp.allclose(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       atol=1e-3		)		)

         # input_ids should never be changed
         self.assertListEqual(input_ids.tolist()				,       input_ids_comp.tolist()		)







       def        _snake_case       (      self		)->Dict:




         '''simple docstring'''





         A_      :				str		     =					4
         A_      :				Dict		     =					10
         A_      :				Tuple		     =					15
         A_      :				List[str]		     =					2
         A_      :				List[str]		     =					1
         A_      :				Union[str, Any]		     =					15

         # dummy input_ids and scores
         A_      :				Any		     =					ids_tensor((batch_size, sequence_length)				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					input_ids.copy()

         A_      :				Optional[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Tuple		     =					scores.copy()

         # instantiate all dist processors
         A_      :				List[str]		     =					FlaxTemperatureLogitsWarper(temperature=0.5		)
         A_      :				Optional[Any]		     =					FlaxTopKLogitsWarper(3		)
         A_      :				int		     =					FlaxTopPLogitsWarper(0.8		)

         # instantiate all logits processors
         A_      :				List[Any]		     =					FlaxMinLengthLogitsProcessor(min_length=10				,       eos_token_id=_SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[Any]		     =					FlaxForcedEOSTokenLogitsProcessor(max_length=_SCREAMING_SNAKE_CASE				,       eos_token_id=_SCREAMING_SNAKE_CASE		)

         A_      :				str		     =					10

         # no processor list
         def run_no_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
           A_      :				int		     =					temp_dist_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Optional[Any]		     =					top_k_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				List[Any]		     =					top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Dict		     =					min_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Any		     =					bos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Optional[Any]		     =					eos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           return scores

         # with processor list
         def run_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
           A_      :				Optional[int]		     =					FlaxLogitsProcessorList(
               [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]		)
           A_      :				Optional[int]		     =					processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           return scores

         A_      :				Optional[int]		     =					jax.jit(_SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					jax.jit(_SCREAMING_SNAKE_CASE		)

         A_      :				Dict		     =					jitted_run_no_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					jitted_run_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

         # scores should be equal
         self.assertTrue(jnp.allclose(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       atol=1e-3		)		)

         # input_ids should never be changed
         self.assertListEqual(input_ids.tolist()				,       input_ids_comp.tolist()		)




