


'''simple docstring'''




import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
				from cookiecutter.main import cookiecutter

				_lowerCAmelCase  :		Optional[Any]		     =	True
except ImportError:
				_lowerCAmelCase  :		List[str]		     =	False

_lowerCAmelCase  :		Any		     =	logging.get_logger(__name__)  # pylint: disable=invalid-name

def 			__UpperCamelCase    (    _A    :				Namespace				)    ->      Any:




	"""simple docstring"""





	return AddNewModelCommand(args.testing					,   args.testing_file					,   path=args.path				)






class  lowerCAmelCase				(				a							):



	@staticmethod
	def 				lowercase     (					snake_case__    ):
		lowerCAmelCase					:    Any      							= parser.add_parser('add-new-model'    )
		add_new_model_parser.add_argument('--testing' ,					action='store_true' ,					help='If in testing mode.'    )
		add_new_model_parser.add_argument('--testing_file' ,					type=snake_case__ ,					help='Configuration file on which to run.'    )
		add_new_model_parser.add_argument(
		    '--path' ,					type=snake_case__ ,					help='Path to cookiecutter. Should only be used for testing purposes.'    )
		add_new_model_parser.set_defaults(func=snake_case__    )



	def __init__(					self ,					snake_case__ ,					snake_case__ ,					snake_case__=None ,					*snake_case__    ):
		lowerCAmelCase					:    List[Any]      							= testing
		lowerCAmelCase					:    Any      							= testing_file
		lowerCAmelCase					:    Any      							= path



	def 				lowercase     (					self    ):
		warnings.warn(
		    'The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. '
		    'It is not actively maintained anymore, so might give a result that won\'t pass all tests and quality '
		    'checks, you should use `transformers-cli add-new-model-like` instead.'    )
		if not _has_cookiecutter:
			raise ImportError(
			    'Model creation dependencies are required to use the `add_new_model` command. Install them by running '
			    'the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n'    )
		# Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
		lowerCAmelCase					:    Optional[Any]      							= [directory for directory in os.listdir() if 'cookiecutter-template-' == directory[:22]]
		if len(snake_case__    ) > 0:
			raise ValueError(
			    'Several directories starting with `cookiecutter-template-` in current working directory. '
			    'Please clean your directory by removing all folders starting with `cookiecutter-template-` or '
			    'change your working directory.'    )

		lowerCAmelCase					:    str      							= (
		    Path(snake_case__    ).parent.parent.parent.parent if self._path is None else Path(self._path    ).parent.parent
		)
		lowerCAmelCase					:    Tuple      							= path_to_transformer_root / 'templates' / 'adding_a_new_model'

		# Execute cookiecutter
		if not self._testing:
			cookiecutter(str(snake_case__    )    )
		else:
			with open(self._testing_file ,					'r'    ) as configuration_file:
				lowerCAmelCase					:    Optional[Any]      							= json.load(snake_case__    )

			cookiecutter(
			    str(path_to_cookiecutter if self._path is None else self._path    ) ,					no_input=snake_case__ ,					extra_context=snake_case__ ,					)

		lowerCAmelCase					:    Union[str, Any]      							= [directory for directory in os.listdir() if 'cookiecutter-template-' in directory[:22]][0]

		# Retrieve configuration
		with open(directory + '/configuration.json' ,					'r'    ) as configuration_file:
			lowerCAmelCase					:    Any      							= json.load(snake_case__    )

		lowerCAmelCase					:    Union[str, Any]      							= configuration['lowercase_modelname']
		lowerCAmelCase					:    Optional[Any]      							= configuration['generate_tensorflow_pytorch_and_flax']
		os.remove(f"{directory}/configuration.json"    )

		lowerCAmelCase					:    Any      							= 'PyTorch' in generate_tensorflow_pytorch_and_flax
		lowerCAmelCase					:    Dict      							= 'TensorFlow' in generate_tensorflow_pytorch_and_flax
		lowerCAmelCase					:    int      							= 'Flax' in generate_tensorflow_pytorch_and_flax

		lowerCAmelCase					:    str      							= f"{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}"
		os.makedirs(snake_case__ ,					exist_ok=snake_case__    )
		os.makedirs(f"{path_to_transformer_root}/tests/models/{lowercase_model_name}" ,					exist_ok=snake_case__    )

		# Tests require submodules as they have parent imports
		with open(f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py" ,					'w'    ):
			pass

		shutil.move(
		    f"{directory}/__init__.py" ,					f"{model_dir}/__init__.py" ,					)
		shutil.move(
		    f"{directory}/configuration_{lowercase_model_name}.py" ,					f"{model_dir}/configuration_{lowercase_model_name}.py" ,					)

		def remove_copy_lines(snake_case__    ):
			with open(snake_case__ ,					'r'    ) as f:
				lowerCAmelCase					:    Union[str, Any]      							= f.readlines()
			with open(snake_case__ ,					'w'    ) as f:
				for line in lines:
					if "# Copied from transformers." not in line:
						f.write(snake_case__    )

		if output_pytorch:
			if not self._testing:
				remove_copy_lines(f"{directory}/modeling_{lowercase_model_name}.py"    )

			shutil.move(
			    f"{directory}/modeling_{lowercase_model_name}.py" ,					f"{model_dir}/modeling_{lowercase_model_name}.py" ,					)

			shutil.move(
			    f"{directory}/test_modeling_{lowercase_model_name}.py" ,					f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py" ,					)
		else:
			os.remove(f"{directory}/modeling_{lowercase_model_name}.py"    )
			os.remove(f"{directory}/test_modeling_{lowercase_model_name}.py"    )

		if output_tensorflow:
			if not self._testing:
				remove_copy_lines(f"{directory}/modeling_tf_{lowercase_model_name}.py"    )

			shutil.move(
			    f"{directory}/modeling_tf_{lowercase_model_name}.py" ,					f"{model_dir}/modeling_tf_{lowercase_model_name}.py" ,					)

			shutil.move(
			    f"{directory}/test_modeling_tf_{lowercase_model_name}.py" ,					f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py" ,					)
		else:
			os.remove(f"{directory}/modeling_tf_{lowercase_model_name}.py"    )
			os.remove(f"{directory}/test_modeling_tf_{lowercase_model_name}.py"    )

		if output_flax:
			if not self._testing:
				remove_copy_lines(f"{directory}/modeling_flax_{lowercase_model_name}.py"    )

			shutil.move(
			    f"{directory}/modeling_flax_{lowercase_model_name}.py" ,					f"{model_dir}/modeling_flax_{lowercase_model_name}.py" ,					)

			shutil.move(
			    f"{directory}/test_modeling_flax_{lowercase_model_name}.py" ,					f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py" ,					)
		else:
			os.remove(f"{directory}/modeling_flax_{lowercase_model_name}.py"    )
			os.remove(f"{directory}/test_modeling_flax_{lowercase_model_name}.py"    )

		shutil.move(
		    f"{directory}/{lowercase_model_name}.md" ,					f"{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md" ,					)

		shutil.move(
		    f"{directory}/tokenization_{lowercase_model_name}.py" ,					f"{model_dir}/tokenization_{lowercase_model_name}.py" ,					)

		shutil.move(
		    f"{directory}/tokenization_fast_{lowercase_model_name}.py" ,					f"{model_dir}/tokenization_{lowercase_model_name}_fast.py" ,					)

		from os import fdopen, remove
		from shutil import copymode, move
		from tempfile import mkstemp

		def replace(snake_case__ ,					snake_case__ ,					snake_case__    ):
			# Create temp file
			lowerCAmelCase							,   lowerCAmelCase					:    Dict      							= mkstemp()
			lowerCAmelCase					:    Any      							= False
			with fdopen(snake_case__ ,					'w'    ) as new_file:
				with open(snake_case__    ) as old_file:
					for line in old_file:
						new_file.write(snake_case__    )
						if line_to_copy_below in line:
							lowerCAmelCase					:    Tuple      							= True
							for line_to_copy in lines_to_copy:
								new_file.write(snake_case__    )

			if not line_found:
				raise ValueError(f"Line {line_to_copy_below} was not found in file."    )

			# Copy the file permissions from the old file to the new file
			copymode(snake_case__ ,					snake_case__    )
			# Remove original file
			remove(snake_case__    )
			# Move new file
			move(snake_case__ ,					snake_case__    )

		def skip_units(snake_case__    ):
			return (
			    ("generating PyTorch" in line and not output_pytorch)
			    or ("generating TensorFlow" in line and not output_tensorflow)
			    or ("generating Flax" in line and not output_flax)
			)

		def replace_in_files(snake_case__    ):
			with open(snake_case__    ) as datafile:
				lowerCAmelCase					:    Union[str, Any]      							= []
				lowerCAmelCase					:    Dict      							= False
				lowerCAmelCase					:    Any      							= False
				for line in datafile:
					if "# To replace in: " in line and "##" not in line:
						lowerCAmelCase					:    Dict      							= line.split('"'    )[1]
						lowerCAmelCase					:    List[str]      							= skip_units(snake_case__    )
					elif "# Below: " in line and "##" not in line:
						lowerCAmelCase					:    Tuple      							= line.split('"'    )[1]
						lowerCAmelCase					:    Any      							= skip_units(snake_case__    )
					elif "# End." in line and "##" not in line:
						if not skip_file and not skip_snippet:
							replace(snake_case__ ,					snake_case__ ,					snake_case__    )

						lowerCAmelCase					:    Any      							= []
					elif "# Replace with" in line and "##" not in line:
						lowerCAmelCase					:    Optional[Any]      							= []
					elif "##" not in line:
						lines_to_copy.append(snake_case__    )

			remove(snake_case__    )

		replace_in_files(f"{directory}/to_replace_{lowercase_model_name}.py"    )
		os.rmdir(snake_case__    )




'''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    )
