






"""simple docstring"""
import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_lowerCAmelCase       =				"▁"

_lowerCAmelCase       =				get_tests_dir("fixtures/test_sentencepiece.model")



@require_sentencepiece
@require_tokenizers
class   SCREAMING_SNAKE_CASE	(					_SCREAMING_SNAKE_CASE							,							unittest.TestCase    ):





	"""simple docstring"""




	_A							:					List[str] 			=					BigBirdTokenizer
	_A							:					List[str] 			=					BigBirdTokenizerFast
	_A							:					str 			=					True
	_A							:					int 			=					True





	def  lowerCamelCase(self				):
		super().setUp()

		A_		:    Optional[int]						     = self.tokenizer_class(lowerCAmelCase_  ,  keep_accents=lowerCAmelCase_				)
		tokenizer.save_pretrained(self.tmpdirname				)





	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = """<s>"""
		A_		:    Tuple						     = 1

		self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCAmelCase_				)  ,  lowerCAmelCase_				)
		self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCAmelCase_				)  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = list(self.get_tokenizer().get_vocab().keys()				)

		self.assertEqual(vocab_keys[0]  ,  """<unk>"""				)
		self.assertEqual(vocab_keys[1]  ,  """<s>"""				)
		self.assertEqual(vocab_keys[-1]  ,  """[MASK]"""				)
		self.assertEqual(len(lowerCAmelCase_				)  ,  1004				)





	def  lowerCamelCase(self				):
		self.assertEqual(self.get_tokenizer().vocab_size  ,  1000				)





	def  lowerCamelCase(self				):
		if not self.test_rust_tokenizer:
			return

		A_		:    int						     = self.get_tokenizer()
		A_		:    str						     = self.get_rust_tokenizer()

		A_		:    int						     = """I was born in 92000, and this is falsé."""

		A_		:    Union[str, Any]						     = tokenizer.tokenize(lowerCAmelCase_				)
		A_		:    str						     = rust_tokenizer.tokenize(lowerCAmelCase_				)
		self.assertListEqual(lowerCAmelCase_  ,  lowerCAmelCase_				)

		A_		:    Dict						     = tokenizer.encode(lowerCAmelCase_  ,  add_special_tokens=lowerCAmelCase_				)
		A_		:    int						     = rust_tokenizer.encode(lowerCAmelCase_  ,  add_special_tokens=lowerCAmelCase_				)
		self.assertListEqual(lowerCAmelCase_  ,  lowerCAmelCase_				)

		A_		:    List[Any]						     = self.get_rust_tokenizer()
		A_		:    List[Any]						     = tokenizer.encode(lowerCAmelCase_				)
		A_		:    Optional[Any]						     = rust_tokenizer.encode(lowerCAmelCase_				)
		self.assertListEqual(lowerCAmelCase_  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    int						     = BigBirdTokenizer(lowerCAmelCase_  ,  keep_accents=lowerCAmelCase_				)

		A_		:    Union[str, Any]						     = tokenizer.tokenize("""This is a test"""				)
		self.assertListEqual(lowerCAmelCase_  ,  ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

		self.assertListEqual(
		    tokenizer.convert_tokens_to_ids(lowerCAmelCase_				)  ,  [285, 46, 10, 170, 382]  ,  )

		A_		:    int						     = tokenizer.tokenize("""I was born in 92000, and this is falsé."""				)
		self.assertListEqual(
		    lowerCAmelCase_  ,  [
		        SPIECE_UNDERLINE + """I""",
		        SPIECE_UNDERLINE + """was""",
		        SPIECE_UNDERLINE + """b""",
		        """or""",
		        """n""",
		        SPIECE_UNDERLINE + """in""",
		        SPIECE_UNDERLINE + """""",
		        """9""",
		        """2""",
		        """0""",
		        """0""",
		        """0""",
		        """,""",
		        SPIECE_UNDERLINE + """and""",
		        SPIECE_UNDERLINE + """this""",
		        SPIECE_UNDERLINE + """is""",
		        SPIECE_UNDERLINE + """f""",
		        """al""",
		        """s""",
		        """é""",
		        """.""",
		    ]  ,  )
		A_		:    Dict						     = tokenizer.convert_tokens_to_ids(lowerCAmelCase_				)
		self.assertListEqual(
		    lowerCAmelCase_  ,  [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]  ,  )

		A_		:    Union[str, Any]						     = tokenizer.convert_ids_to_tokens(lowerCAmelCase_				)
		self.assertListEqual(
		    lowerCAmelCase_  ,  [
		        SPIECE_UNDERLINE + """I""",
		        SPIECE_UNDERLINE + """was""",
		        SPIECE_UNDERLINE + """b""",
		        """or""",
		        """n""",
		        SPIECE_UNDERLINE + """in""",
		        SPIECE_UNDERLINE + """""",
		        """<unk>""",
		        """2""",
		        """0""",
		        """0""",
		        """0""",
		        """,""",
		        SPIECE_UNDERLINE + """and""",
		        SPIECE_UNDERLINE + """this""",
		        SPIECE_UNDERLINE + """is""",
		        SPIECE_UNDERLINE + """f""",
		        """al""",
		        """s""",
		        """<unk>""",
		        """.""",
		    ]  ,  )





	@cached_property
	def  lowerCamelCase(self				):
		return BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""				)





	@slow
	def  lowerCamelCase(self				):
		A_		:    List[Any]						     = """Hello World!"""
		A_		:    str						     = [65, 18536, 2260, 101, 66]

		self.assertListEqual(lowerCAmelCase_  ,  self.big_tokenizer.encode(lowerCAmelCase_				)				)





	@slow
	def  lowerCamelCase(self				):
		A_		:    str						     = (
		    """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
		    """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
		)
		# fmt: off
		A_		:    List[str]						     = [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66]  # noqa: E231
		# fmt: on
		self.assertListEqual(lowerCAmelCase_  ,  self.big_tokenizer.encode(lowerCAmelCase_				)				)





	@require_torch
	@slow
	def  lowerCamelCase(self				):
		import torch

		from transformers import BigBirdConfig, BigBirdModel

		# Build sequence
		A_		:    Union[str, Any]						     = list(self.big_tokenizer.get_vocab().keys()				)[:10]
		A_		:    Tuple						     = """ """.join(lowerCAmelCase_				)
		A_		:    Union[str, Any]						     = self.big_tokenizer.encode_plus(lowerCAmelCase_  ,  return_tensors="""pt"""  ,  return_token_type_ids=lowerCAmelCase_				)
		A_		:    Tuple						     = self.big_tokenizer.batch_encode_plus(
		    [sequence + """ """ + sequence]  ,  return_tensors="""pt"""  ,  return_token_type_ids=lowerCAmelCase_				)

		A_		:    int						     = BigBirdConfig(attention_type="""original_full"""				)
		A_		:    Dict						     = BigBirdModel(lowerCAmelCase_				)

		assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

		with torch.no_grad():
			model(**lowerCAmelCase_				)
			model(**lowerCAmelCase_				)





	@slow
	def  lowerCamelCase(self				):
		A_		:    str						     = BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""				)
		A_		:    Optional[Any]						     = tokenizer.decode(tokenizer("""Paris is the [MASK]."""				).input_ids				)

		self.assertTrue(decoded_text == """[CLS] Paris is the[MASK].[SEP]"""				)





	@slow
	def  lowerCamelCase(self				):
		# fmt: off
		A_		:    Dict						     = {"""input_ids""": [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
		# fmt: on

		self.tokenizer_integration_test_util(
		    expected_encoding=lowerCAmelCase_  ,  model_name="""google/bigbird-roberta-base"""  ,  revision="""215c99f1600e06f83acce68422f2035b2b5c3510"""  ,  )









"""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   SCREAMING_SNAKE_CASE	:





	"""simple docstring"""




	def __init__(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_=13  ,  lowerCAmelCase_=7  ,  lowerCAmelCase_=True  ,  lowerCAmelCase_=True  ,  lowerCAmelCase_=True  ,  lowerCAmelCase_=True  ,  lowerCAmelCase_=99  ,  lowerCAmelCase_=64  ,  lowerCAmelCase_=32  ,  lowerCAmelCase_=5  ,  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  ,  ):
		A_		:    Optional[Any]						     = parent
		A_		:    List[str]						     = batch_size
		A_		:    List[str]						     = seq_length
		A_		:    List[str]						     = is_training
		A_		:    Optional[Any]						     = use_input_mask
		A_		:    Dict						     = use_token_type_ids
		A_		:    Any						     = use_labels
		A_		:    Tuple						     = vocab_size
		A_		:    Optional[Any]						     = hidden_size
		A_		:    Tuple						     = embedding_size
		A_		:    Tuple						     = num_hidden_layers
		A_		:    Any						     = num_attention_heads
		A_		:    Optional[int]						     = intermediate_size
		A_		:    Union[str, Any]						     = hidden_act
		A_		:    Optional[int]						     = hidden_dropout_prob
		A_		:    Optional[Any]						     = attention_probs_dropout_prob
		A_		:    str						     = max_position_embeddings
		A_		:    str						     = type_vocab_size
		A_		:    Optional[Any]						     = type_sequence_label_size
		A_		:    List[str]						     = initializer_range
		A_		:    str						     = num_labels
		A_		:    Dict						     = num_choices
		A_		:    Any						     = scope





	def  lowerCamelCase(self				):
		A_		:    Any						     = ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size				)

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

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

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

		A_		:    Tuple						     = self.get_config()

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





	def  lowerCamelCase(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=lowerCAmelCase_  ,  initializer_range=self.initializer_range  ,  )





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    str						     = MobileBertModel(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    Optional[int]						     = model(lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_				)
		A_		:    Union[str, Any]						     = model(lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_				)
		A_		:    int						     = 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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Optional[int]						     = MobileBertForMaskedLM(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    List[Any]						     = model(lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_				)
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.vocab_size)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Optional[int]						     = MobileBertForNextSentencePrediction(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    Tuple						     = model(
		    lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_  ,  )
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, 2)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    int						     = MobileBertForPreTraining(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    Union[str, Any]						     = model(
		    lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_  ,  next_sentence_label=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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Union[str, Any]						     = MobileBertForQuestionAnswering(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    Tuple						     = model(
		    lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  start_positions=lowerCAmelCase_  ,  end_positions=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  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    int						     = self.num_labels
		A_		:    Optional[int]						     = MobileBertForSequenceClassification(lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    int						     = model(lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_				)
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_labels)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    str						     = self.num_labels
		A_		:    int						     = MobileBertForTokenClassification(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    str						     = model(lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_				)
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.num_labels)				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    str						     = self.num_choices
		A_		:    int						     = MobileBertForMultipleChoice(config=lowerCAmelCase_				)
		model.to(lowerCAmelCase_				)
		model.eval()
		A_		:    Tuple						     = input_ids.unsqueeze(1				).expand(-1  ,  self.num_choices  ,  -1				).contiguous()
		A_		:    str						     = token_type_ids.unsqueeze(1				).expand(-1  ,  self.num_choices  ,  -1				).contiguous()
		A_		:    Optional[int]						     = input_mask.unsqueeze(1				).expand(-1  ,  self.num_choices  ,  -1				).contiguous()
		A_		:    Union[str, Any]						     = model(
		    lowerCAmelCase_  ,  attention_mask=lowerCAmelCase_  ,  token_type_ids=lowerCAmelCase_  ,  labels=lowerCAmelCase_  ,  )
		self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_choices)				)





	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = self.prepare_config_and_inputs()
		(
		    (
		    A_
		)     ,  (
		    A_
		)     ,  (
		    A_
		)     ,  (
		    A_
		)     ,  (
		    A_
		)     ,  (
		    A_
		)     ,  (
		    A_
		)     ,  
		)		:    Dict						     = config_and_inputs
		A_		:    Any						     = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
		return config, inputs_dict






@require_torch
class   SCREAMING_SNAKE_CASE	(					_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							unittest.TestCase    ):





	"""simple docstring"""




	_A							:					Dict 			=					(
	    (
	        MobileBertModel,
	        MobileBertForMaskedLM,
	        MobileBertForMultipleChoice,
	        MobileBertForNextSentencePrediction,
	        MobileBertForPreTraining,
	        MobileBertForQuestionAnswering,
	        MobileBertForSequenceClassification,
	        MobileBertForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	_A							:					Union[str, Any] 			=					(
	    {
	        """feature-extraction""": MobileBertModel,
	        """fill-mask""": MobileBertForMaskedLM,
	        """question-answering""": MobileBertForQuestionAnswering,
	        """text-classification""": MobileBertForSequenceClassification,
	        """token-classification""": MobileBertForTokenClassification,
	        """zero-shot""": MobileBertForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	_A							:					Union[str, Any] 			=					True





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_=False				):
		A_		:    Optional[int]						     = super()._prepare_for_class(lowerCAmelCase_  ,  lowerCAmelCase_  ,  return_labels=lowerCAmelCase_				)

		if return_labels:
			if model_class in get_values(lowerCAmelCase_				):
				A_		:    List[Any]						     = torch.zeros(
				    (self.model_tester.batch_size, self.model_tester.seq_length)  ,  dtype=torch.long  ,  device=lowerCAmelCase_				)
				A_		:    Optional[int]						     = torch.zeros(
				    self.model_tester.batch_size  ,  dtype=torch.long  ,  device=lowerCAmelCase_				)
		return inputs_dict





	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = MobileBertModelTester(self				)
		A_		:    Optional[Any]						     = ConfigTester(self  ,  config_class=lowerCAmelCase_  ,  hidden_size=37				)





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





	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_model(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Tuple						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Dict						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_pretraining(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Any						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_question_answering(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Dict						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowerCAmelCase_				)





	def  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_mobilebert_for_token_classification(*lowerCAmelCase_				)






def       __UpperCamelCase						(		snake_case__       ):
	return torch.tensor(
	    snake_case__ , dtype=torch.long , device=snake_case__ , )


_lowerCAmelCase       =				1e-3




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





	"""simple docstring"""




	@slow
	def  lowerCamelCase(self				):
		A_		:    Union[str, Any]						     = MobileBertModel.from_pretrained("""google/mobilebert-uncased"""				).to(lowerCAmelCase_				)
		A_		:    Any						     = _long_tensor([[101, 7110, 1005, 1056, 2023, 11333, 17413, 1029, 102]]				)
		with torch.no_grad():
			A_		:    Dict						     = model(lowerCAmelCase_				)[0]
		A_		:    Any						     = torch.Size((1, 9, 512)				)
		self.assertEqual(output.shape  ,  lowerCAmelCase_				)
		A_		:    Optional[int]						     = 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=lowerCAmelCase_  ,  )

		# 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
		A_		:    List[str]						     = torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE				)
		A_		:    Any						     = torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE				)

		self.assertTrue(lower_bound and upper_bound				)

