



"""simple docstring"""


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 			_a (					unittest.TestCase):
   """simple docstring"""



   def __init__(		self     :    Union[str, Any]				,   __UpperCamelCase     :    Optional[Any]				,   __UpperCamelCase     :    Tuple=1_3				,   __UpperCamelCase     :    Optional[Any]=7				,   __UpperCamelCase     :    Optional[Any]=True				,   __UpperCamelCase     :    Tuple=True				,   __UpperCamelCase     :    List[Any]=True				,   __UpperCamelCase     :    Any=True				,   __UpperCamelCase     :    Optional[int]=9_9				,   __UpperCamelCase     :    int=3_2				,   __UpperCamelCase     :    List[str]=5				,   __UpperCamelCase     :    Optional[Any]=4				,   __UpperCamelCase     :    List[Any]=3_7				,   __UpperCamelCase     :    Union[str, Any]="gelu"				,   __UpperCamelCase     :    List[Any]=0.1				,   __UpperCamelCase     :    Optional[Any]=0.1				,   __UpperCamelCase     :    Tuple=5_1_2				,   __UpperCamelCase     :    Optional[Any]=1_6				,   __UpperCamelCase     :    Optional[int]=2				,   __UpperCamelCase     :    int=0.0_2				,   __UpperCamelCase     :    Dict=4				,   )->int:
       _UpperCAmelCase					=    parent
       _UpperCAmelCase					=    batch_size
       _UpperCAmelCase					=    seq_length
       _UpperCAmelCase					=    is_training
       _UpperCAmelCase					=    use_attention_mask
       _UpperCAmelCase					=    use_token_type_ids
       _UpperCAmelCase					=    use_labels
       _UpperCAmelCase					=    vocab_size
       _UpperCAmelCase					=    hidden_size
       _UpperCAmelCase					=    num_hidden_layers
       _UpperCAmelCase					=    num_attention_heads
       _UpperCAmelCase					=    intermediate_size
       _UpperCAmelCase					=    hidden_act
       _UpperCAmelCase					=    hidden_dropout_prob
       _UpperCAmelCase					=    attention_probs_dropout_prob
       _UpperCAmelCase					=    max_position_embeddings
       _UpperCAmelCase					=    type_vocab_size
       _UpperCAmelCase					=    type_sequence_label_size
       _UpperCAmelCase					=    initializer_range
       _UpperCAmelCase					=    num_choices



   def  lowercase__						(		self     :    Dict   )->Optional[int]:
       _UpperCAmelCase					=    ids_tensor([self.batch_size, self.seq_length]				,   self.vocab_size   )

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

       _UpperCAmelCase					=    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  lowercase__						(		self     :    Tuple   )->Any:
       _UpperCAmelCase					=    self.prepare_config_and_inputs()
       _UpperCAmelCase		,						_UpperCAmelCase		,						_UpperCAmelCase					=    config_and_inputs
       _UpperCAmelCase					=    {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
       return config, inputs_dict



@require_flax
class 			_a (					lowerCAmelCase			,							unittest.TestCase):
   """simple docstring"""
   UpperCamelCase__			      =	(
       (
           FlaxDistilBertModel,
           FlaxDistilBertForMaskedLM,
           FlaxDistilBertForMultipleChoice,
           FlaxDistilBertForQuestionAnswering,
           FlaxDistilBertForSequenceClassification,
           FlaxDistilBertForTokenClassification,
           FlaxDistilBertForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )



   def  lowercase__						(		self     :    Optional[int]   )->Optional[int]:
       _UpperCAmelCase					=    FlaxDistilBertModelTester(self   )



   @slow
   def  lowercase__						(		self     :    Any   )->Tuple:
       for model_class_name in self.all_model_classes:
           _UpperCAmelCase					=    model_class_name.from_pretrained('''distilbert-base-uncased'''   )
           _UpperCAmelCase					=    model(np.ones((1, 1)   )   )
           self.assertIsNotNone(__UpperCamelCase   )



@require_flax
class 			_a (					unittest.TestCase):
   """simple docstring"""



   @slow
   def  lowercase__						(		self     :    Dict   )->Union[str, Any]:
       _UpperCAmelCase					=    FlaxDistilBertModel.from_pretrained('''distilbert-base-uncased'''   )
       _UpperCAmelCase					=    np.array([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]   )
       _UpperCAmelCase					=    np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
       _UpperCAmelCase					=    model(__UpperCamelCase				,   attention_mask=__UpperCamelCase   )[0]
       _UpperCAmelCase					=    (1, 1_1, 7_6_8)
       self.assertEqual(output.shape				,   __UpperCamelCase   )
       _UpperCAmelCase					=    np.array([[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]]   )

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








"""simple docstring"""


def  lowercase	(      _SCREAMING_SNAKE_CASE   :						int					,     _SCREAMING_SNAKE_CASE   :						int				):






				'''simple docstring'''



				if a < 0 or b < 0:
								raise ValueError('''the value of both inputs must be positive'''				)

				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"
				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"

				_UpperCAmelCase					=    max(len(_SCREAMING_SNAKE_CASE				)					,     len(_SCREAMING_SNAKE_CASE				)				)

				return "0b" + "".join(
				    str(int(char_a == '''1''' and char_b == '''1'''				)				)
				    for char_a, char_b in zip(a_binary.zfill(_SCREAMING_SNAKE_CASE				)					,     b_binary.zfill(_SCREAMING_SNAKE_CASE				)				)				)


if __name__ == "__main__":
					import doctest

					doctest.testmod()



