


'''simple docstring'''




import shutil
import tempfile
import unittest
from unittest.mock import patch

from transformers import (
    DefaultFlowCallback,
    IntervalStrategy,
    PrinterCallback,
    ProgressCallback,
    Trainer,
    TrainerCallback,
    TrainingArguments,
    is_torch_available,
)
from transformers.testing_utils import require_torch


if is_torch_available():
				from transformers.trainer import DEFAULT_CALLBACKS

				from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel



class  lowerCAmelCase				(				__snake_case							):



	def __init__(					self    ):
		lowerCAmelCase					:    Any      							= []



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_init_end'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_train_begin'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_train_end'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_epoch_begin'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_epoch_end'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_step_begin'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_step_end'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_evaluate'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_predict'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_save'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_log'    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					**snake_case__    ):
		self.events.append('on_prediction_step'    )



@require_torch
class  lowerCAmelCase				(				unittest.TestCase							):



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Any      							= tempfile.mkdtemp()



	def 				lowercase     (					self    ):
		shutil.rmtree(self.output_dir    )



	def 				lowercase     (					self ,					snake_case__=0 ,					snake_case__=0 ,					snake_case__=64 ,					snake_case__=64 ,					snake_case__=None ,					snake_case__=False ,					**snake_case__    ):
		lowerCAmelCase					:    Dict      							= RegressionDataset(length=A_    )
		lowerCAmelCase					:    int      							= RegressionDataset(length=A_    )
		lowerCAmelCase					:    List[Any]      							= RegressionModelConfig(a=A_ ,					b=A_    )
		lowerCAmelCase					:    Any      							= RegressionPreTrainedModel(A_    )

		lowerCAmelCase					:    Any      							= TrainingArguments(self.output_dir ,					disable_tqdm=A_ ,					report_to=[] ,					**A_    )
		return Trainer(
		    A_ ,					A_ ,					train_dataset=A_ ,					eval_dataset=A_ ,					callbacks=A_ ,					)



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__    ):
		self.assertEqual(len(A_    ) ,					len(A_    )    )

		# Order doesn't matter
		lowerCAmelCase					:    Optional[int]      							= sorted(A_ ,					key=lambda snake_case__    : cb.__name__ if isinstance(A_ ,					A_    ) else cb.__class__.__name__    )
		lowerCAmelCase					:    Optional[Any]      							= sorted(A_ ,					key=lambda snake_case__    : cb.__name__ if isinstance(A_ ,					A_    ) else cb.__class__.__name__    )

		for cba, cba in zip(A_ ,					A_    ):
			if isinstance(A_ ,					A_    ) and isinstance(A_ ,					A_    ):
				self.assertEqual(A_ ,					A_    )
			elif isinstance(A_ ,					A_    ) and not isinstance(A_ ,					A_    ):
				self.assertEqual(A_ ,					cba.__class__    )
			elif not isinstance(A_ ,					A_    ) and isinstance(A_ ,					A_    ):
				self.assertEqual(cba.__class__ ,					A_    )
			else:
				self.assertEqual(A_ ,					A_    )



	def 				lowercase     (					self ,					snake_case__    ):
		lowerCAmelCase					:    Any      							= ["on_init_end", "on_train_begin"]
		lowerCAmelCase					:    int      							= 0
		lowerCAmelCase					:    str      							= len(trainer.get_eval_dataloader()    )
		lowerCAmelCase					:    Tuple      							= ["on_prediction_step"] * len(trainer.get_eval_dataloader()    ) + ["on_log", "on_evaluate"]
		for _ in range(trainer.state.num_train_epochs    ):
			expected_events.append('on_epoch_begin'    )
			for _ in range(A_    ):
				step += 1
				expected_events += ["on_step_begin", "on_step_end"]
				if step % trainer.args.logging_steps == 0:
					expected_events.append('on_log'    )
				if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0:
					expected_events += evaluation_events.copy()
				if step % trainer.args.save_steps == 0:
					expected_events.append('on_save'    )
			expected_events.append('on_epoch_end'    )
			if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH:
				expected_events += evaluation_events.copy()
		expected_events += ["on_log", "on_train_end"]
		return expected_events



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Union[str, Any]      							= self.get_trainer()
		lowerCAmelCase					:    Any      							= DEFAULT_CALLBACKS.copy() + [ProgressCallback]
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		# Callbacks passed at init are added to the default callbacks
		lowerCAmelCase					:    List[Any]      							= self.get_trainer(callbacks=[MyTestTrainerCallback]    )
		expected_callbacks.append(A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		# TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback
		lowerCAmelCase					:    List[str]      							= self.get_trainer(disable_tqdm=A_    )
		lowerCAmelCase					:    Union[str, Any]      							= DEFAULT_CALLBACKS.copy() + [PrinterCallback]
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Optional[Any]      							= DEFAULT_CALLBACKS.copy() + [ProgressCallback]
		lowerCAmelCase					:    Any      							= self.get_trainer()

		# We can add, pop, or remove by class name
		trainer.remove_callback(A_    )
		expected_callbacks.remove(A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		lowerCAmelCase					:    List[Any]      							= self.get_trainer()
		lowerCAmelCase					:    Optional[int]      							= trainer.pop_callback(A_    )
		self.assertEqual(cb.__class__ ,					A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		trainer.add_callback(A_    )
		expected_callbacks.insert(0 ,					A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		# We can also add, pop, or remove by instance
		lowerCAmelCase					:    Dict      							= self.get_trainer()
		lowerCAmelCase					:    int      							= trainer.callback_handler.callbacks[0]
		trainer.remove_callback(A_    )
		expected_callbacks.remove(A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		lowerCAmelCase					:    List[Any]      							= self.get_trainer()
		lowerCAmelCase					:    Tuple      							= trainer.callback_handler.callbacks[0]
		lowerCAmelCase					:    Optional[Any]      							= trainer.pop_callback(A_    )
		self.assertEqual(A_ ,					A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )

		trainer.add_callback(A_    )
		expected_callbacks.insert(0 ,					A_    )
		self.check_callbacks_equality(trainer.callback_handler.callbacks ,					A_    )



	def 				lowercase     (					self    ):
		import warnings

		# XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested
		warnings.simplefilter(action='ignore' ,					category=A_    )

		lowerCAmelCase					:    str      							= self.get_trainer(callbacks=[MyTestTrainerCallback]    )
		trainer.train()
		lowerCAmelCase					:    List[str]      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		# Independent log/save/eval
		lowerCAmelCase					:    int      							= self.get_trainer(callbacks=[MyTestTrainerCallback] ,					logging_steps=5    )
		trainer.train()
		lowerCAmelCase					:    Any      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		lowerCAmelCase					:    Union[str, Any]      							= self.get_trainer(callbacks=[MyTestTrainerCallback] ,					save_steps=5    )
		trainer.train()
		lowerCAmelCase					:    int      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		lowerCAmelCase					:    Tuple      							= self.get_trainer(callbacks=[MyTestTrainerCallback] ,					eval_steps=5 ,					evaluation_strategy='steps'    )
		trainer.train()
		lowerCAmelCase					:    str      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		lowerCAmelCase					:    Dict      							= self.get_trainer(callbacks=[MyTestTrainerCallback] ,					evaluation_strategy='epoch'    )
		trainer.train()
		lowerCAmelCase					:    str      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		# A bit of everything
		lowerCAmelCase					:    Optional[Any]      							= self.get_trainer(
		    callbacks=[MyTestTrainerCallback] ,					logging_steps=3 ,					save_steps=10 ,					eval_steps=5 ,					evaluation_strategy='steps' ,					)
		trainer.train()
		lowerCAmelCase					:    List[Any]      							= trainer.callback_handler.callbacks[-2].events
		self.assertEqual(A_ ,					self.get_expected_events(A_    )    )

		# warning should be emitted for duplicated callbacks
		with patch('transformers.trainer_callback.logger.warning'    ) as warn_mock:
			lowerCAmelCase					:    Dict      							= self.get_trainer(
			    callbacks=[MyTestTrainerCallback, MyTestTrainerCallback] ,					)
			assert str(A_    ) in warn_mock.call_args[0][0]




'''simple docstring'''




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  lowerCAmelCase				:



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



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    List[Any]      							= ids_tensor([self.batch_size, self.seq_length] ,					self.vocab_size    )

		lowerCAmelCase					:    Union[str, Any]      							= None
		if self.use_input_mask:
			lowerCAmelCase					:    Dict      							= random_attention_mask([self.batch_size, self.seq_length]    )

		lowerCAmelCase					:    Optional[int]      							= None
		if self.use_token_type_ids:
			lowerCAmelCase					:    List[str]      							= ids_tensor([self.batch_size, self.seq_length] ,					self.type_vocab_size    )

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

		lowerCAmelCase					:    Tuple      							= self.get_config()

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



	def 				lowercase     (					self    ):
		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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    Optional[int]      							= MobileBertModel(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    int      							= model(snake_case__ ,					attention_mask=snake_case__ ,					token_type_ids=snake_case__    )
		lowerCAmelCase					:    Optional[int]      							= model(snake_case__ ,					token_type_ids=snake_case__    )
		lowerCAmelCase					:    Optional[Any]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    int      							= MobileBertForMaskedLM(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    str      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    Union[str, Any]      							= MobileBertForNextSentencePrediction(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    str      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    List[Any]      							= MobileBertForPreTraining(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    Tuple      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    Union[str, Any]      							= MobileBertForQuestionAnswering(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    List[str]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    Optional[int]      							= self.num_labels
		lowerCAmelCase					:    List[Any]      							= MobileBertForSequenceClassification(snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    Union[str, Any]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    Union[str, Any]      							= self.num_labels
		lowerCAmelCase					:    int      							= MobileBertForTokenClassification(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    Union[str, Any]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__ ,					snake_case__    ):
		lowerCAmelCase					:    List[str]      							= self.num_choices
		lowerCAmelCase					:    Any      							= MobileBertForMultipleChoice(config=snake_case__    )
		model.to(snake_case__    )
		model.eval()
		lowerCAmelCase					:    Dict      							= input_ids.unsqueeze(1    ).expand(-1 ,					self.num_choices ,					-1    ).contiguous()
		lowerCAmelCase					:    int      							= token_type_ids.unsqueeze(1    ).expand(-1 ,					self.num_choices ,					-1    ).contiguous()
		lowerCAmelCase					:    Union[str, Any]      							= input_mask.unsqueeze(1    ).expand(-1 ,					self.num_choices ,					-1    ).contiguous()
		lowerCAmelCase					:    List[str]      							= 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 				lowercase     (					self    ):
		lowerCAmelCase					:    Any      							= self.prepare_config_and_inputs()
		(
		    (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   (
		    lowerCAmelCase
		)							,   
		)					:    Optional[Any]      							= config_and_inputs
		lowerCAmelCase					:    List[Any]      							= {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
		return config, inputs_dict



@require_torch
class  lowerCAmelCase				(				a      ,				a      ,				unittest.TestCase							):
	_lowerCamelCase   :					List[str]			      = (
	    (
	        MobileBertModel,
	        MobileBertForMaskedLM,
	        MobileBertForMultipleChoice,
	        MobileBertForNextSentencePrediction,
	        MobileBertForPreTraining,
	        MobileBertForQuestionAnswering,
	        MobileBertForSequenceClassification,
	        MobileBertForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	_lowerCamelCase   :					Tuple			      = (
	    {
	        """feature-extraction""": MobileBertModel,
	        """fill-mask""": MobileBertForMaskedLM,
	        """question-answering""": MobileBertForQuestionAnswering,
	        """text-classification""": MobileBertForSequenceClassification,
	        """token-classification""": MobileBertForTokenClassification,
	        """zero-shot""": MobileBertForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	_lowerCamelCase   :					str			      = True



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__ ,					snake_case__=False    ):
		lowerCAmelCase					:    int      							= super()._prepare_for_class(snake_case__ ,					snake_case__ ,					return_labels=snake_case__    )

		if return_labels:
			if model_class in get_values(snake_case__    ):
				lowerCAmelCase					:    str      							= torch.zeros(
				    (self.model_tester.batch_size, self.model_tester.seq_length) ,					dtype=torch.long ,					device=snake_case__    )
				lowerCAmelCase					:    Tuple      							= torch.zeros(
				    self.model_tester.batch_size ,					dtype=torch.long ,					device=snake_case__    )
		return inputs_dict



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    List[Any]      							= MobileBertModelTester(self    )
		lowerCAmelCase					:    Dict      							= ConfigTester(self ,					config_class=snake_case__ ,					hidden_size=37    )



	def 				lowercase     (					self    ):
		self.config_tester.run_common_tests()



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    int      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_model(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Union[str, Any]      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Tuple      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Union[str, Any]      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    str      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    int      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Any      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__    )



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Optional[Any]      							= self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__    )


def 			__UpperCamelCase    (    _A    :				Optional[Any]				)    ->      Optional[int]:




	"""simple docstring"""





	return torch.tensor(
	    _A					,   dtype=torch.long					,   device=_A					,   )


_lowerCAmelCase  :		Union[str, Any]		     =	1E-3






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



	@slow
	def 				lowercase     (					self    ):
		lowerCAmelCase					:    List[str]      							= MobileBertModel.from_pretrained('google/mobilebert-uncased'    ).to(snake_case__    )
		lowerCAmelCase					:    List[Any]      							= _long_tensor([[101, 7110, 1005, 1056, 2023, 1_1333, 1_7413, 1029, 102]]    )
		with torch.no_grad():
			lowerCAmelCase					:    Tuple      							= model(snake_case__    )[0]
		lowerCAmelCase					:    List[Any]      							= torch.Size((1, 9, 512)    )
		self.assertEqual(output.shape ,					snake_case__    )
		lowerCAmelCase					:    Union[str, Any]      							= torch.tensor(
		    [
		        [
		            [-2.4_7_3_6_5_2_6e0_7, 8.2_6_9_1_6_5_6e0_4, 1.6_5_2_1_8_3_8e0_5],
		            [-5.7_5_4_1_7_0_4e-0_1, 3.9_0_5_6_0_2_2e0_0, 4.4_0_1_1_5_0_7e0_0],
		            [2.6_0_4_7_3_5_9e0_0, 1.5_6_7_7_6_5_2e0_0, -1.7_3_2_4_1_8_8e-0_1],
		        ]
		    ] ,					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
		lowerCAmelCase					:    List[str]      							= torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE    )
		lowerCAmelCase					:    Dict      							= torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE    )

		self.assertTrue(lower_bound and upper_bound    )
