
"""simple docstring"""




import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


UpperCAmelCase__   :					List[str]												=				get_logger(__name__)


UpperCAmelCase__   :					Optional[Any]												=				r'\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n'



class 			lowerCAmelCase_		:


				"""simple docstring"""



				@add_start_docstrings(SCREAMING_SNAKE_CASE__					)
				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											raise NotImplementedError(
											    F'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''					)






class 			lowerCAmelCase_		:


				"""simple docstring"""



				@add_start_docstrings(SCREAMING_SNAKE_CASE__					)
				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											raise NotImplementedError(
											    F'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''					)






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				@add_start_docstrings(SCREAMING_SNAKE_CASE__					)
				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											for processor in self:
																		SCREAMING_SNAKE_CASE__		: str     =     inspect.signature(processor.__call__					).parameters
																		if len(SCREAMING_SNAKE_CASE__					) > 3:
																									if not all(arg in kwargs for arg in list(function_args.keys()					)[2:]					):
																																raise ValueError(
																																    F'''Make sure that all the required parameters: {list(function_args.keys()					)} for '''
																																    F'''{processor.__class__} are passed to the logits processor.'''					)
																									SCREAMING_SNAKE_CASE__		: Tuple     =     processor(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)
																		else:
																									SCREAMING_SNAKE_CASE__		: int     =     processor(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	str:



											"""simple docstring"""




											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or not (temperature > 0):
																		raise ValueError(F'''`temperature` has to be a strictly positive float, but is {temperature}'''					)

											SCREAMING_SNAKE_CASE__		: Any     =     temperature



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     scores / self.temperature
											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = -float("""Inf"""					)     , SCREAMING_SNAKE_CASE__ = 1					)      ->	List[str]:



											"""simple docstring"""




											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or (top_p < 0 or top_p > 1.0):
																		raise ValueError(F'''`top_p` has to be a float > 0 and < 1, but is {top_p}'''					)
											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or (min_tokens_to_keep < 1):
																		raise ValueError(F'''`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}'''					)

											SCREAMING_SNAKE_CASE__		: str     =     top_p
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     filter_value
											SCREAMING_SNAKE_CASE__		: str     =     min_tokens_to_keep



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__		: List[Any]     =     lax.top_k(SCREAMING_SNAKE_CASE__     , scores.shape[-1]					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     jnp.full_like(SCREAMING_SNAKE_CASE__     , self.filter_value					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     jax.nn.softmax(SCREAMING_SNAKE_CASE__     , axis=-1					).cumsum(axis=-1					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     cumulative_probs < self.top_p

											# include the token that is higher than top_p as well
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     jnp.roll(SCREAMING_SNAKE_CASE__     , 1					)
											score_mask |= score_mask.at[:, 0].set(SCREAMING_SNAKE_CASE__					)

											# min tokens to keep
											SCREAMING_SNAKE_CASE__		: Tuple     =     score_mask.at[:, : self.min_tokens_to_keep].set(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     jnp.where(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     jax.lax.sort_key_val(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)[-1]

											return next_scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = -float("""Inf"""					)     , SCREAMING_SNAKE_CASE__ = 1					)      ->	int:



											"""simple docstring"""




											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or top_k <= 0:
																		raise ValueError(F'''`top_k` has to be a strictly positive integer, but is {top_k}'''					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     max(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     filter_value



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__		: str     =     scores.shape
											SCREAMING_SNAKE_CASE__		: int     =     jnp.full(batch_size * vocab_size     , self.filter_value					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     min(self.top_k     , scores.shape[-1]					)  # Safety check
											SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__		: List[str]     =     lax.top_k(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     jnp.broadcast_to((jnp.arange(SCREAMING_SNAKE_CASE__					) * vocab_size)[:, None]     , (batch_size, topk)					).flatten()
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     topk_scores.flatten()
											SCREAMING_SNAKE_CASE__		: str     =     topk_indices.flatten() + shift

											SCREAMING_SNAKE_CASE__		: Tuple     =     next_scores_flat.at[topk_indices_flat].set(SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     next_scores_flat.reshape(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											return next_scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     bos_token_id



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     jnp.full(scores.shape     , -float("""inf"""					)					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     1 - jnp.bool_(cur_len - 1					)

											SCREAMING_SNAKE_CASE__		: int     =     jnp.where(SCREAMING_SNAKE_CASE__     , new_scores.at[:, self.bos_token_id].set(0					)     , SCREAMING_SNAKE_CASE__					)

											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     max_length
											SCREAMING_SNAKE_CASE__		: int     =     eos_token_id



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     jnp.full(scores.shape     , -float("""inf"""					)					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     1 - jnp.bool_(cur_len - self.max_length + 1					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     jnp.where(SCREAMING_SNAKE_CASE__     , new_scores.at[:, self.eos_token_id].set(0					)     , SCREAMING_SNAKE_CASE__					)

											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



											"""simple docstring"""




											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or min_length < 0:
																		raise ValueError(F'''`min_length` has to be a positive integer, but is {min_length}'''					)

											if not isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					) or eos_token_id < 0:
																		raise ValueError(F'''`eos_token_id` has to be a positive integer, but is {eos_token_id}'''					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     min_length
											SCREAMING_SNAKE_CASE__		: str     =     eos_token_id



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     1 - jnp.clip(cur_len - self.min_length     , 0     , 1					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     jnp.where(SCREAMING_SNAKE_CASE__     , scores.at[:, self.eos_token_id].set(-float("""inf"""					)					)     , SCREAMING_SNAKE_CASE__					)

											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     list(SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     begin_index



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     1 - jnp.bool_(cur_len - self.begin_index					)

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     jnp.where(SCREAMING_SNAKE_CASE__     , scores.at[:, self.begin_suppress_tokens].set(-float("""inf"""					)					)     , SCREAMING_SNAKE_CASE__					)

											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     list(SCREAMING_SNAKE_CASE__					)



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     scores.at[..., self.suppress_tokens].set(-float("""inf"""					)					)

											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     dict(SCREAMING_SNAKE_CASE__					)
											# Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
											# index of the array corresponds to the index of the token to be forced, for XLA compatibility.
											# Indexes without forced tokens will have a negative value.
											SCREAMING_SNAKE_CASE__		: int     =     jnp.ones((max(force_token_map.keys()					) + 1)     , dtype=jnp.intaa					) * -1
											for index, token in force_token_map.items():
																		if token is not None:
																									SCREAMING_SNAKE_CASE__		: Optional[int]     =     force_token_array.at[index].set(SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     jnp.intaa(SCREAMING_SNAKE_CASE__					)



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	jnp.ndarray:



											"""simple docstring"""




											def _force_token(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: List[str]     =     scores.shape[0]
																		SCREAMING_SNAKE_CASE__		: Dict     =     self.force_token_array[generation_idx]

																		SCREAMING_SNAKE_CASE__		: int     =     jnp.ones_like(SCREAMING_SNAKE_CASE__     , dtype=scores.dtype					) * -float("""inf"""					)
																		SCREAMING_SNAKE_CASE__		: str     =     jnp.zeros((batch_size, 1)     , dtype=scores.dtype					)
																		SCREAMING_SNAKE_CASE__		: Tuple     =     lax.dynamic_update_slice(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , (0, current_token)					)
																		return new_scores

											SCREAMING_SNAKE_CASE__		: List[Any]     =     lax.cond(
											    cur_len >= self.force_token_array.shape[0]     , lambda: scores     , lambda: lax.cond(
											        self.force_token_array[cur_len] >= 0     , lambda: _force_token(SCREAMING_SNAKE_CASE__					)     , lambda: scores     , )     , )
											return scores






class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     generate_config.eos_token_id
											SCREAMING_SNAKE_CASE__		: Any     =     generate_config.no_timestamps_token_id
											SCREAMING_SNAKE_CASE__		: List[str]     =     generate_config.no_timestamps_token_id + 1

											SCREAMING_SNAKE_CASE__		: Any     =     decoder_input_length + 1

											if generate_config.is_multilingual:
																		# room for language token and task token
																		self.begin_index += 2
											if hasattr(SCREAMING_SNAKE_CASE__     , """max_initial_timestamp_index"""					):
																		SCREAMING_SNAKE_CASE__		: str     =     generate_config.max_initial_timestamp_index
											else:
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model_config.vocab_size
											if self.max_initial_timestamp_index is None:
																		SCREAMING_SNAKE_CASE__		: Tuple     =     model_config.vocab_size



				def __call__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     scores.at[:, self.no_timestamps_token_id].set(-float("""inf"""					)					)

											def handle_pairs(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: int     =     jnp.where((cur_len - self.begin_index) >= 1     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
																		SCREAMING_SNAKE_CASE__		: Optional[int]     =     jnp.where(
																		    input_ids_k[cur_len - 1] >= self.timestamp_begin     , True and last_was_timestamp     , SCREAMING_SNAKE_CASE__     , )

																		SCREAMING_SNAKE_CASE__		: int     =     jnp.where((cur_len - self.begin_index) < 2     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     jnp.where(
																		    input_ids_k[cur_len - 2] >= self.timestamp_begin     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , )

																		return jnp.where(
																		    SCREAMING_SNAKE_CASE__     , jnp.where(
																		        penultimate_was_timestamp > 0     , scores_k.at[self.timestamp_begin :].set(-float("""inf"""					)					)     , scores_k.at[: self.eos_token_id].set(-float("""inf"""					)					)     , )     , SCREAMING_SNAKE_CASE__     , )

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     jax.vmap(SCREAMING_SNAKE_CASE__					)(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[str]     =     jnp.where(cur_len == self.begin_index     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     jnp.where(
											    self.max_initial_timestamp_index is not None     , True and apply_max_initial_timestamp     , SCREAMING_SNAKE_CASE__     , )

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.timestamp_begin + self.max_initial_timestamp_index

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     jnp.where(
											    SCREAMING_SNAKE_CASE__     , scores.at[:, last_allowed + 1 :].set(-float("""inf"""					)					)     , SCREAMING_SNAKE_CASE__     , )

											# if sum of probability over timestamps is above any other token, sample timestamp
											SCREAMING_SNAKE_CASE__		: int     =     jax.nn.log_softmax(SCREAMING_SNAKE_CASE__     , axis=-1					)

											def handle_cumulative_probs(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: Any     =     jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]     , axis=-1					)
																		SCREAMING_SNAKE_CASE__		: str     =     jnp.max(logprobs_k[: self.timestamp_begin]					)
																		return jnp.where(
																		    timestamp_logprob > max_text_token_logprob     , scores_k.at[: self.timestamp_begin].set(-float("""inf"""					)					)     , SCREAMING_SNAKE_CASE__     , )

											SCREAMING_SNAKE_CASE__		: int     =     jax.vmap(SCREAMING_SNAKE_CASE__					)(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)

											return scores






"""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 			lowerCAmelCase_		(a__				,      a__				,      unittest.TestCase						):


				"""simple docstring"""



				__UpperCamelCase   :		Any       =     (
				    (
				        TFMobileBertModel,
				        TFMobileBertForMaskedLM,
				        TFMobileBertForNextSentencePrediction,
				        TFMobileBertForPreTraining,
				        TFMobileBertForQuestionAnswering,
				        TFMobileBertForSequenceClassification,
				        TFMobileBertForTokenClassification,
				        TFMobileBertForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				__UpperCamelCase   :		Tuple       =     (
				    {
				        '''feature-extraction''': TFMobileBertModel,
				        '''fill-mask''': TFMobileBertForMaskedLM,
				        '''question-answering''': TFMobileBertForQuestionAnswering,
				        '''text-classification''': TFMobileBertForSequenceClassification,
				        '''token-classification''': TFMobileBertForTokenClassification,
				        '''zero-shot''': TFMobileBertForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase   :		Optional[int]       =     False
				__UpperCamelCase   :		str       =     False



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=False					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     super()._prepare_for_class(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , return_labels=SCREAMING_SNAKE_CASE__					)

											if return_labels:
																		if model_class in get_values(SCREAMING_SNAKE_CASE__					):
																									SCREAMING_SNAKE_CASE__		: List[str]     =     tf.zeros(self.model_tester.batch_size     , dtype=tf.intaa					)

											return inputs_dict



				class 			lowerCAmelCase_		(a__						):


								"""simple docstring"""



								def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=13     , SCREAMING_SNAKE_CASE__=7     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=99     , SCREAMING_SNAKE_CASE__=32     , SCREAMING_SNAKE_CASE__=32     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=4     , SCREAMING_SNAKE_CASE__=37     , SCREAMING_SNAKE_CASE__="gelu"     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=5_12     , SCREAMING_SNAKE_CASE__=16     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=0.02     , SCREAMING_SNAKE_CASE__=3     , SCREAMING_SNAKE_CASE__=4     , SCREAMING_SNAKE_CASE__=None     , )      ->	Optional[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Tuple     =     parent
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     batch_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     seq_length
															SCREAMING_SNAKE_CASE__		: Any     =     is_training
															SCREAMING_SNAKE_CASE__		: List[str]     =     use_input_mask
															SCREAMING_SNAKE_CASE__		: List[Any]     =     use_token_type_ids
															SCREAMING_SNAKE_CASE__		: List[Any]     =     use_labels
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     vocab_size
															SCREAMING_SNAKE_CASE__		: int     =     hidden_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     num_hidden_layers
															SCREAMING_SNAKE_CASE__		: List[str]     =     num_attention_heads
															SCREAMING_SNAKE_CASE__		: List[str]     =     intermediate_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     hidden_act
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     hidden_dropout_prob
															SCREAMING_SNAKE_CASE__		: Dict     =     attention_probs_dropout_prob
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     max_position_embeddings
															SCREAMING_SNAKE_CASE__		: Dict     =     type_vocab_size
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     type_sequence_label_size
															SCREAMING_SNAKE_CASE__		: str     =     initializer_range
															SCREAMING_SNAKE_CASE__		: str     =     num_labels
															SCREAMING_SNAKE_CASE__		: Dict     =     num_choices
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     scope
															SCREAMING_SNAKE_CASE__		: Dict     =     embedding_size



								def 			__magic_name__					(self					)      ->	List[str]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: List[str]     =     ids_tensor([self.batch_size, self.seq_length]     , self.vocab_size					)

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

															SCREAMING_SNAKE_CASE__		: List[Any]     =     None
															if self.use_token_type_ids:
																						SCREAMING_SNAKE_CASE__		: int     =     ids_tensor([self.batch_size, self.seq_length]     , self.type_vocab_size					)

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

															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[int]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: str     =     TFMobileBertModel(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: int     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[Any]     =     model(SCREAMING_SNAKE_CASE__					)

															SCREAMING_SNAKE_CASE__		: Dict     =     [input_ids, input_mask]
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model(SCREAMING_SNAKE_CASE__					)

															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)

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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Any:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Any     =     TFMobileBertForMaskedLM(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.seq_length, self.vocab_size)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	str:



															"""simple docstring"""




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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



															"""simple docstring"""




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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	int:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: List[Any]     =     self.num_labels
															SCREAMING_SNAKE_CASE__		: List[Any]     =     TFMobileBertForSequenceClassification(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: str     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.num_labels)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Tuple:



															"""simple docstring"""




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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: str     =     self.num_labels
															SCREAMING_SNAKE_CASE__		: Tuple     =     TFMobileBertForTokenClassification(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.seq_length, self.num_labels)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Any     =     TFMobileBertForQuestionAnswering(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Dict     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: str     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.start_logits.shape     , (self.batch_size, self.seq_length)					)
															self.parent.assertEqual(result.end_logits.shape     , (self.batch_size, self.seq_length)					)



								def 			__magic_name__					(self					)      ->	Dict:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Tuple     =     self.prepare_config_and_inputs()
															(
															    (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   
															)		: List[Any]     =     config_and_inputs
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
															return config, inputs_dict






				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     TFMobileBertModelTest.TFMobileBertModelTester(self					)
											SCREAMING_SNAKE_CASE__		: str     =     ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE__     , hidden_size=37					)



				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											self.config_tester.run_common_tests()



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_model(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_masked_lm(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_multiple_choice(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_pretraining(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_question_answering(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_sequence_classification(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_token_classification(*SCREAMING_SNAKE_CASE__					)



				@slow
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											for model_name in ["google/mobilebert-uncased"]:
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     TFMobileBertModel.from_pretrained(SCREAMING_SNAKE_CASE__					)
																		self.assertIsNotNone(SCREAMING_SNAKE_CASE__					)






@require_tf
class 			lowerCAmelCase_		(unittest.TestCase						):


				"""simple docstring"""



				@slow
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased"""					)
											SCREAMING_SNAKE_CASE__		: List[Any]     =     tf.constant([[0, 1, 2, 3, 4, 5]]					)
											SCREAMING_SNAKE_CASE__		: Dict     =     model(SCREAMING_SNAKE_CASE__					)[0]

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [1, 6, 3_05_22]
											self.assertEqual(output.shape     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: 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]     , SCREAMING_SNAKE_CASE__     , atol=1E-4					)




