




import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

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


if is_torch_available():
 import torch

 from transformers import (
     MODEL_FOR_PRETRAINING_MAPPING,
     MobileBertForMaskedLM,
     MobileBertForMultipleChoice,
     MobileBertForNextSentencePrediction,
     MobileBertForPreTraining,
     MobileBertForQuestionAnswering,
     MobileBertForSequenceClassification,
     MobileBertForTokenClassification,
     MobileBertModel,
 )



class       a					:

     '''simple docstring'''





     def __init__(     self       :      Optional[Any] ,   __snake_case       :      Any ,   __snake_case       :      Any=13 ,   __snake_case       :      List[Any]=7 ,   __snake_case       :      Dict=True ,   __snake_case       :      Optional[int]=True ,   __snake_case       :      Optional[int]=True ,   __snake_case       :      Optional[int]=True ,   __snake_case       :      Optional[Any]=99 ,   __snake_case       :      Dict=64 ,   __snake_case       :      Any=32 ,   __snake_case       :      Optional[Any]=5 ,   __snake_case       :      Union[str, Any]=4 ,   __snake_case       :      Tuple=37 ,   __snake_case       :      List[str]="gelu" ,   __snake_case       :      Dict=0.1 ,   __snake_case       :      Union[str, Any]=0.1 ,   __snake_case       :      Optional[Any]=5_12 ,   __snake_case       :      Union[str, Any]=16 ,   __snake_case       :      str=2 ,   __snake_case       :      Optional[int]=0.02 ,   __snake_case       :      Union[str, Any]=3 ,   __snake_case       :      int=4 ,   __snake_case       :      Dict=None ,   ):
         UpperCAmelCase_										=					parent
         UpperCAmelCase_										=					batch_size
         UpperCAmelCase_										=					seq_length
         UpperCAmelCase_										=					is_training
         UpperCAmelCase_										=					use_input_mask
         UpperCAmelCase_										=					use_token_type_ids
         UpperCAmelCase_										=					use_labels
         UpperCAmelCase_										=					vocab_size
         UpperCAmelCase_										=					hidden_size
         UpperCAmelCase_										=					embedding_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_labels
         UpperCAmelCase_										=					num_choices
         UpperCAmelCase_										=					scope
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					ids_tensor([self.batch_size, self.seq_length] ,   self.vocab_size    )

         UpperCAmelCase_										=					None
         if self.use_input_mask:
             UpperCAmelCase_										=					random_attention_mask([self.batch_size, self.seq_length]    )

         UpperCAmelCase_										=					None
         if self.use_token_type_ids:
             UpperCAmelCase_										=					ids_tensor([self.batch_size, self.seq_length] ,   self.type_vocab_size    )

         UpperCAmelCase_										=					None
         UpperCAmelCase_										=					None
         UpperCAmelCase_										=					None
         if self.use_labels:
             UpperCAmelCase_										=					ids_tensor([self.batch_size] ,   self.type_sequence_label_size    )
             UpperCAmelCase_										=					ids_tensor([self.batch_size, self.seq_length] ,   self.num_labels    )
             UpperCAmelCase_										=					ids_tensor([self.batch_size] ,   self.num_choices    )

         UpperCAmelCase_										=					self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
     def   lowerCamelCase_       (     self       :      List[str]    ):
         return MobileBertConfig(
             vocab_size=self.vocab_size ,   hidden_size=self.hidden_size ,   num_hidden_layers=self.num_hidden_layers ,   num_attention_heads=self.num_attention_heads ,   intermediate_size=self.intermediate_size ,   embedding_size=self.embedding_size ,   hidden_act=self.hidden_act ,   hidden_dropout_prob=self.hidden_dropout_prob ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob ,   max_position_embeddings=self.max_position_embeddings ,   type_vocab_size=self.type_vocab_size ,   is_decoder=__snake_case ,   initializer_range=self.initializer_range ,   )
     def   lowerCamelCase_       (     self       :      Optional[int] ,   __snake_case       :      int ,   __snake_case       :      Tuple ,   __snake_case       :      Dict ,   __snake_case       :      str ,   __snake_case       :      int ,   __snake_case       :      Tuple ,   __snake_case       :      List[Any]    ):
         UpperCAmelCase_										=					MobileBertModel(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(__snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case    )
         UpperCAmelCase_										=					model(__snake_case ,   token_type_ids=__snake_case    )
         UpperCAmelCase_										=					model(__snake_case    )

         self.parent.assertEqual(result.last_hidden_state.shape ,   (self.batch_size, self.seq_length, self.hidden_size)    )
         self.parent.assertEqual(result.pooler_output.shape ,   (self.batch_size, self.hidden_size)    )
     def   lowerCamelCase_       (     self       :      Any ,   __snake_case       :      Optional[Any] ,   __snake_case       :      Dict ,   __snake_case       :      List[Any] ,   __snake_case       :      Any ,   __snake_case       :      List[Any] ,   __snake_case       :      List[Any] ,   __snake_case       :      str    ):
         UpperCAmelCase_										=					MobileBertForMaskedLM(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(__snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case    )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.vocab_size)    )
     def   lowerCamelCase_       (     self       :      Optional[int] ,   __snake_case       :      List[Any] ,   __snake_case       :      Optional[int] ,   __snake_case       :      Tuple ,   __snake_case       :      Any ,   __snake_case       :      List[Any] ,   __snake_case       :      Any ,   __snake_case       :      List[Any]    ):
         UpperCAmelCase_										=					MobileBertForNextSentencePrediction(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(
             __snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case ,   )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, 2)    )
     def   lowerCamelCase_       (     self       :      Optional[Any] ,   __snake_case       :      Optional[Any] ,   __snake_case       :      Optional[Any] ,   __snake_case       :      str ,   __snake_case       :      List[Any] ,   __snake_case       :      Optional[Any] ,   __snake_case       :      Union[str, Any] ,   __snake_case       :      int    ):
         UpperCAmelCase_										=					MobileBertForPreTraining(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(
             __snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case ,   next_sentence_label=__snake_case ,   )
         self.parent.assertEqual(result.prediction_logits.shape ,   (self.batch_size, self.seq_length, self.vocab_size)    )
         self.parent.assertEqual(result.seq_relationship_logits.shape ,   (self.batch_size, 2)    )
     def   lowerCamelCase_       (     self       :      List[Any] ,   __snake_case       :      int ,   __snake_case       :      int ,   __snake_case       :      List[str] ,   __snake_case       :      List[str] ,   __snake_case       :      int ,   __snake_case       :      List[Any] ,   __snake_case       :      int    ):
         UpperCAmelCase_										=					MobileBertForQuestionAnswering(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(
             __snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   start_positions=__snake_case ,   end_positions=__snake_case ,   )
         self.parent.assertEqual(result.start_logits.shape ,   (self.batch_size, self.seq_length)    )
         self.parent.assertEqual(result.end_logits.shape ,   (self.batch_size, self.seq_length)    )
     def   lowerCamelCase_       (     self       :      Dict ,   __snake_case       :      Any ,   __snake_case       :      List[str] ,   __snake_case       :      Union[str, Any] ,   __snake_case       :      List[str] ,   __snake_case       :      Union[str, Any] ,   __snake_case       :      Any ,   __snake_case       :      Dict    ):
         UpperCAmelCase_										=					self.num_labels
         UpperCAmelCase_										=					MobileBertForSequenceClassification(__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(__snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case    )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels)    )
     def   lowerCamelCase_       (     self       :      List[Any] ,   __snake_case       :      int ,   __snake_case       :      List[Any] ,   __snake_case       :      str ,   __snake_case       :      int ,   __snake_case       :      Optional[int] ,   __snake_case       :      Dict ,   __snake_case       :      Optional[Any]    ):
         UpperCAmelCase_										=					self.num_labels
         UpperCAmelCase_										=					MobileBertForTokenClassification(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					model(__snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case    )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.num_labels)    )
     def   lowerCamelCase_       (     self       :      List[str] ,   __snake_case       :      int ,   __snake_case       :      str ,   __snake_case       :      Any ,   __snake_case       :      Any ,   __snake_case       :      List[Any] ,   __snake_case       :      Optional[Any] ,   __snake_case       :      Dict    ):
         UpperCAmelCase_										=					self.num_choices
         UpperCAmelCase_										=					MobileBertForMultipleChoice(config=__snake_case    )
         model.to(__snake_case    )
         model.eval()
         UpperCAmelCase_										=					input_ids.unsqueeze(1    ).expand(-1 ,   self.num_choices ,   -1    ).contiguous()
         UpperCAmelCase_										=					token_type_ids.unsqueeze(1    ).expand(-1 ,   self.num_choices ,   -1    ).contiguous()
         UpperCAmelCase_										=					input_mask.unsqueeze(1    ).expand(-1 ,   self.num_choices ,   -1    ).contiguous()
         UpperCAmelCase_										=					model(
             __snake_case ,   attention_mask=__snake_case ,   token_type_ids=__snake_case ,   labels=__snake_case ,   )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_choices)    )




     def   lowerCamelCase_       (     self       :      int    ):
         UpperCAmelCase_										=					self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							(
             UpperCAmelCase_
         )			,							
         )										=					config_and_inputs
         UpperCAmelCase_										=					{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
         return config, inputs_dict



@require_torch
class       a					(       _A     ,       _A     ,       unittest.TestCase      ):

     '''simple docstring'''





     lowerCAmelCase    :	List[Any]       		=  (
         (
             MobileBertModel,
             MobileBertForMaskedLM,
             MobileBertForMultipleChoice,
             MobileBertForNextSentencePrediction,
             MobileBertForPreTraining,
             MobileBertForQuestionAnswering,
             MobileBertForSequenceClassification,
             MobileBertForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     lowerCAmelCase    :	Dict       		=  (
         {
             'feature-extraction': MobileBertModel,
             'fill-mask': MobileBertForMaskedLM,
             'question-answering': MobileBertForQuestionAnswering,
             'text-classification': MobileBertForSequenceClassification,
             'token-classification': MobileBertForTokenClassification,
             'zero-shot': MobileBertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     lowerCAmelCase    :	Any       		=  True
     def   lowerCamelCase_       (     self       :      int ,   __snake_case       :      Optional[int] ,   __snake_case       :      List[str] ,   __snake_case       :      Tuple=False    ):
         UpperCAmelCase_										=					super()._prepare_for_class(__snake_case ,   __snake_case ,   return_labels=__snake_case    )

         if return_labels:
             if model_class in get_values(__snake_case    ):
                 UpperCAmelCase_										=					torch.zeros(
                     (self.model_tester.batch_size, self.model_tester.seq_length) ,   dtype=torch.long ,   device=__snake_case    )
                 UpperCAmelCase_										=					torch.zeros(
                     self.model_tester.batch_size ,   dtype=torch.long ,   device=__snake_case    )
         return inputs_dict
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					MobileBertModelTester(self    )
         UpperCAmelCase_										=					ConfigTester(self ,   config_class=__snake_case ,   hidden_size=37    )
     def   lowerCamelCase_       (     self       :      List[str]    ):
         self.config_tester.run_common_tests()
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_model(*__snake_case    )
     def   lowerCamelCase_       (     self       :      int    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_masked_lm(*__snake_case    )
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_multiple_choice(*__snake_case    )
     def   lowerCamelCase_       (     self       :      List[Any]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*__snake_case    )
     def   lowerCamelCase_       (     self       :      Dict    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_pretraining(*__snake_case    )
     def   lowerCamelCase_       (     self       :      str    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_question_answering(*__snake_case    )
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_sequence_classification(*__snake_case    )




     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_token_classification(*__snake_case    )




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						str				)  ->							Any:
    return torch.tensor(
        __UpperCamelCase	,					dtype=torch.long	,					device=__UpperCamelCase	,					)


_lowerCamelCase      			=						1e-3



@require_torch
@require_sentencepiece
@require_tokenizers
class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     @slow
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					MobileBertModel.from_pretrained('''google/mobilebert-uncased'''    ).to(__snake_case    )
         UpperCAmelCase_										=					_long_tensor([[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]]    )
         with torch.no_grad():
             UpperCAmelCase_										=					model(__snake_case    )[0]
         UpperCAmelCase_										=					torch.Size((1, 9, 5_12)    )
         self.assertEqual(output.shape ,   __snake_case    )
         UpperCAmelCase_										=					torch.tensor(
             [
                 [
                     [-2.4736526E07, 8.2691656E04, 1.6521838E05],
                     [-5.7541704E-01, 3.9056022E00, 4.4011507E00],
                     [2.6047359E00, 1.5677652E00, -1.7324188E-01],
                 ]
             ] ,   device=__snake_case ,   )

         # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
         # ~1 difference, it's therefore not a good idea to measure using addition.
         # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
         # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
         UpperCAmelCase_										=					torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE    )
         UpperCAmelCase_										=					torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE    )

         self.assertTrue(lower_bound and upper_bound    )











def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						float	,					__UpperCamelCase      :						float				)  ->							float:

    if density <= 0:
        raise ValueError('''Impossible fluid density'''				)
    if bulk_modulus <= 0:
        raise ValueError('''Impossible bulk modulus'''				)

    return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
 import doctest

 doctest.testmod()





