




import unittest

import numpy as np

from transformers import DistilBertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
       import jax.numpy as jnp

       from transformers.models.distilbert.modeling_flax_distilbert import (
           FlaxDistilBertForMaskedLM,
           FlaxDistilBertForMultipleChoice,
           FlaxDistilBertForQuestionAnswering,
           FlaxDistilBertForSequenceClassification,
           FlaxDistilBertForTokenClassification,
           FlaxDistilBertModel,
       )





class     lowerCamelCase__(					unittest.TestCase):
      def __init__(				self: Tuple    ,       UpperCamelCase_: Optional[Any]    ,       UpperCamelCase_: List[str]=13    ,       UpperCamelCase_: Any=7    ,       UpperCamelCase_: str=True    ,       UpperCamelCase_: Any=True    ,       UpperCamelCase_: Optional[Any]=True    ,       UpperCamelCase_: int=True    ,       UpperCamelCase_: Optional[Any]=99    ,       UpperCamelCase_: Optional[int]=32    ,       UpperCamelCase_: Optional[Any]=5    ,       UpperCamelCase_: List[Any]=4    ,       UpperCamelCase_: Optional[int]=37    ,       UpperCamelCase_: List[str]="gelu"    ,       UpperCamelCase_: Tuple=0.1    ,       UpperCamelCase_: Dict=0.1    ,       UpperCamelCase_: List[Any]=5_12    ,       UpperCamelCase_: Union[str, Any]=16    ,       UpperCamelCase_: Optional[Any]=2    ,       UpperCamelCase_: Optional[Any]=0.02    ,       UpperCamelCase_: Dict=4    ,       ):
             __lowerCamelCase   =						parent
             __lowerCamelCase   =						batch_size
             __lowerCamelCase   =						seq_length
             __lowerCamelCase   =						is_training
             __lowerCamelCase   =						use_attention_mask
             __lowerCamelCase   =						use_token_type_ids
             __lowerCamelCase   =						use_labels
             __lowerCamelCase   =						vocab_size
             __lowerCamelCase   =						hidden_size
             __lowerCamelCase   =						num_hidden_layers
             __lowerCamelCase   =						num_attention_heads
             __lowerCamelCase   =						intermediate_size
             __lowerCamelCase   =						hidden_act
             __lowerCamelCase   =						hidden_dropout_prob
             __lowerCamelCase   =						attention_probs_dropout_prob
             __lowerCamelCase   =						max_position_embeddings
             __lowerCamelCase   =						type_vocab_size
             __lowerCamelCase   =						type_sequence_label_size
             __lowerCamelCase   =						initializer_range
             __lowerCamelCase   =						num_choices
      def 			lowerCAmelCase__						(				self: int   ):
             __lowerCamelCase   =						ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size   )

             __lowerCamelCase   =						None
             if self.use_attention_mask:
                    __lowerCamelCase   =						random_attention_mask([self.batch_size, self.seq_length]   )

             __lowerCamelCase   =						DistilBertConfig(
                 vocab_size=self.vocab_size    ,       dim=self.hidden_size    ,       n_layers=self.num_hidden_layers    ,       n_heads=self.num_attention_heads    ,       hidden_dim=self.intermediate_size    ,       hidden_act=self.hidden_act    ,       dropout=self.hidden_dropout_prob    ,       attention_dropout=self.attention_probs_dropout_prob    ,       max_position_embeddings=self.max_position_embeddings    ,       initializer_range=self.initializer_range    ,       tie_weights_=UpperCamelCase_    ,       )

             return config, input_ids, attention_mask




      def 			lowerCAmelCase__						(				self: int   ):
             __lowerCamelCase   =						self.prepare_config_and_inputs()
             __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase   =						config_and_inputs
             __lowerCamelCase   =						{"""input_ids""": input_ids, """attention_mask""": attention_mask}
             return config, inputs_dict





@require_flax
class     lowerCamelCase__(					__lowerCamelCase ,     unittest.TestCase):
      UpperCAmelCase__      :	int    		=   (
          (
              FlaxDistilBertModel,
              FlaxDistilBertForMaskedLM,
              FlaxDistilBertForMultipleChoice,
              FlaxDistilBertForQuestionAnswering,
              FlaxDistilBertForSequenceClassification,
              FlaxDistilBertForTokenClassification,
              FlaxDistilBertForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						FlaxDistilBertModelTester(self   )




      @slow
      def 			lowerCAmelCase__						(				self: Any   ):
             for model_class_name in self.all_model_classes:
                    __lowerCamelCase   =						model_class_name.from_pretrained("""distilbert-base-uncased"""   )
                    __lowerCamelCase   =						model(np.ones((1, 1)   )   )
                    self.assertIsNotNone(UpperCamelCase_   )





@require_flax
class     lowerCamelCase__(					unittest.TestCase):
      @slow
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase   =						FlaxDistilBertModel.from_pretrained("""distilbert-base-uncased"""   )
             __lowerCamelCase   =						np.array([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]   )
             __lowerCamelCase   =						np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
             __lowerCamelCase   =						model(UpperCamelCase_    ,       attention_mask=UpperCamelCase_   )[0]
             __lowerCamelCase   =						(1, 11, 7_68)
             self.assertEqual(output.shape    ,       UpperCamelCase_   )
             __lowerCamelCase   =						np.array([[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]]   )

             self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]    ,       UpperCamelCase_    ,       atol=1E-4   )   )







def 					lowerCamelCase__       (						A__       :					list	):





       '''simple docstring'''



       __lowerCamelCase   =						len(A__	)
       for _ in range(A__	):
              for i in range(_ % 2  ,			arr_size - 1  ,			2	):
                     if arr[i + 1] < arr[i]:
                            __lowerCamelCase,   __lowerCamelCase   =						arr[i + 1], arr[i]

       return arr


if __name__ == "__main__":
       UpperCAmelCase_									=	list(range(10, 0, -1))
       print(f"""Original: {arr}. Sorted: {odd_even_transposition(arr)}""")

