


'''simple docstring'''



import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__A	=logging.get_logger(__name__)


__A	={'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'}

__A	={
    'vocab_file': {
        'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json',
        'allenai/longformer-large-4096': (
            'https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json'
        ),
        'allenai/longformer-large-4096-finetuned-triviaqa': (
            'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json'
        ),
        'allenai/longformer-base-4096-extra.pos.embd.only': (
            'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json'
        ),
        'allenai/longformer-large-4096-extra.pos.embd.only': (
            'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json'
        ),
    },
    'merges_file': {
        'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt',
        'allenai/longformer-large-4096': (
            'https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt'
        ),
        'allenai/longformer-large-4096-finetuned-triviaqa': (
            'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt'
        ),
        'allenai/longformer-base-4096-extra.pos.embd.only': (
            'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt'
        ),
        'allenai/longformer-large-4096-extra.pos.embd.only': (
            'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt'
        ),
    },
}

__A	={
    'allenai/longformer-base-4096': 40_96,
    'allenai/longformer-large-4096': 40_96,
    'allenai/longformer-large-4096-finetuned-triviaqa': 40_96,
    'allenai/longformer-base-4096-extra.pos.embd.only': 40_96,
    'allenai/longformer-large-4096-extra.pos.embd.only': 40_96,
}







@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def     _UpperCamelCase      (		):
			UpperCAmelCase__  :					Any        =     (
			    list(range(ord("""!"""					) ,      ord("""~"""					) + 1					)					) + list(range(ord("""¡"""					) ,      ord("""¬"""					) + 1					)					) + list(range(ord("""®"""					) ,      ord("""ÿ"""					) + 1					)					)
			)
			UpperCAmelCase__  :					Optional[Any]        =     bs[:]
			UpperCAmelCase__  :					int        =     0
			for b in range(2**8					):
						if b not in bs:
									bs.append(UpperCamelCase__					)
									cs.append(2**8 + n					)
									n += 1
			UpperCAmelCase__  :					List[Any]        =     [chr(UpperCamelCase__					) for n in cs]
			return dict(zip(UpperCamelCase__ ,      UpperCamelCase__					)					)







def     _UpperCamelCase      (		UpperCamelCase__					):
			UpperCAmelCase__  :					Optional[int]        =     set()
			UpperCAmelCase__  :					Optional[int]        =     word[0]
			for char in word[1:]:
						pairs.add((prev_char, char)					)
						UpperCAmelCase__  :					List[Any]        =     char
			return pairs


class 		_snake_case					(     a__	):
					lowerCAmelCase      :int   =					VOCAB_FILES_NAMES
					lowerCAmelCase      :Optional[int]   =					PRETRAINED_VOCAB_FILES_MAP
					lowerCAmelCase      :Union[str, Any]   =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowerCAmelCase      :int   =					['''input_ids''', '''attention_mask''']




					def __init__(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase="replace"							,							_lowerCamelCase="<s>"							,							_lowerCamelCase="</s>"							,							_lowerCamelCase="</s>"							,							_lowerCamelCase="<s>"							,							_lowerCamelCase="<unk>"							,							_lowerCamelCase="<pad>"							,							_lowerCamelCase="<mask>"							,							_lowerCamelCase=False							,							**_lowerCamelCase							,							):
								UpperCAmelCase__  :					Dict        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else bos_token
								UpperCAmelCase__  :					int        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else eos_token
								UpperCAmelCase__  :					str        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else sep_token
								UpperCAmelCase__  :					Union[str, Any]        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else cls_token
								UpperCAmelCase__  :					Union[str, Any]        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else unk_token
								UpperCAmelCase__  :					Any        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else pad_token

								# Mask token behave like a normal word, i.e. include the space before it
								UpperCAmelCase__  :					List[str]        =     AddedToken(_lowerCamelCase							,							lstrip=_lowerCamelCase							,							rstrip=_lowerCamelCase) if isinstance(_lowerCamelCase							,							_lowerCamelCase) else mask_token

								super().__init__(
								    errors=_lowerCamelCase							,							bos_token=_lowerCamelCase							,							eos_token=_lowerCamelCase							,							unk_token=_lowerCamelCase							,							sep_token=_lowerCamelCase							,							cls_token=_lowerCamelCase							,							pad_token=_lowerCamelCase							,							mask_token=_lowerCamelCase							,							add_prefix_space=_lowerCamelCase							,							**_lowerCamelCase							,							)

								with open(_lowerCamelCase							,							encoding="""utf-8""") as vocab_handle:
											UpperCAmelCase__  :					Optional[Any]        =     json.load(_lowerCamelCase)
								UpperCAmelCase__  :					Any        =     {v: k for k, v in self.encoder.items()}
								UpperCAmelCase__  :					List[str]        =     errors  # how to handle errors in decoding
								UpperCAmelCase__  :					Optional[Any]        =     bytes_to_unicode()
								UpperCAmelCase__  :					Dict        =     {v: k for k, v in self.byte_encoder.items()}
								with open(_lowerCamelCase							,							encoding="""utf-8""") as merges_handle:
											UpperCAmelCase__  :					Optional[int]        =     merges_handle.read().split("""\n""")[1:-1]
								UpperCAmelCase__  :					Union[str, Any]        =     [tuple(merge.split()) for merge in bpe_merges]
								UpperCAmelCase__  :					str        =     dict(zip(_lowerCamelCase							,							range(len(_lowerCamelCase))))
								UpperCAmelCase__  :					Dict        =     {}
								UpperCAmelCase__  :					Dict        =     add_prefix_space

								# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
								UpperCAmelCase__  :					Optional[int]        =     re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")




					@property
					def 				snake_case__						(      self):
								return len(self.encoder)




					def 				snake_case__						(      self):
								return dict(self.encoder							,							**self.added_tokens_encoder)




					def 				snake_case__						(      self							,							_lowerCamelCase):
								if token in self.cache:
											return self.cache[token]
								UpperCAmelCase__  :					List[Any]        =     tuple(_lowerCamelCase)
								UpperCAmelCase__  :					str        =     get_pairs(_lowerCamelCase)

								if not pairs:
											return token

								while True:
											UpperCAmelCase__  :					Dict        =     min(_lowerCamelCase							,							key=lambda _lowerCamelCase: self.bpe_ranks.get(_lowerCamelCase							,							float("""inf""")))
											if bigram not in self.bpe_ranks:
														break
											UpperCAmelCase__   ,       UpperCAmelCase__  :					Tuple        =     bigram
											UpperCAmelCase__  :					str        =     []
											UpperCAmelCase__  :					int        =     0
											while i < len(_lowerCamelCase):
														try:
																	UpperCAmelCase__  :					List[str]        =     word.index(_lowerCamelCase							,							_lowerCamelCase)
														except ValueError:
																	new_word.extend(word[i:])
																	break
														else:
																	new_word.extend(word[i:j])
																	UpperCAmelCase__  :					Any        =     j

														if word[i] == first and i < len(_lowerCamelCase) - 1 and word[i + 1] == second:
																	new_word.append(first + second)
																	i += 2
														else:
																	new_word.append(word[i])
																	i += 1
											UpperCAmelCase__  :					List[Any]        =     tuple(_lowerCamelCase)
											UpperCAmelCase__  :					Any        =     new_word
											if len(_lowerCamelCase) == 1:
														break
											else:
														UpperCAmelCase__  :					str        =     get_pairs(_lowerCamelCase)
								UpperCAmelCase__  :					Optional[int]        =     """ """.join(_lowerCamelCase)
								UpperCAmelCase__  :					List[Any]        =     word
								return word




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					Dict        =     []
								for token in re.findall(self.pat							,							_lowerCamelCase):
											UpperCAmelCase__  :					Dict        =     """""".join(
											    self.byte_encoder[b] for b in token.encode("""utf-8"""))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
											bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_lowerCamelCase).split(""" """))
								return bpe_tokens




					def 				snake_case__						(      self							,							_lowerCamelCase):
								return self.encoder.get(_lowerCamelCase							,							self.encoder.get(self.unk_token))




					def 				snake_case__						(      self							,							_lowerCamelCase):
								return self.decoder.get(_lowerCamelCase)




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					Tuple        =     """""".join(_lowerCamelCase)
								UpperCAmelCase__  :					str        =     bytearray([self.byte_decoder[c] for c in text]).decode("""utf-8"""							,							errors=self.errors)
								return text




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase = None):
								if not os.path.isdir(_lowerCamelCase):
											logger.error(f'''Vocabulary path ({save_directory}) should be a directory''')
											return
								UpperCAmelCase__  :					Dict        =     os.path.join(
								    _lowerCamelCase							,							(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""])
								UpperCAmelCase__  :					int        =     os.path.join(
								    _lowerCamelCase							,							(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""])

								with open(_lowerCamelCase							,							"""w"""							,							encoding="""utf-8""") as f:
											f.write(json.dumps(self.encoder							,							indent=2							,							sort_keys=_lowerCamelCase							,							ensure_ascii=_lowerCamelCase) + """\n""")

								UpperCAmelCase__  :					Optional[Any]        =     0
								with open(_lowerCamelCase							,							"""w"""							,							encoding="""utf-8""") as writer:
											writer.write("""#version: 0.2\n""")
											for bpe_tokens, token_index in sorted(self.bpe_ranks.items()							,							key=lambda _lowerCamelCase: kv[1]):
														if index != token_index:
																	logger.warning(
																	    f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
																	    """ Please check that the tokenizer is not corrupted!""")
																	UpperCAmelCase__  :					Tuple        =     token_index
														writer.write(""" """.join(_lowerCamelCase) + """\n""")
														index += 1

								return vocab_file, merge_file




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase = None):
								if token_ids_a is None:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
								UpperCAmelCase__  :					Optional[int]        =     [self.cls_token_id]
								UpperCAmelCase__  :					Optional[Any]        =     [self.sep_token_id]
								return cls + token_ids_a + sep + sep + token_ids_a + sep




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase = None							,							_lowerCamelCase = False):
								if already_has_special_tokens:
											return super().get_special_tokens_mask(
											    token_ids_a=_lowerCamelCase							,							token_ids_a=_lowerCamelCase							,							already_has_special_tokens=_lowerCamelCase)

								if token_ids_a is None:
											return [1] + ([0] * len(_lowerCamelCase)) + [1]
								return [1] + ([0] * len(_lowerCamelCase)) + [1, 1] + ([0] * len(_lowerCamelCase)) + [1]




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase = None):
								UpperCAmelCase__  :					Union[str, Any]        =     [self.sep_token_id]
								UpperCAmelCase__  :					List[Any]        =     [self.cls_token_id]

								if token_ids_a is None:
											return len(cls + token_ids_a + sep) * [0]
								return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase=False							,							**_lowerCamelCase):
								UpperCAmelCase__  :					Optional[Any]        =     kwargs.pop("""add_prefix_space"""							,							self.add_prefix_space)
								if (is_split_into_words or add_prefix_space) and (len(_lowerCamelCase) > 0 and not text[0].isspace()):
											UpperCAmelCase__  :					Tuple        =     """ """ + text
								return (text, kwargs)



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




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase=False):
								UpperCAmelCase__  :					int        =     super()._prepare_for_class(_lowerCamelCase							,							_lowerCamelCase							,							return_labels=_lowerCamelCase)

								if return_labels:
											if model_class in get_values(_lowerCamelCase):
														UpperCAmelCase__  :					Tuple        =     tf.zeros(self.model_tester.batch_size							,							dtype=tf.intaa)

								return inputs_dict


					class 		_snake_case					(     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							,							):
													UpperCAmelCase__  :					Optional[Any]        =     parent
													UpperCAmelCase__  :					List[str]        =     batch_size
													UpperCAmelCase__  :					Any        =     seq_length
													UpperCAmelCase__  :					Dict        =     is_training
													UpperCAmelCase__  :					str        =     use_input_mask
													UpperCAmelCase__  :					int        =     use_token_type_ids
													UpperCAmelCase__  :					Optional[Any]        =     use_labels
													UpperCAmelCase__  :					Any        =     vocab_size
													UpperCAmelCase__  :					Optional[Any]        =     hidden_size
													UpperCAmelCase__  :					Optional[int]        =     num_hidden_layers
													UpperCAmelCase__  :					List[Any]        =     num_attention_heads
													UpperCAmelCase__  :					Dict        =     intermediate_size
													UpperCAmelCase__  :					str        =     hidden_act
													UpperCAmelCase__  :					int        =     hidden_dropout_prob
													UpperCAmelCase__  :					Union[str, Any]        =     attention_probs_dropout_prob
													UpperCAmelCase__  :					Optional[int]        =     max_position_embeddings
													UpperCAmelCase__  :					Union[str, Any]        =     type_vocab_size
													UpperCAmelCase__  :					Optional[int]        =     type_sequence_label_size
													UpperCAmelCase__  :					Optional[int]        =     initializer_range
													UpperCAmelCase__  :					Union[str, Any]        =     num_labels
													UpperCAmelCase__  :					List[str]        =     num_choices
													UpperCAmelCase__  :					str        =     scope
													UpperCAmelCase__  :					Optional[int]        =     embedding_size




										def 				snake_case__						(      self):
													UpperCAmelCase__  :					str        =     ids_tensor([self.batch_size, self.seq_length]							,							self.vocab_size)

													UpperCAmelCase__  :					Optional[Any]        =     None
													if self.use_input_mask:
																UpperCAmelCase__  :					Tuple        =     random_attention_mask([self.batch_size, self.seq_length])

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

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

													UpperCAmelCase__  :					str        =     MobileBertConfig(
													    vocab_size=self.vocab_size							,							hidden_size=self.hidden_size							,							num_hidden_layers=self.num_hidden_layers							,							num_attention_heads=self.num_attention_heads							,							intermediate_size=self.intermediate_size							,							hidden_act=self.hidden_act							,							hidden_dropout_prob=self.hidden_dropout_prob							,							attention_probs_dropout_prob=self.attention_probs_dropout_prob							,							max_position_embeddings=self.max_position_embeddings							,							type_vocab_size=self.type_vocab_size							,							initializer_range=self.initializer_range							,							embedding_size=self.embedding_size							,							)

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




										def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
													UpperCAmelCase__  :					str        =     TFMobileBertModel(config=_lowerCamelCase)
													UpperCAmelCase__  :					Dict        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													UpperCAmelCase__  :					int        =     model(_lowerCamelCase)

													UpperCAmelCase__  :					Dict        =     [input_ids, input_mask]
													UpperCAmelCase__  :					List[Any]        =     model(_lowerCamelCase)

													UpperCAmelCase__  :					Optional[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 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
													UpperCAmelCase__  :					List[str]        =     TFMobileBertForMaskedLM(config=_lowerCamelCase)
													UpperCAmelCase__  :					List[str]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													UpperCAmelCase__  :					Dict        =     model(_lowerCamelCase)
													self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size))




										def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
													UpperCAmelCase__  :					Union[str, Any]        =     TFMobileBertForNextSentencePrediction(config=_lowerCamelCase)
													UpperCAmelCase__  :					str        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													UpperCAmelCase__  :					List[str]        =     model(_lowerCamelCase)
													self.parent.assertEqual(result.logits.shape							,							(self.batch_size, 2))




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




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




										def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
													UpperCAmelCase__  :					List[Any]        =     self.num_labels
													UpperCAmelCase__  :					Optional[Any]        =     TFMobileBertForTokenClassification(config=_lowerCamelCase)
													UpperCAmelCase__  :					Dict        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													UpperCAmelCase__  :					List[Any]        =     model(_lowerCamelCase)
													self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.num_labels))




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




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					str        =     TFMobileBertModelTest.TFMobileBertModelTester(self)
								UpperCAmelCase__  :					List[Any]        =     ConfigTester(self							,							config_class=_lowerCamelCase							,							hidden_size=37)




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




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_model(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[int]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_masked_lm(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_multiple_choice(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					List[Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_pretraining(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_question_answering(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					str        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_sequence_classification(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Tuple        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_mobilebert_for_token_classification(*_lowerCamelCase)




					@slow
					def 				snake_case__						(      self):
								# for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["google/mobilebert-uncased"]:
											UpperCAmelCase__  :					Optional[Any]        =     TFMobileBertModel.from_pretrained(_lowerCamelCase)
											self.assertIsNotNone(_lowerCamelCase)


@require_tf
class 		_snake_case					(     unittest.TestCase	):




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

								UpperCAmelCase__  :					List[str]        =     [1, 6, 3_0522]
								self.assertEqual(output.shape							,							_lowerCamelCase)

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