




from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__lowerCAmelCase						:							List[Any]			     =						logging.get_logger(__name__)

__lowerCAmelCase						:							Optional[Any]			     =						{
    'facebook/mbart-large-cc25': 'https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json',
    # See all MBART models at https://huggingface.co/models?filter=mbart
}




class        snake_case__				(_UpperCamelCase  ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			:				List[Any]									=   """mbart"""
				SCREAMING_SNAKE_CASE_			:				Union[str, Any]									=   ["""past_key_values"""]
				SCREAMING_SNAKE_CASE_			:				Union[str, Any]									=   {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





				def __init__( self							:	Optional[Any]   , __lowerCamelCase							:	Union[str, Any]=5_02_65   , __lowerCamelCase							:	Dict=10_24   , __lowerCamelCase							:	str=12   , __lowerCamelCase							:	Any=40_96   , __lowerCamelCase							:	List[str]=16   , __lowerCamelCase							:	str=12   , __lowerCamelCase							:	str=40_96   , __lowerCamelCase							:	Tuple=16   , __lowerCamelCase							:	int=0.0   , __lowerCamelCase							:	Optional[Any]=0.0   , __lowerCamelCase							:	Any=True   , __lowerCamelCase							:	Optional[Any]=True   , __lowerCamelCase							:	Optional[int]="gelu"   , __lowerCamelCase							:	Optional[int]=10_24   , __lowerCamelCase							:	Any=0.1   , __lowerCamelCase							:	Optional[int]=0.0   , __lowerCamelCase							:	Optional[int]=0.0   , __lowerCamelCase							:	List[Any]=0.02   , __lowerCamelCase							:	Union[str, Any]=0.0   , __lowerCamelCase							:	Optional[int]=False   , __lowerCamelCase							:	Dict=1   , __lowerCamelCase							:	Any=0   , __lowerCamelCase							:	Any=2   , __lowerCamelCase							:	Optional[int]=2   , **__lowerCamelCase							:	Any   , )   ->	Optional[int]:
							a       =     vocab_size
							a       =     max_position_embeddings
							a       =     d_model
							a       =     encoder_ffn_dim
							a       =     encoder_layers
							a       =     encoder_attention_heads
							a       =     decoder_ffn_dim
							a       =     decoder_layers
							a       =     decoder_attention_heads
							a       =     dropout
							a       =     attention_dropout
							a       =     activation_dropout
							a       =     activation_function
							a       =     init_std
							a       =     encoder_layerdrop
							a       =     decoder_layerdrop
							a       =     classifier_dropout
							a       =     use_cache
							a       =     encoder_layers
							a       =     scale_embedding  # scale factor will be sqrt(d_model) if True
							super().__init__(
							    pad_token_id=__lowerCamelCase   , bos_token_id=__lowerCamelCase   , eos_token_id=__lowerCamelCase   , is_encoder_decoder=__lowerCamelCase   , forced_eos_token_id=__lowerCamelCase   , **__lowerCamelCase   , )




class        snake_case__				(_UpperCamelCase  ):
				"""simple docstring"""



				@property
				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
										a       =     OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										    ]				)

										if self.use_past:
													a       =     {0: "batch"}
													a       =     {0: "batch", 1: "past_decoder_sequence + sequence"}
										else:
													a       =     {0: "batch", 1: "decoder_sequence"}
													a       =     {0: "batch", 1: "decoder_sequence"}

										if self.use_past:
													self.fill_with_past_key_values_(__lowerCamelCase   , direction="inputs"				)
							elif self.task == "causal-lm":
										# TODO: figure this case out.
										a       =     OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										    ]				)
										if self.use_past:
													a       ,						a       =     self.num_layers
													for i in range(__lowerCamelCase				):
																a       =     {0: "batch", 2: "past_sequence + sequence"}
																a       =     {0: "batch", 2: "past_sequence + sequence"}
							else:
										a       =     OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										        ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
										        ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
										    ]				)

							return common_inputs





				@property
				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
										a       =     super().outputs
							else:
										a       =     super(__lowerCamelCase   , self				).outputs
										if self.use_past:
													a       ,						a       =     self.num_layers
													for i in range(__lowerCamelCase				):
																a       =     {0: "batch", 2: "past_sequence + sequence"}
																a       =     {0: "batch", 2: "past_sequence + sequence"}
							return common_outputs





				def 				__UpperCAmelCase				( self							:	Union[str, Any]   , __lowerCamelCase							:	PreTrainedTokenizer   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	bool = False   , __lowerCamelCase							:	Optional[TensorType] = None   , )   ->	Mapping[str, Any]:
							a       =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)

							# Generate decoder inputs
							a       =     seq_length if not self.use_past else 1
							a       =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)
							a       =     {f"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
							a       =     dict(**__lowerCamelCase   , **__lowerCamelCase				)

							if self.use_past:
										if not is_torch_available():
													raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."				)
										else:
													import torch
										a       ,						a       =     common_inputs["input_ids"].shape
										a       =     common_inputs["decoder_input_ids"].shape[1]
										a       ,						a       =     self.num_attention_heads
										a       =     (
										    batch,
										    num_encoder_attention_heads,
										    encoder_seq_length,
										    self._config.hidden_size // num_encoder_attention_heads,
										)
										a       =     decoder_seq_length + 3
										a       =     (
										    batch,
										    num_decoder_attention_heads,
										    decoder_past_length,
										    self._config.hidden_size // num_decoder_attention_heads,
										)

										a       =     torch.cat(
										    [common_inputs["decoder_attention_mask"], torch.ones(__lowerCamelCase   , __lowerCamelCase				)]   , dim=1				)

										a       =     []
										# If the number of encoder and decoder layers are present in the model configuration, both are considered
										a       ,						a       =     self.num_layers
										a       =     min(__lowerCamelCase   , __lowerCamelCase				)
										a       =     max(__lowerCamelCase   , __lowerCamelCase				) - min_num_layers
										a       =     "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

										for _ in range(__lowerCamelCase				):
													common_inputs["past_key_values"].append(
													    (
													        torch.zeros(__lowerCamelCase				),
													        torch.zeros(__lowerCamelCase				),
													        torch.zeros(__lowerCamelCase				),
													        torch.zeros(__lowerCamelCase				),
													    )				)
										# TODO: test this.
										a       =     encoder_shape if remaining_side_name == "encoder" else decoder_shape
										for _ in range(__lowerCamelCase   , __lowerCamelCase				):
													common_inputs["past_key_values"].append((torch.zeros(__lowerCamelCase				), torch.zeros(__lowerCamelCase				))				)
							return common_inputs





				def 				__UpperCAmelCase				( self							:	Dict   , __lowerCamelCase							:	PreTrainedTokenizer   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	bool = False   , __lowerCamelCase							:	Optional[TensorType] = None   , )   ->	Mapping[str, Any]:
							a       =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)

							if self.use_past:
										if not is_torch_available():
													raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."				)
										else:
													import torch
										a       ,						a       =     common_inputs["input_ids"].shape
										# Not using the same length for past_key_values
										a       =     seqlen + 2
										a       ,						a       =     self.num_layers
										a       ,						a       =     self.num_attention_heads
										a       =     (
										    batch,
										    num_encoder_attention_heads,
										    past_key_values_length,
										    self._config.hidden_size // num_encoder_attention_heads,
										)

										a       =     common_inputs["attention_mask"].dtype
										a       =     torch.cat(
										    [common_inputs["attention_mask"], torch.ones(__lowerCamelCase   , __lowerCamelCase   , dtype=__lowerCamelCase				)]   , dim=1				)
										a       =     [
										    (torch.zeros(__lowerCamelCase				), torch.zeros(__lowerCamelCase				)) for _ in range(__lowerCamelCase				)
										]
							return common_inputs





				def 				__UpperCAmelCase				( self							:	int   , __lowerCamelCase							:	PreTrainedTokenizer   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	bool = False   , __lowerCamelCase							:	Optional[TensorType] = None   , )   ->	Mapping[str, Any]:
							# Copied from OnnxConfig.generate_dummy_inputs
							# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
							# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
							a       =     compute_effective_axis_dimension(
							    __lowerCamelCase   , fixed_dimension=OnnxConfig.default_fixed_batch   , num_token_to_add=0				)

							# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
							a       =     tokenizer.num_special_tokens_to_add(__lowerCamelCase				)
							a       =     compute_effective_axis_dimension(
							    __lowerCamelCase   , fixed_dimension=OnnxConfig.default_fixed_sequence   , num_token_to_add=__lowerCamelCase				)

							# Generate dummy inputs according to compute batch and sequence
							a       =     [" ".join([tokenizer.unk_token]				) * seq_length] * batch_size
							a       =     dict(tokenizer(__lowerCamelCase   , return_tensors=__lowerCamelCase				)				)
							return common_inputs





				def 				__UpperCAmelCase				( self							:	List[str]   , __lowerCamelCase							:	PreTrainedTokenizer   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	int = -1   , __lowerCamelCase							:	bool = False   , __lowerCamelCase							:	Optional[TensorType] = None   , )   ->	Mapping[str, Any]:
							if self.task in ["default", "seq2seq-lm"]:
										a       =     self._generate_dummy_inputs_for_default_and_seqaseq_lm(
										    __lowerCamelCase   , batch_size=__lowerCamelCase   , seq_length=__lowerCamelCase   , is_pair=__lowerCamelCase   , framework=__lowerCamelCase				)

							elif self.task == "causal-lm":
										a       =     self._generate_dummy_inputs_for_causal_lm(
										    __lowerCamelCase   , batch_size=__lowerCamelCase   , seq_length=__lowerCamelCase   , is_pair=__lowerCamelCase   , framework=__lowerCamelCase				)
							else:
										a       =     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    __lowerCamelCase   , batch_size=__lowerCamelCase   , seq_length=__lowerCamelCase   , is_pair=__lowerCamelCase   , framework=__lowerCamelCase				)

							return common_inputs





				def 				__UpperCAmelCase				( self							:	Union[str, Any]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[str]				)   ->	List[str]:
							if self.task in ["default", "seq2seq-lm"]:
										a       =     super()._flatten_past_key_values_(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)
							else:
										a       =     super(__lowerCamelCase   , self				)._flatten_past_key_values_(
										    __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)












from __future__ import annotations

import unittest

from transformers import is_tf_available
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_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFXLMForMultipleChoice,
		    TFXLMForQuestionAnsweringSimple,
		    TFXLMForSequenceClassification,
		    TFXLMForTokenClassification,
		    TFXLMModel,
		    TFXLMWithLMHeadModel,
		    XLMConfig,
		)




class        snake_case__				:
				"""simple docstring"""



				def __init__( self							:	Optional[Any]   , __lowerCamelCase							:	Any   , )   ->	Any:
							a       =     parent
							a       =     13
							a       =     7
							a       =     True
							a       =     True
							a       =     True
							a       =     True
							a       =     True
							a       =     False
							a       =     False
							a       =     False
							a       =     2
							a       =     99
							a       =     0
							a       =     32
							a       =     2
							a       =     4
							a       =     0.1
							a       =     0.1
							a       =     5_12
							a       =     16
							a       =     2
							a       =     0.02
							a       =     3
							a       =     4
							a       =     "last"
							a       =     True
							a       =     None
							a       =     0





				def 				__UpperCAmelCase				( self							:	int				)   ->	Tuple:
							a       =     ids_tensor([self.batch_size, self.seq_length]   , self.vocab_size				)
							a       =     random_attention_mask([self.batch_size, self.seq_length]   , dtype=tf.floataa				)

							a       =     None
							if self.use_input_lengths:
										a       =     (
										    ids_tensor([self.batch_size]   , vocab_size=2				) + self.seq_length - 2
										)  # small variation of seq_length

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

							a       =     None
							a       =     None
							a       =     None
							if self.use_labels:
										a       =     ids_tensor([self.batch_size]   , self.type_sequence_label_size				)
										a       =     ids_tensor([self.batch_size, self.seq_length]   , self.num_labels				)
										a       =     ids_tensor([self.batch_size]   , 2   , dtype=tf.floataa				)
										a       =     ids_tensor([self.batch_size]   , self.num_choices				)

							a       =     XLMConfig(
							    vocab_size=self.vocab_size   , n_special=self.n_special   , emb_dim=self.hidden_size   , n_layers=self.num_hidden_layers   , n_heads=self.num_attention_heads   , dropout=self.hidden_dropout_prob   , attention_dropout=self.attention_probs_dropout_prob   , gelu_activation=self.gelu_activation   , sinusoidal_embeddings=self.sinusoidal_embeddings   , asm=self.asm   , causal=self.causal   , n_langs=self.n_langs   , max_position_embeddings=self.max_position_embeddings   , initializer_range=self.initializer_range   , summary_type=self.summary_type   , use_proj=self.use_proj   , bos_token_id=self.bos_token_id   , )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_lengths,
							    sequence_labels,
							    token_labels,
							    is_impossible_labels,
							    choice_labels,
							    input_mask,
							)





				def 				__UpperCAmelCase				( self							:	List[str]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Any   , )   ->	Union[str, Any]:
							a       =     TFXLMModel(config=__lowerCamelCase				)
							a       =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
							a       =     model(__lowerCamelCase				)

							a       =     [input_ids, input_mask]
							a       =     model(__lowerCamelCase				)
							self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)				)





				def 				__UpperCAmelCase				( self							:	Union[str, Any]   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	Dict   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Any   , )   ->	Optional[Any]:
							a       =     TFXLMWithLMHeadModel(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
							a       =     model(__lowerCamelCase				)

							a       =     outputs

							self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.vocab_size)				)





				def 				__UpperCAmelCase				( self							:	Tuple   , __lowerCamelCase							:	Dict   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	List[Any]   , )   ->	int:
							a       =     TFXLMForQuestionAnsweringSimple(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths}

							a       =     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 				__UpperCAmelCase				( self							:	Dict   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	Optional[int]   , )   ->	Optional[int]:
							a       =     TFXLMForSequenceClassification(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths}

							a       =     model(__lowerCamelCase				)

							self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.type_sequence_label_size)				)





				def 				__UpperCAmelCase				( self							:	Any   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Union[str, Any]   , )   ->	Optional[Any]:
							a       =     self.num_labels
							a       =     TFXLMForTokenClassification(config=__lowerCamelCase				)
							a       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							a       =     model(__lowerCamelCase				)
							self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.num_labels)				)





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





				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	str:
							a       =     self.prepare_config_and_inputs()
							(
							    (
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						
							)       =     config_and_inputs
							a       =     {
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							    "langs": token_type_ids,
							    "lengths": input_lengths,
							}
							return config, inputs_dict




@require_tf
class        snake_case__				(_UpperCamelCase       ,			_UpperCamelCase       ,			unittest.TestCase  ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			:				int									=   (
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_			:				List[str]									=   (
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				SCREAMING_SNAKE_CASE_			:				List[Any]									=   (
				    {
				        """feature-extraction""": TFXLMModel,
				        """fill-mask""": TFXLMWithLMHeadModel,
				        """question-answering""": TFXLMForQuestionAnsweringSimple,
				        """text-classification""": TFXLMForSequenceClassification,
				        """text-generation""": TFXLMWithLMHeadModel,
				        """token-classification""": TFXLMForTokenClassification,
				        """zero-shot""": TFXLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				SCREAMING_SNAKE_CASE_			:				Tuple									=   False
				SCREAMING_SNAKE_CASE_			:				Dict									=   False





				def 				__UpperCAmelCase				( self							:	Any   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	List[Any]				)   ->	Dict:
							if (
							    pipeline_test_casse_name == "QAPipelineTests"
							    and tokenizer_name is not None
							    and not tokenizer_name.endswith("Fast"				)
							):
										# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
										# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
										# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
										return True

							return False





				def 				__UpperCAmelCase				( self							:	Tuple				)   ->	Tuple:
							a       =     TFXLMModelTester(self				)
							a       =     ConfigTester(self   , config_class=__lowerCamelCase   , emb_dim=37				)





				def 				__UpperCAmelCase				( self							:	List[str]				)   ->	Optional[int]:
							self.config_tester.run_common_tests()





				def 				__UpperCAmelCase				( self							:	Dict				)   ->	List[Any]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_model(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Tuple				)   ->	Dict:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_lm_head(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	Dict:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_qa(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	Optional[int]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_sequence_classif(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	Optional[Any]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_token_classification(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	str:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowerCamelCase				)





				@slow
				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	List[Any]:
							for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										a       =     TFXLMModel.from_pretrained(__lowerCamelCase				)
										self.assertIsNotNone(__lowerCamelCase				)




@require_tf
class        snake_case__				(unittest.TestCase  ):
				"""simple docstring"""



				@slow
				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	str:
							a       =     TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"				)
							a       =     tf.convert_to_tensor([[14, 4_47]]   , dtype=tf.intaa				)  # the president
							a       =     [
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							]  # the president the president the president the president the president the president the president the president the president the president
							# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
							a       =     model.generate(__lowerCamelCase   , do_sample=__lowerCamelCase				)
							self.assertListEqual(output_ids[0].numpy().tolist()   , __lowerCamelCase				)






