

'''simple docstring'''







from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TF_MODEL_FOR_PRETRAINING_MAPPING,
          TFMobileBertForMaskedLM,
          TFMobileBertForMultipleChoice,
          TFMobileBertForNextSentencePrediction,
          TFMobileBertForPreTraining,
          TFMobileBertForQuestionAnswering,
          TFMobileBertForSequenceClassification,
          TFMobileBertForTokenClassification,
          TFMobileBertModel,
      )


@require_tf
class 					A__      (      _snake_case						,						_snake_case						,						unittest.TestCase			):
    lowercase						=		(
        (
            TFMobileBertModel,
            TFMobileBertForMaskedLM,
            TFMobileBertForNextSentencePrediction,
            TFMobileBertForPreTraining,
            TFMobileBertForQuestionAnswering,
            TFMobileBertForSequenceClassification,
            TFMobileBertForTokenClassification,
            TFMobileBertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    lowercase						=		(
        {
            "feature-extraction": TFMobileBertModel,
            "fill-mask": TFMobileBertForMaskedLM,
            "question-answering": TFMobileBertForQuestionAnswering,
            "text-classification": TFMobileBertForSequenceClassification,
            "token-classification": TFMobileBertForTokenClassification,
            "zero-shot": TFMobileBertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    lowercase						=		False
    lowercase						=		False



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__=False       )						->      Any:





           '''simple docstring'''
           A_						=      super()._prepare_for_class(UpperCamelCase__		,				UpperCamelCase__		,				return_labels=UpperCamelCase__       )

           if return_labels:
                  if model_class in get_values(UpperCamelCase__       ):
                         A_						=      tf.zeros(self.model_tester.batch_size		,				dtype=tf.intaa       )

           return inputs_dict


    class 					A__      (      _snake_case			):



        def __init__(					self		,				UpperCamelCase__		,				UpperCamelCase__=13		,				UpperCamelCase__=7		,				UpperCamelCase__=True		,				UpperCamelCase__=True		,				UpperCamelCase__=True		,				UpperCamelCase__=True		,				UpperCamelCase__=99		,				UpperCamelCase__=32		,				UpperCamelCase__=32		,				UpperCamelCase__=2		,				UpperCamelCase__=4		,				UpperCamelCase__=37		,				UpperCamelCase__="gelu"		,				UpperCamelCase__=0.1		,				UpperCamelCase__=0.1		,				UpperCamelCase__=512		,				UpperCamelCase__=16		,				UpperCamelCase__=2		,				UpperCamelCase__=0.02		,				UpperCamelCase__=3		,				UpperCamelCase__=4		,				UpperCamelCase__=None		,				)						->      Optional[Any]:





               '''simple docstring'''
               A_						=      parent
               A_						=      batch_size
               A_						=      seq_length
               A_						=      is_training
               A_						=      use_input_mask
               A_						=      use_token_type_ids
               A_						=      use_labels
               A_						=      vocab_size
               A_						=      hidden_size
               A_						=      num_hidden_layers
               A_						=      num_attention_heads
               A_						=      intermediate_size
               A_						=      hidden_act
               A_						=      hidden_dropout_prob
               A_						=      attention_probs_dropout_prob
               A_						=      max_position_embeddings
               A_						=      type_vocab_size
               A_						=      type_sequence_label_size
               A_						=      initializer_range
               A_						=      num_labels
               A_						=      num_choices
               A_						=      scope
               A_						=      embedding_size



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





               '''simple docstring'''
               A_						=      ids_tensor([self.batch_size, self.seq_length]		,				self.vocab_size       )

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

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

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

               A_						=      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		,				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		,				initializer_range=self.initializer_range		,				embedding_size=self.embedding_size		,				)

               return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Tuple:





               '''simple docstring'''
               A_						=      TFMobileBertModel(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )

               A_						=      [input_ids, input_mask]
               A_						=      model(UpperCamelCase__       )

               A_						=      model(UpperCamelCase__       )

               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 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Optional[Any]:





               '''simple docstring'''
               A_						=      TFMobileBertForMaskedLM(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.vocab_size)       )



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Optional[Any]:





               '''simple docstring'''
               A_						=      TFMobileBertForNextSentencePrediction(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               self.parent.assertEqual(result.logits.shape		,				(self.batch_size, 2)       )



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Optional[Any]:





               '''simple docstring'''
               A_						=      TFMobileBertForPreTraining(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               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 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Dict:





               '''simple docstring'''
               A_						=      self.num_labels
               A_						=      TFMobileBertForSequenceClassification(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)       )



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Any:





               '''simple docstring'''
               A_						=      self.num_choices
               A_						=      TFMobileBertForMultipleChoice(config=UpperCamelCase__       )
               A_						=      tf.tile(tf.expand_dims(UpperCamelCase__		,				1       )		,				(1, self.num_choices, 1)       )
               A_						=      tf.tile(tf.expand_dims(UpperCamelCase__		,				1       )		,				(1, self.num_choices, 1)       )
               A_						=      tf.tile(tf.expand_dims(UpperCamelCase__		,				1       )		,				(1, self.num_choices, 1)       )
               A_						=      {
                   """input_ids""": multiple_choice_inputs_ids,
                   """attention_mask""": multiple_choice_input_mask,
                   """token_type_ids""": multiple_choice_token_type_ids,
               }
               A_						=      model(UpperCamelCase__       )
               self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_choices)       )



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Tuple:





               '''simple docstring'''
               A_						=      self.num_labels
               A_						=      TFMobileBertForTokenClassification(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.num_labels)       )



        def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      str:





               '''simple docstring'''
               A_						=      TFMobileBertForQuestionAnswering(config=UpperCamelCase__       )
               A_						=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
               A_						=      model(UpperCamelCase__       )
               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 					snake_case_			(					self       )						->      str:





               '''simple docstring'''
               A_						=      self.prepare_config_and_inputs()
               (
                   (
                   A_
               )					,			(
                   A_
               )					,			(
                   A_
               )					,			(
                   A_
               )					,			(
                   A_
               )					,			(
                   A_
               )					,			(
                   A_
               )					,			
               )						=      config_and_inputs
               A_						=      {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
               return config, inputs_dict



    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           A_						=      TFMobileBertModelTest.TFMobileBertModelTester(self       )
           A_						=      ConfigTester(self		,				config_class=UpperCamelCase__		,				hidden_size=37       )



    def 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def 					snake_case_			(					self       )						->      int:





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_model(*UpperCamelCase__       )



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





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_masked_lm(*UpperCamelCase__       )



    def 					snake_case_			(					self       )						->      Dict:





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_multiple_choice(*UpperCamelCase__       )



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





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*UpperCamelCase__       )



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





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_pretraining(*UpperCamelCase__       )



    def 					snake_case_			(					self       )						->      Tuple:





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_question_answering(*UpperCamelCase__       )



    def 					snake_case_			(					self       )						->      Dict:





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_sequence_classification(*UpperCamelCase__       )



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





           '''simple docstring'''
           A_						=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_mobilebert_for_token_classification(*UpperCamelCase__       )







    @slow
    def 					snake_case_			(					self       )						->      Union[str, Any]:





           '''simple docstring'''
           # for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           for model_name in ["google/mobilebert-uncased"]:
                  A_						=      TFMobileBertModel.from_pretrained(UpperCamelCase__       )
                  self.assertIsNotNone(UpperCamelCase__       )


@require_tf
class 					A__      (      unittest.TestCase			):



    @slow
    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           A_						=      TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased"""       )
           A_						=      tf.constant([[0, 1, 2, 3, 4, 5]]       )
           A_						=      model(UpperCamelCase__       )[0]

           A_						=      [1, 6, 30522]
           self.assertEqual(output.shape		,				UpperCamelCase__       )

           A_						=      tf.constant(
               [
                   [
                       [-4.5919547, -9.248295, -9.645256],
                       [-6.7306175, -6.440284, -6.6052837],
                       [-7.2743506, -6.7847915, -6.024673],
                   ]
               ]       )
           tf.debugging.assert_near(output[:, :3, :3]		,				UpperCamelCase__		,				atol=1e-4       )



'''simple docstring'''







import warnings

from diffusers import StableDiffusionImgaImgPipeline  # noqa F401


warnings.warn(
    '''The `image_to_image.py` script is outdated. Please use directly `from diffusers import'''
    ''' StableDiffusionImg2ImgPipeline` instead.'''
)
