


import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import SwiftFormerForImageClassification, SwiftFormerModel
     from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import ViTImageProcessor






class   _lowerCamelCase :




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE=13				,       _SCREAMING_SNAKE_CASE=3				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=0.1				,       _SCREAMING_SNAKE_CASE=0.1				,       _SCREAMING_SNAKE_CASE=224				,       _SCREAMING_SNAKE_CASE=1000				,       _SCREAMING_SNAKE_CASE=[3, 3, 6, 4]				,       _SCREAMING_SNAKE_CASE=[48, 56, 112, 220]				,       )->Optional[int]:




         '''simple docstring'''





         A_      :				str		     =					parent
         A_      :				List[Any]		     =					batch_size
         A_      :				List[str]		     =					num_channels
         A_      :				Any		     =					is_training
         A_      :				List[Any]		     =					use_labels
         A_      :				int		     =					hidden_dropout_prob
         A_      :				List[str]		     =					attention_probs_dropout_prob
         A_      :				str		     =					num_labels
         A_      :				List[Any]		     =					image_size
         A_      :				Dict		     =					layer_depths
         A_      :				int		     =					embed_dims



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




         '''simple docstring'''





         A_      :				Tuple		     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

         A_      :				List[Any]		     =					None
         if self.use_labels:
           A_      :				str		     =					ids_tensor([self.batch_size]				,       self.num_labels		)

         A_      :				Optional[Any]		     =					self.get_config()

         return config, pixel_values, labels



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         return SwiftFormerConfig(
             depths=self.layer_depths				,       embed_dims=self.embed_dims				,       mlp_ratio=4				,       downsamples=[True, True, True, True]				,       hidden_act='''gelu'''				,       num_labels=self.num_labels				,       down_patch_size=3				,       down_stride=2				,       down_pad=1				,       drop_rate=0.0				,       drop_path_rate=0.0				,       use_layer_scale=_SCREAMING_SNAKE_CASE				,       layer_scale_init_value=1e-5				,       )



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




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					SwiftFormerModel(config=_SCREAMING_SNAKE_CASE		)
         model.to(_SCREAMING_SNAKE_CASE		)
         model.eval()
         A_      :				List[Any]		     =					model(_SCREAMING_SNAKE_CASE		)
         self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.embed_dims[-1], 7, 7)		)



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




         '''simple docstring'''





         A_      :				Optional[Any]		     =					self.num_labels
         A_      :				Tuple		     =					SwiftFormerForImageClassification(_SCREAMING_SNAKE_CASE		)
         model.to(_SCREAMING_SNAKE_CASE		)
         model.eval()
         A_      :				Optional[Any]		     =					model(_SCREAMING_SNAKE_CASE				,       labels=_SCREAMING_SNAKE_CASE		)
         self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)		)

         A_      :				str		     =					SwiftFormerForImageClassification(_SCREAMING_SNAKE_CASE		)
         model.to(_SCREAMING_SNAKE_CASE		)
         model.eval()

         A_      :				int		     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
         A_      :				Dict		     =					model(_SCREAMING_SNAKE_CASE		)
         self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)		)







       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         ((A_)     ,       (A_)     ,       (A_))      :				Optional[int]		     =					self.prepare_config_and_inputs()
         A_      :				str		     =					{'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
class   _lowerCamelCase (					UpperCamelCase					,							UpperCamelCase					,							unittest.TestCase			):




       """simple docstring"""
       snake_case      =    (SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
       snake_case      =    (
           {"feature-extraction": SwiftFormerModel, "image-classification": SwiftFormerForImageClassification}
           if is_torch_available()
           else {}
       )

       snake_case      =    False
       snake_case      =    False
       snake_case      =    False
       snake_case      =    False
       snake_case      =    False



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_      :				Optional[int]		     =					SwiftFormerModelTester(self		)
         A_      :				Dict		     =					ConfigTester(
             self				,       config_class=_SCREAMING_SNAKE_CASE				,       has_text_modality=_SCREAMING_SNAKE_CASE				,       hidden_size=37				,       num_attention_heads=12				,       num_hidden_layers=12				,       )



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         self.config_tester.run_common_tests()



       @unittest.skip(reason='''SwiftFormer does not use inputs_embeds'''		)
       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         pass



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




         '''simple docstring'''





         A_     ,       A_      :				int		     =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_      :				List[str]		     =					model_class(_SCREAMING_SNAKE_CASE		)
           A_      :				Dict		     =					model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE				,       nn.Linear		)		)



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_     ,       A_      :				Any		     =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_      :				Tuple		     =					model_class(_SCREAMING_SNAKE_CASE		)
           A_      :				List[str]		     =					inspect.signature(model.forward		)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           A_      :				Tuple		     =					[*signature.parameters.keys()]

           A_      :				Optional[Any]		     =					['''pixel_values''']
           self.assertListEqual(arg_names[:1]				,       _SCREAMING_SNAKE_CASE		)



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




         '''simple docstring'''





         A_      :				List[str]		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->Dict:




         '''simple docstring'''





         A_      :				Dict		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE		)



       @slow
       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           A_      :				Optional[Any]		     =					SwiftFormerModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)



       @unittest.skip(reason='''SwiftFormer does not output attentions'''		)
       def        _snake_case       (      self		)->Union[str, Any]:




         '''simple docstring'''





         pass



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         def check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
           A_      :				Tuple		     =					model_class(_SCREAMING_SNAKE_CASE		)
           model.to(_SCREAMING_SNAKE_CASE		)
           model.eval()

           with torch.no_grad():
             A_      :				Dict		     =					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)		)

           A_      :				List[str]		     =					outputs.hidden_states

           A_      :				Optional[int]		     =					8
           self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       _SCREAMING_SNAKE_CASE		)  # TODO

           # SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
           # with the width and height being successively divided by 2, after every 2 blocks
           for i in range(len(_SCREAMING_SNAKE_CASE		)		):
             self.assertEqual(
                 hidden_states[i].shape				,       torch.Size(
                     [
                         self.model_tester.batch_size,
                         self.model_tester.embed_dims[i // 2],
                         (self.model_tester.image_size // 4) // 2 ** (i // 2),
                         (self.model_tester.image_size // 4) // 2 ** (i // 2),
                     ]		)				,       )

         A_     ,       A_      :				Tuple		     =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_      :				Dict		     =					True
           check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           A_      :				Optional[int]		     =					True

           check_hidden_states_output(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)



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




         '''simple docstring'''





         def _config_zero_init(_SCREAMING_SNAKE_CASE		):
           A_      :				Optional[Any]		     =					copy.deepcopy(_SCREAMING_SNAKE_CASE		)
           for key in configs_no_init.__dict__.keys():
             if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
               setattr(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       1e-10		)
             if isinstance(getattr(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)				,       _SCREAMING_SNAKE_CASE		):
               A_      :				str		     =					_config_zero_init(getattr(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)		)
               setattr(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
           return configs_no_init

         A_     ,       A_      :				Tuple		     =					self.model_tester.prepare_config_and_inputs_for_common()

         A_      :				int		     =					_config_zero_init(_SCREAMING_SNAKE_CASE		)
         for model_class in self.all_model_classes:
           A_      :				Optional[Any]		     =					model_class(config=_SCREAMING_SNAKE_CASE		)
           for name, param in model.named_parameters():
             if param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1e9) / 1e9).round().item()				,       [0.0, 1.0]				,       msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''				,       )







       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''		)
       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         pass




def   _SCREAMING_SNAKE_CASE	( ):
  A_      :				Optional[Any]		     =					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
  return image







@require_torch
@require_vision
class   _lowerCamelCase (					unittest.TestCase			):




       """simple docstring"""



       @cached_property
       def        _snake_case       (      self		)->Dict:




         '''simple docstring'''





         return ViTImageProcessor.from_pretrained('''MBZUAI/swiftformer-xs'''		) if is_vision_available() else None







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




         '''simple docstring'''





         A_      :				Tuple		     =					SwiftFormerForImageClassification.from_pretrained('''MBZUAI/swiftformer-xs'''		).to(_SCREAMING_SNAKE_CASE		)

         A_      :				int		     =					self.default_image_processor
         A_      :				Optional[int]		     =					prepare_img()
         A_      :				List[Any]		     =					image_processor(images=_SCREAMING_SNAKE_CASE				,       return_tensors='''pt'''		).to(_SCREAMING_SNAKE_CASE		)

         # forward pass
         with torch.no_grad():
           A_      :				int		     =					model(**_SCREAMING_SNAKE_CASE		)

         # verify the logits
         A_      :				Dict		     =					torch.Size((1, 1000)		)
         self.assertEqual(outputs.logits.shape				,       _SCREAMING_SNAKE_CASE		)

         A_      :				Dict		     =					torch.tensor([[-2.1_703e00, 2.1_107e00, -2.0_811e00]]		).to(_SCREAMING_SNAKE_CASE		)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]				,       _SCREAMING_SNAKE_CASE				,       atol=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()		)




