



'''simple docstring'''



import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
		from transformers.pipelines.conversational import Conversation


lowerCamelCase									=							logging.get_logger(__name__)

lowerCamelCase									=							{'''vocab_file''': '''vocab.txt''', '''emoji_file''': '''emoji.json'''}

lowerCamelCase									=							{
    '''vocab_file''': {
        '''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt''',
    },
    '''emoji_file''': {
        '''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json''',
    },
}

lowerCamelCase									=							{
    '''abeja/gpt-neox-japanese-2.7b''': 2048,
}



def 	_A							( _lowerCAmelCase	, _lowerCAmelCase       ):



							"""simple docstring"""



							with open(_lowercase	, 'r'	, encoding='utf-8'       ) as f:
														__lowercase													=json.loads(f.read()       )

							__lowercase													=collections.OrderedDict()
							__lowercase													=collections.OrderedDict()
							__lowercase													=collections.OrderedDict()
							with open(_lowercase	, 'r'	, encoding='utf-8'       ) as f:
														__lowercase													=f.readlines()
							__lowercase													=[[t.rstrip('\n'       )] if (t == "," or "," not in t) else t.rstrip('\n'       ).split(','       ) for t in token]
							for idx, b in enumerate(_lowercase       ):
														__lowercase													=b
														__lowercase													=idx
														for wd in b:
																					__lowercase													=idx

							return vocab, raw_vocab, ids_to_tokens, emoji





class _UpperCamelCase		(  a__		):





				'''simple docstring'''





				lowerCAmelCase__            =     VOCAB_FILES_NAMES
				lowerCAmelCase__            =     PRETRAINED_VOCAB_FILES_MAP
				lowerCAmelCase__            =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowerCAmelCase__            =     ["""input_ids""", """attention_mask"""]

				def __init__(				self	:	int	,							_lowerCAmelCase	:	Any	,							_lowerCAmelCase	:	Any	,							_lowerCAmelCase	:	List[Any]="<|endoftext|>"	,							_lowerCAmelCase	:	Optional[int]="<|endoftext|>"	,							_lowerCAmelCase	:	int="<|startoftext|>"	,							_lowerCAmelCase	:	List[str]="<|endoftext|>"	,							_lowerCAmelCase	:	List[str]=False	,							**_lowerCAmelCase	:	Tuple	,							):







											'''simple docstring'''

											super().__init__(
											    unk_token=lowerCAmelCase__	,							pad_token=lowerCAmelCase__	,							bos_token=lowerCAmelCase__	,							eos_token=lowerCAmelCase__	,							do_clean_text=lowerCAmelCase__	,							**lowerCAmelCase__	,							)
											if not os.path.isfile(lowerCAmelCase__):
																		raise ValueError(
																		    f"""Can't find a vocabulary file at path '{vocab_file}'. To load the vocabulary from a Google pretrained"""
																		    ' model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`')
											if not os.path.isfile(lowerCAmelCase__):
																		raise ValueError(
																		    f"""Can't find a emoji file at path '{emoji_file}'. To load the emoji information from a Google"""
																		    ' pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`')
											__lowercase													=do_clean_text
											__lowercase													=load_vocab_and_emoji(lowerCAmelCase__	,							lowerCAmelCase__)
											__lowercase													=SubWordJapaneseTokenizer(
											    vocab=self.vocab	,							ids_to_tokens=self.ids_to_tokens	,							emoji=self.emoji)

				@property
				def 					__lowerCamelCase  (				self	:	Tuple):







											'''simple docstring'''

											return len(self.raw_vocab)

				def 					__lowerCamelCase  (				self	:	List[Any]):







											'''simple docstring'''

											return dict(self.raw_vocab	,							**self.added_tokens_encoder)

				def 					__lowerCamelCase  (				self	:	List[str]	,							_lowerCAmelCase	:	Any):







											'''simple docstring'''

											return self.subword_tokenizer.tokenize(lowerCAmelCase__	,							clean=self.do_clean_text)

				def 					__lowerCamelCase  (				self	:	Any	,							_lowerCAmelCase	:	Any):







											'''simple docstring'''

											return self.vocab.get(lowerCAmelCase__	,							self.vocab.get(self.unk_token))

				def 					__lowerCamelCase  (				self	:	Optional[int]	,							_lowerCAmelCase	:	List[Any]):







											'''simple docstring'''

											return self.subword_tokenizer.convert_id_to_token(lowerCAmelCase__)

				def 					__lowerCamelCase  (				self	:	Tuple	,							_lowerCAmelCase	:	List[str]):







											'''simple docstring'''

											__lowercase													="".join(lowerCAmelCase__).strip()
											return out_string

				def 					__lowerCamelCase  (				self	:	Tuple	,							_lowerCAmelCase	:	Optional[int]):







											'''simple docstring'''

											__lowercase													=[]
											for is_user, text in conversation.iter_texts():
																		input_ids.extend(self.encode(lowerCAmelCase__	,							add_special_tokens=lowerCAmelCase__) + [self.eos_token_id])

											if len(lowerCAmelCase__) > self.model_max_length:
																		__lowercase													=input_ids[-self.model_max_length :]
											return input_ids

				def 					__lowerCamelCase  (				self	:	Optional[int]	,							_lowerCAmelCase	:	str	,							_lowerCAmelCase	:	Tuple = None):







											'''simple docstring'''

											__lowercase													=0
											if os.path.isdir(lowerCAmelCase__):
																		__lowercase													=os.path.join(
																		    lowerCAmelCase__	,							(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])
																		__lowercase													=os.path.join(
																		    lowerCAmelCase__	,							(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['emoji_file'])
											else:
																		__lowercase													=(
																		    (filename_prefix + "-" if filename_prefix else "") + save_directory + VOCAB_FILES_NAMES["vocab_file"]
																		)
																		__lowercase													=(
																		    (filename_prefix + "-" if filename_prefix else "") + save_directory + VOCAB_FILES_NAMES["emoji_file"]
																		)
											with open(lowerCAmelCase__	,							'w'	,							encoding='utf-8') as writer:
																		for token_index, token in self.ids_to_tokens.items():
																									if index != token_index:
																																logger.warning(
																																    f"""Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."""
																																    ' Please check that the vocabulary is not corrupted!')
																																__lowercase													=token_index
																									writer.write(','.join(lowerCAmelCase__) + '\n')
																									index += 1
											with open(lowerCAmelCase__	,							'w'	,							encoding='utf-8') as writer:
																		json.dump(self.emoji	,							lowerCAmelCase__)
											return vocab_file, emoji_file





class _UpperCamelCase		(  a__		):





				'''simple docstring'''





				def __init__(				self	:	str	,							_lowerCAmelCase	:	Dict	,							_lowerCAmelCase	:	int	,							_lowerCAmelCase	:	Union[str, Any]):







											'''simple docstring'''

											__lowercase													=vocab  # same as swe
											__lowercase													=ids_to_tokens  # same as bpe
											__lowercase													=emoji
											__lowercase													=np.max([len(lowerCAmelCase__) for w in self.vocab.keys()])
											__lowercase													=re.compile(R'(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)')
											__lowercase													=re.compile(R'[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*')
											__lowercase													=re.compile(R'[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}')
											__lowercase													=re.compile(
											    R'([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*')
											__lowercase													=re.compile(
											    R'(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*')
											__lowercase													=re.compile(
											    R'((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*')
											__lowercase													="─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿"
											__lowercase													="▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟"
											__lowercase													=str.maketrans({k: '<BLOCK>' for k in keisen + blocks})

				def __len__(				self	:	int):







											'''simple docstring'''

											return len(self.ids_to_tokens)

				def 					__lowerCamelCase  (				self	:	Optional[int]	,							_lowerCAmelCase	:	Any):







											'''simple docstring'''

											__lowercase													=self.content_repattera.sub('<URL>'	,							lowerCAmelCase__)
											__lowercase													=self.content_repattera.sub('<EMAIL>'	,							lowerCAmelCase__)
											__lowercase													=self.content_repattera.sub('<TEL>'	,							lowerCAmelCase__)
											__lowercase													=self.content_repattera.sub('<DATE>'	,							lowerCAmelCase__)
											__lowercase													=self.content_repattera.sub('<DATE>'	,							lowerCAmelCase__)
											__lowercase													=self.content_repattera.sub('<PRICE>'	,							lowerCAmelCase__)
											__lowercase													=content.translate(self.content_transa)
											while "<BLOCK><BLOCK>" in content:
																		__lowercase													=content.replace('<BLOCK><BLOCK>'	,							'<BLOCK>')
											return content

				def 					__lowerCamelCase  (				self	:	List[str]	,							_lowerCAmelCase	:	Optional[int]	,							_lowerCAmelCase	:	str=False):







											'''simple docstring'''

											__lowercase													=text.replace(' '	,							'<SP>')
											__lowercase													=text.replace('　'	,							'<SP>')
											__lowercase													=text.replace('\r\n'	,							'<BR>')
											__lowercase													=text.replace('\n'	,							'<BR>')
											__lowercase													=text.replace('\r'	,							'<BR>')
											__lowercase													=text.replace('\t'	,							'<TAB>')
											__lowercase													=text.replace('—'	,							'ー')
											__lowercase													=text.replace('−'	,							'ー')
											for k, v in self.emoji["emoji"].items():
																		if k in text:
																									__lowercase													=text.replace(lowerCAmelCase__	,							lowerCAmelCase__)
											if clean:
																		__lowercase													=self.clean_text(lowerCAmelCase__)

											def check_simbol(_lowerCAmelCase	:	Union[str, Any]):
																		__lowercase													=x.encode()
																		if len(lowerCAmelCase__) == 1 and len(lowerCAmelCase__) == 2:
																									__lowercase													=(int(e[0]) << 8) + int(e[1])
																									if (
																									    (c >= 0Xc_2_a_1 and c <= 0Xc_2_b_f)
																									    or (c >= 0Xc_7_8_0 and c <= 0Xc_7_8_3)
																									    or (c >= 0Xc_a_b_9 and c <= 0Xc_b_b_f)
																									    or (c >= 0Xc_c_8_0 and c <= 0Xc_d_a_2)
																									):
																																return True
																		return False

											def checkuae(_lowerCAmelCase	:	Any):
																		__lowercase													=x.encode()
																		if len(lowerCAmelCase__) == 1 and len(lowerCAmelCase__) == 3:
																									__lowercase													=(int(e[0]) << 1_6) + (int(e[1]) << 8) + int(e[2])
																									if c >= 0Xe_2_8_0_8_0 and c <= 0Xe_2_b_0_7_f:
																																return True
																		return False

											__lowercase													=0
											__lowercase													=[]
											while pos < len(lowerCAmelCase__):
																		__lowercase													=min(len(lowerCAmelCase__)	,							pos + self.maxlen + 1) if text[pos] == "<" else pos + 3
																		__lowercase													=[]  # (token_id, token, pos)
																		for e in range(lowerCAmelCase__	,							lowerCAmelCase__	,							-1):
																									__lowercase													=text[pos:e]
																									if wd in self.vocab:
																																if wd[0] == "<" and len(lowerCAmelCase__) > 2:
																																							__lowercase													=[(self.vocab[wd], wd, e)]
																																							break
																																else:
																																							candidates.append((self.vocab[wd], wd, e))
																		if len(lowerCAmelCase__) > 0:
																									# the smallest token_id is adopted
																									__lowercase													=sorted(lowerCAmelCase__	,							key=lambda _lowerCAmelCase: x[0])[0]
																									result.append(lowerCAmelCase__)
																									__lowercase													=e
																		else:
																									__lowercase													=pos + 1
																									__lowercase													=text[pos:end]
																									if check_simbol(lowerCAmelCase__):
																																result.append('<KIGOU>')
																									elif checkuae(lowerCAmelCase__):
																																result.append('<U2000U2BFF>')
																									else:
																																for i in wd.encode('utf-8'):
																																							result.append('<|byte%d|>' % i)
																									__lowercase													=end
											return result

				def 					__lowerCamelCase  (				self	:	Optional[int]	,							_lowerCAmelCase	:	Tuple	,							_lowerCAmelCase	:	Union[str, Any]="\n"):







											'''simple docstring'''

											__lowercase													=[]
											__lowercase													=[]
											__lowercase													=self.ids_to_tokens[index][0]
											if word[:6] == "<|byte" and word[-2:] == "|>":
																		byte_tokens.append(int(word[6:-2]))
											else:
																		if len(lowerCAmelCase__) > 0:
																									words.append(bytearray(lowerCAmelCase__).decode('utf-8'	,							errors='replace'))
																									__lowercase													=[]
																		if word[:7] == "<|emoji" and word[-2:] == "|>":
																									words.append(self.emoji['emoji_inv'][word])
																		elif word == "<SP>":
																									words.append(' ')
																		elif word == "<BR>":
																									words.append(lowerCAmelCase__)
																		elif word == "<TAB>":
																									words.append('\t')
																		elif word == "<BLOCK>":
																									words.append('▀')
																		elif word == "<KIGOU>":
																									words.append('ǀ')
																		elif word == "<U2000U2BFF>":
																									words.append('‖')
																		else:
																									words.append(lowerCAmelCase__)
											if len(lowerCAmelCase__) > 0:
																		words.append(bytearray(lowerCAmelCase__).decode('utf-8'	,							errors='replace'))
											__lowercase													="".join(lowerCAmelCase__)
											return text










"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    TF_MODEL_FOR_PRETRAINING_MAPPING,
		    TFMobileBertForMaskedLM,
		    TFMobileBertForMultipleChoice,
		    TFMobileBertForNextSentencePrediction,
		    TFMobileBertForPreTraining,
		    TFMobileBertForQuestionAnswering,
		    TFMobileBertForSequenceClassification,
		    TFMobileBertForTokenClassification,
		    TFMobileBertModel,
		)


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






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

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

								return inputs_dict


							class 			__UpperCamelCase							(		a__		):






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






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

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

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

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

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

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






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					int:
															a :						List[Any]      =							TFMobileBertModel(config=lowerCAmelCase__ )
															a :						int      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						List[Any]      =							model(lowerCAmelCase__ )

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

															a :						List[str]      =							model(lowerCAmelCase__ )

															self.parent.assertEqual(
															    result.last_hidden_state.shape ,   (self.batch_size, self.seq_length, self.hidden_size) )
															self.parent.assertEqual(result.pooler_output.shape ,   (self.batch_size, self.hidden_size) )






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






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






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					List[str]:
															a :						Dict      =							TFMobileBertForPreTraining(config=lowerCAmelCase__ )
															a :						Union[str, Any]      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						List[Any]      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(
															    result.prediction_logits.shape ,   (self.batch_size, self.seq_length, self.vocab_size) )
															self.parent.assertEqual(result.seq_relationship_logits.shape ,   (self.batch_size, 2) )






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






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






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






														def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					List[str]:
															a :						Dict      =							TFMobileBertForQuestionAnswering(config=lowerCAmelCase__ )
															a :						int      =							{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
															a :						Optional[Any]      =							model(lowerCAmelCase__ )
															self.parent.assertEqual(result.start_logits.shape ,   (self.batch_size, self.seq_length) )
															self.parent.assertEqual(result.end_logits.shape ,   (self.batch_size, self.seq_length) )






														def        __a  (  self )      ->					List[str]:
															a :						Dict      =							self.prepare_config_and_inputs()
															(
															    (
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			(
															    a
															),			
															) :						Dict      =							config_and_inputs
															a :						Optional[int]      =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
															return config, inputs_dict






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






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






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






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






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






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






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






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






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






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






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


@require_tf
class 			__UpperCamelCase							(		unittest.TestCase		):






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

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

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


