import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest

class    snake_case       (   UpperCamelCase_    ):
  lowercase_								=  (DEISMultistepScheduler,)
  lowercase_								=  (('num_inference_steps', 25),)




  def 						__lowercase(   self  :						List[str]  ,			**a_  :						int					)->							Optional[Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					List[str]      =		{
           'num_train_timesteps': 1000,
           'beta_start': 0.0001,
           'beta_end': 0.02,
           'beta_schedule': 'linear',
           'solver_order': 2,
       }

       config.update(**a_					)
       return config




  def 						__lowercase(   self  :						Optional[int]  ,			a_  :						List[str]=0  ,			**a_  :						str					)->							Union[str, Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Tuple      =		dict(self.forward_default_kwargs					)
       SCREAMING_SNAKE_CASE__					:					str      =		kwargs.pop('num_inference_steps'  ,			a_					)
       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		self.dummy_sample
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		0.1 * sample
       SCREAMING_SNAKE_CASE__					:					int      =		[residual + 0.2, residual + 0.15, residual + 0.10]

       for scheduler_class in self.scheduler_classes:
            SCREAMING_SNAKE_CASE__					:					Dict      =		self.get_scheduler_config(**a_					)
            SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		scheduler_class(**a_					)
            scheduler.set_timesteps(a_					)
            # copy over dummy past residuals
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		dummy_past_residuals[: scheduler.config.solver_order]

            with tempfile.TemporaryDirectory() as tmpdirname:
                 scheduler.save_config(a_					)
                 SCREAMING_SNAKE_CASE__					:					Dict      =		scheduler_class.from_pretrained(a_					)
                 new_scheduler.set_timesteps(a_					)
                 # copy over dummy past residuals
                 SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		dummy_past_residuals[: new_scheduler.config.solver_order]

            SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		sample, sample
            for t in range(a_  ,			time_step + scheduler.config.solver_order + 1					):
                 SCREAMING_SNAKE_CASE__					:					Optional[int]      =		scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample
                 SCREAMING_SNAKE_CASE__					:					List[Any]      =		new_scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample

                 assert torch.sum(torch.abs(output - new_output					)					) < 1e-5, "Scheduler outputs are not identical"




  def 						__lowercase(   self  :						int					)->							Dict:




       """simple docstring"""
       pass




  def 						__lowercase(   self  :						List[str]  ,			a_  :						int=0  ,			**a_  :						Optional[Any]					)->							Union[str, Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Dict      =		dict(self.forward_default_kwargs					)
       SCREAMING_SNAKE_CASE__					:					str      =		kwargs.pop('num_inference_steps'  ,			a_					)
       SCREAMING_SNAKE_CASE__					:					str      =		self.dummy_sample
       SCREAMING_SNAKE_CASE__					:					Dict      =		0.1 * sample
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		[residual + 0.2, residual + 0.15, residual + 0.10]

       for scheduler_class in self.scheduler_classes:
            SCREAMING_SNAKE_CASE__					:					int      =		self.get_scheduler_config()
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		scheduler_class(**a_					)
            scheduler.set_timesteps(a_					)

            # copy over dummy past residuals (must be after setting timesteps)
            SCREAMING_SNAKE_CASE__					:					List[str]      =		dummy_past_residuals[: scheduler.config.solver_order]

            with tempfile.TemporaryDirectory() as tmpdirname:
                 scheduler.save_config(a_					)
                 SCREAMING_SNAKE_CASE__					:					str      =		scheduler_class.from_pretrained(a_					)
                 # copy over dummy past residuals
                 new_scheduler.set_timesteps(a_					)

                 # copy over dummy past residual (must be after setting timesteps)
                 SCREAMING_SNAKE_CASE__					:					List[Any]      =		dummy_past_residuals[: new_scheduler.config.solver_order]

            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample
            SCREAMING_SNAKE_CASE__					:					Any      =		new_scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample

            assert torch.sum(torch.abs(output - new_output					)					) < 1e-5, "Scheduler outputs are not identical"




  def 						__lowercase(   self  :						Dict  ,			a_  :						List[str]=None  ,			**a_  :						List[Any]					)->							Any:




       """simple docstring"""
       if scheduler is None:
            SCREAMING_SNAKE_CASE__					:					str      =		self.scheduler_classes[0]
            SCREAMING_SNAKE_CASE__					:					Dict      =		self.get_scheduler_config(**a_					)
            SCREAMING_SNAKE_CASE__					:					int      =		scheduler_class(**a_					)

       SCREAMING_SNAKE_CASE__					:					Dict      =		self.scheduler_classes[0]
       SCREAMING_SNAKE_CASE__					:					int      =		self.get_scheduler_config(**a_					)
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		scheduler_class(**a_					)

       SCREAMING_SNAKE_CASE__					:					List[Any]      =		10
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		self.dummy_model()
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		self.dummy_sample_deter
       scheduler.set_timesteps(a_					)

       for i, t in enumerate(scheduler.timesteps					):
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		model(a_  ,			a_					)
            SCREAMING_SNAKE_CASE__					:					Any      =		scheduler.step(a_  ,			a_  ,			a_					).prev_sample

       return sample




  def 						__lowercase(   self  :						List[Any]					)->							Union[str, Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Any      =		dict(self.forward_default_kwargs					)

       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		kwargs.pop('num_inference_steps'  ,			a_					)

       for scheduler_class in self.scheduler_classes:
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		self.get_scheduler_config()
            SCREAMING_SNAKE_CASE__					:					Tuple      =		scheduler_class(**a_					)

            SCREAMING_SNAKE_CASE__					:					List[Any]      =		self.dummy_sample
            SCREAMING_SNAKE_CASE__					:					int      =		0.1 * sample

            if num_inference_steps is not None and hasattr(a_  ,			'set_timesteps'					):
                 scheduler.set_timesteps(a_					)
            elif num_inference_steps is not None and not hasattr(a_  ,			'set_timesteps'					):
                 SCREAMING_SNAKE_CASE__					:					int      =		num_inference_steps

            # copy over dummy past residuals (must be done after set_timesteps)
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		[residual + 0.2, residual + 0.15, residual + 0.10]
            SCREAMING_SNAKE_CASE__					:					str      =		dummy_past_residuals[: scheduler.config.solver_order]

            SCREAMING_SNAKE_CASE__					:					Tuple      =		scheduler.timesteps[5]
            SCREAMING_SNAKE_CASE__					:					List[str]      =		scheduler.timesteps[6]

            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample
            SCREAMING_SNAKE_CASE__					:					str      =		scheduler.step(a_  ,			a_  ,			a_  ,			**a_					).prev_sample

            self.assertEqual(output_a.shape  ,			sample.shape					)
            self.assertEqual(output_a.shape  ,			output_a.shape					)




  def 						__lowercase(   self  :						Tuple					)->							Any:




       """simple docstring"""
       # make sure that iterating over schedulers with same config names gives same results
       # for defaults
       SCREAMING_SNAKE_CASE__					:					List[str]      =		DEISMultistepScheduler(**self.get_scheduler_config()					)
       SCREAMING_SNAKE_CASE__					:					str      =		self.full_loop(scheduler=a_					)
       SCREAMING_SNAKE_CASE__					:					int      =		torch.mean(torch.abs(a_					)					)

       assert abs(result_mean.item() - 0.2_3916					) < 1e-3

       SCREAMING_SNAKE_CASE__					:					Tuple      =		DPMSolverSinglestepScheduler.from_config(scheduler.config					)
       SCREAMING_SNAKE_CASE__					:					int      =		DPMSolverMultistepScheduler.from_config(scheduler.config					)
       SCREAMING_SNAKE_CASE__					:					Any      =		UniPCMultistepScheduler.from_config(scheduler.config					)
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		DEISMultistepScheduler.from_config(scheduler.config					)

       SCREAMING_SNAKE_CASE__					:					Any      =		self.full_loop(scheduler=a_					)
       SCREAMING_SNAKE_CASE__					:					Tuple      =		torch.mean(torch.abs(a_					)					)

       assert abs(result_mean.item() - 0.2_3916					) < 1e-3




  def 						__lowercase(   self  :						Tuple					)->							Tuple:




       """simple docstring"""
       for timesteps in [25, 50, 100, 999, 1000]:
            self.check_over_configs(num_train_timesteps=a_					)




  def 						__lowercase(   self  :						str					)->							Tuple:




       """simple docstring"""
       self.check_over_configs(thresholding=a_					)
       for order in [1, 2, 3]:
            for solver_type in ["logrho"]:
                 for threshold in [0.5, 1.0, 2.0]:
                      for prediction_type in ["epsilon", "sample"]:
                           self.check_over_configs(
                               thresholding=a_  ,			prediction_type=a_  ,			sample_max_value=a_  ,			algorithm_type='deis'  ,			solver_order=a_  ,			solver_type=a_  ,			)




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




       """simple docstring"""
       for prediction_type in ["epsilon", "v_prediction"]:
            self.check_over_configs(prediction_type=a_					)




  def 						__lowercase(   self  :						str					)->							Dict:




       """simple docstring"""
       for algorithm_type in ["deis"]:
            for solver_type in ["logrho"]:
                 for order in [1, 2, 3]:
                      for prediction_type in ["epsilon", "sample"]:
                           self.check_over_configs(
                               solver_order=a_  ,			solver_type=a_  ,			prediction_type=a_  ,			algorithm_type=a_  ,			)
                           SCREAMING_SNAKE_CASE__					:					Tuple      =		self.full_loop(
                               solver_order=a_  ,			solver_type=a_  ,			prediction_type=a_  ,			algorithm_type=a_  ,			)
                           assert not torch.isnan(a_					).any(), "Samples have nan numbers"




  def 						__lowercase(   self  :						Optional[Any]					)->							List[str]:




       """simple docstring"""
       self.check_over_configs(lower_order_final=a_					)
       self.check_over_configs(lower_order_final=a_					)




  def 						__lowercase(   self  :						List[Any]					)->							str:




       """simple docstring"""
       for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
            self.check_over_forward(num_inference_steps=a_  ,			time_step=0					)




  def 						__lowercase(   self  :						str					)->							Union[str, Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					List[str]      =		self.full_loop()
       SCREAMING_SNAKE_CASE__					:					Any      =		torch.mean(torch.abs(a_					)					)

       assert abs(result_mean.item() - 0.2_3916					) < 1e-3




  def 						__lowercase(   self  :						Any					)->							Dict:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Dict      =		self.full_loop(prediction_type='v_prediction'					)
       SCREAMING_SNAKE_CASE__					:					List[str]      =		torch.mean(torch.abs(a_					)					)

       assert abs(result_mean.item() - 0.091					) < 1e-3




  def 						__lowercase(   self  :						int					)->							Optional[Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					str      =		self.scheduler_classes[0]
       SCREAMING_SNAKE_CASE__					:					str      =		self.get_scheduler_config(thresholding=a_  ,			dynamic_thresholding_ratio=0					)
       SCREAMING_SNAKE_CASE__					:					str      =		scheduler_class(**a_					)

       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		10
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		self.dummy_model()
       SCREAMING_SNAKE_CASE__					:					str      =		self.dummy_sample_deter.half()
       scheduler.set_timesteps(a_					)

       for i, t in enumerate(scheduler.timesteps					):
            SCREAMING_SNAKE_CASE__					:					int      =		model(a_  ,			a_					)
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		scheduler.step(a_  ,			a_  ,			a_					).prev_sample

       assert sample.dtype == torch.floataa










"""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 			__UpperCamelCase							(		a__						,			a__						,			unittest.TestCase		):
							lowerCamelCase  :   Optional[int]    =(
							    (
							        TFMobileBertModel,
							        TFMobileBertForMaskedLM,
							        TFMobileBertForNextSentencePrediction,
							        TFMobileBertForPreTraining,
							        TFMobileBertForQuestionAnswering,
							        TFMobileBertForSequenceClassification,
							        TFMobileBertForTokenClassification,
							        TFMobileBertForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							lowerCamelCase  :   Tuple    =(
							    {
							        """feature-extraction""": TFMobileBertModel,
							        """fill-mask""": TFMobileBertForMaskedLM,
							        """question-answering""": TFMobileBertForQuestionAnswering,
							        """text-classification""": TFMobileBertForSequenceClassification,
							        """token-classification""": TFMobileBertForTokenClassification,
							        """zero-shot""": TFMobileBertForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							lowerCamelCase  :   Any    =False
							lowerCamelCase  :   str    =False






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__=False )      ->					Any:
								a :						Dict      =							super()._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ,   return_labels=lowerCAmelCase__ )

								if return_labels:
									if model_class in get_values(lowerCAmelCase__ ):
										a :						str      =							tf.zeros(self.model_tester.batch_size ,   dtype=tf.intaa )

								return inputs_dict


							class 			__UpperCamelCase							(		a__		):






														def __init__(  self ,   lowerCAmelCase__ ,   lowerCAmelCase__=13 ,   lowerCAmelCase__=7 ,   lowerCAmelCase__=True ,   lowerCAmelCase__=True ,   lowerCAmelCase__=True ,   lowerCAmelCase__=True ,   lowerCAmelCase__=99 ,   lowerCAmelCase__=32 ,   lowerCAmelCase__=32 ,   lowerCAmelCase__=2 ,   lowerCAmelCase__=4 ,   lowerCAmelCase__=37 ,   lowerCAmelCase__="gelu" ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=512 ,   lowerCAmelCase__=16 ,   lowerCAmelCase__=2 ,   lowerCAmelCase__=0.02 ,   lowerCAmelCase__=3 ,   lowerCAmelCase__=4 ,   lowerCAmelCase__=None ,   )      ->					List[str]:
															a :						Union[str, Any]      =							parent
															a :						str      =							batch_size
															a :						Optional[int]      =							seq_length
															a :						Tuple      =							is_training
															a :						int      =							use_input_mask
															a :						Union[str, Any]      =							use_token_type_ids
															a :						List[str]      =							use_labels
															a :						str      =							vocab_size
															a :						List[Any]      =							hidden_size
															a :						Any      =							num_hidden_layers
															a :						List[Any]      =							num_attention_heads
															a :						Tuple      =							intermediate_size
															a :						str      =							hidden_act
															a :						List[Any]      =							hidden_dropout_prob
															a :						Optional[Any]      =							attention_probs_dropout_prob
															a :						Union[str, Any]      =							max_position_embeddings
															a :						Tuple      =							type_vocab_size
															a :						Union[str, Any]      =							type_sequence_label_size
															a :						Optional[int]      =							initializer_range
															a :						Any      =							num_labels
															a :						str      =							num_choices
															a :						List[Any]      =							scope
															a :						str      =							embedding_size






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

															a :						Optional[int]      =							None
															if self.use_input_mask:
																a :						int      =							random_attention_mask([self.batch_size, self.seq_length] )

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

															a :						Optional[Any]      =							None
															a :						List[str]      =							None
															a :						str      =							None
															if self.use_labels:
																a :						Dict      =							ids_tensor([self.batch_size] ,   self.type_sequence_label_size )
																a :						Optional[int]      =							ids_tensor([self.batch_size, self.seq_length] ,   self.num_labels )
																a :						str      =							ids_tensor([self.batch_size] ,   self.num_choices )

															a :						Tuple      =							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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					int:
															a :						List[Any]      =							TFMobileBertModel(config=lowerCAmelCase__ )
															a :						int      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						List[Any]      =							model(lowerCAmelCase__ )

															a :						List[str]      =							[input_ids, input_mask]
															a :						Dict      =							model(lowerCAmelCase__ )

															a :						List[str]      =							model(lowerCAmelCase__ )

															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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[Any]:
															a :						List[Any]      =							TFMobileBertForMaskedLM(config=lowerCAmelCase__ )
															a :						Union[str, Any]      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						Optional[int]      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.vocab_size) )






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					int:
															a :						int      =							TFMobileBertForNextSentencePrediction(config=lowerCAmelCase__ )
															a :						Any      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						List[str]      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.logits.shape ,   (self.batch_size, 2) )






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					List[str]:
															a :						Dict      =							TFMobileBertForPreTraining(config=lowerCAmelCase__ )
															a :						Union[str, Any]      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						List[Any]      =							model(lowerCAmelCase__ )
															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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Tuple:
															a :						List[str]      =							self.num_labels
															a :						List[str]      =							TFMobileBertForSequenceClassification(config=lowerCAmelCase__ )
															a :						Optional[Any]      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						Dict      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels) )






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Union[str, Any]:
															a :						Optional[int]      =							self.num_choices
															a :						Tuple      =							TFMobileBertForMultipleChoice(config=lowerCAmelCase__ )
															a :						Dict      =							tf.tile(tf.expand_dims(lowerCAmelCase__ ,   1 ) ,   (1, self.num_choices, 1) )
															a :						Optional[Any]      =							tf.tile(tf.expand_dims(lowerCAmelCase__ ,   1 ) ,   (1, self.num_choices, 1) )
															a :						Optional[int]      =							tf.tile(tf.expand_dims(lowerCAmelCase__ ,   1 ) ,   (1, self.num_choices, 1) )
															a :						Dict      =							{
															    "input_ids": multiple_choice_inputs_ids,
															    "attention_mask": multiple_choice_input_mask,
															    "token_type_ids": multiple_choice_token_type_ids,
															}
															a :						List[Any]      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_choices) )






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Any:
															a :						Any      =							self.num_labels
															a :						Union[str, Any]      =							TFMobileBertForTokenClassification(config=lowerCAmelCase__ )
															a :						Any      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						Any      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.num_labels) )






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					List[str]:
															a :						Dict      =							TFMobileBertForQuestionAnswering(config=lowerCAmelCase__ )
															a :						int      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						Optional[Any]      =							model(lowerCAmelCase__ )
															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        __a  (  self )      ->					List[str]:
															a :						Dict      =							self.prepare_config_and_inputs()
															(
															    (
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			
															) :						Dict      =							config_and_inputs
															a :						Optional[int]      =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
															return config, inputs_dict






							def        __a  (  self )      ->					List[str]:
								a :						List[str]      =							TFMobileBertModelTest.TFMobileBertModelTester(self )
								a :						str      =							ConfigTester(self ,   config_class=lowerCAmelCase__ ,   hidden_size=37 )






							def        __a  (  self )      ->					Any:
								self.config_tester.run_common_tests()






							def        __a  (  self )      ->					List[str]:
								a :						List[str]      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_model(*lowerCAmelCase__ )






							def        __a  (  self )      ->					Dict:
								a :						Any      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowerCAmelCase__ )






							def        __a  (  self )      ->					Any:
								a :						Union[str, Any]      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowerCAmelCase__ )






							def        __a  (  self )      ->					List[str]:
								a :						Tuple      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowerCAmelCase__ )






							def        __a  (  self )      ->					int:
								a :						List[str]      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_pretraining(*lowerCAmelCase__ )






							def        __a  (  self )      ->					int:
								a :						Dict      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_question_answering(*lowerCAmelCase__ )






							def        __a  (  self )      ->					Dict:
								a :						Optional[Any]      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowerCAmelCase__ )






							def        __a  (  self )      ->					Optional[Any]:
								a :						Optional[Any]      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_token_classification(*lowerCAmelCase__ )






							@slow
							def        __a  (  self )      ->					Any:
								# for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["google/mobilebert-uncased"]:
									a :						Union[str, Any]      =							TFMobileBertModel.from_pretrained(lowerCAmelCase__ )
									self.assertIsNotNone(lowerCAmelCase__ )


@require_tf
class 			__UpperCamelCase							(		unittest.TestCase		):






							@slow
							def        __a  (  self )      ->					Optional[int]:
								a :						Optional[int]      =							TFMobileBertForPreTraining.from_pretrained("google/mobilebert-uncased" )
								a :						Any      =							tf.constant([[0, 1, 2, 3, 4, 5]] )
								a :						int      =							model(lowerCAmelCase__ )[0]

								a :						Optional[int]      =							[1, 6, 3_0522]
								self.assertEqual(output.shape ,   lowerCAmelCase__ )

								a :						Optional[Any]      =							tf.constant(
								    [
								        [
								            [-4.5_919_547, -9.248_295, -9.645_256],
								            [-6.7_306_175, -6.440_284, -6.6_052_837],
								            [-7.2_743_506, -6.7_847_915, -6.024_673],
								        ]
								    ] )
								tf.debugging.assert_near(output[:, :3, :3] ,   lowerCAmelCase__ ,   atol=1E-4 )


