


'''simple docstring'''


import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
				import torch

				from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
				import pyanvml.pyanvml as nvml


UpperCAmelCase_	:     str							     =	logging.get_logger(__name__)






class 					lowercase__						(		__UpperCAmelCase      ):





							'''simple docstring'''


							A_							:   PyTorchBenchmarkArguments
							A_							:   PretrainedConfig
							A_							:   str   			=						"PyTorch"






							@property
							def UpperCAmelCase_			(					self						):
											return torch.__version__






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self._prepare_inference_func(lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__						)
											return self._measure_speed(_inference						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: Any  	=   self._prepare_inference_func(lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__						)
											return self._measure_memory(_inference						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: int  	=   self._prepare_train_func(lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__						)
											return self._measure_speed(_train						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: List[str]  	=   self._prepare_train_func(lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__						)
											return self._measure_memory(_train						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.config_dict[model_name]

											if self.args.torchscript:
															_SCREAMING_SNAKE_CASE				: List[str]  	=   True

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   (
											    hasattr(lowerCamelCase__					,      """architectures"""						)
											    and isinstance(config.architectures					,      lowerCamelCase__						)
											    and len(config.architectures						) > 0
											)
											if not self.args.only_pretrain_model and has_model_class_in_config:
															try:
																			_SCREAMING_SNAKE_CASE				: Tuple  	=   config.architectures[0]
																			_SCREAMING_SNAKE_CASE				: List[str]  	=   __import__("""transformers"""					,      fromlist=[model_class]						)
																			_SCREAMING_SNAKE_CASE				: str  	=   getattr(lowerCamelCase__					,      lowerCamelCase__						)
																			_SCREAMING_SNAKE_CASE				: List[str]  	=   model_cls(lowerCamelCase__						)
															except ImportError:
																			raise ImportError(
																			    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																			    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""						)
											else:
															_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   MODEL_MAPPING[config.__class__](lowerCamelCase__						)

											model.eval()
											model.to(self.args.device						)

											# encoder-decoder has vocab size saved differently
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   config.vocab_size if hasattr(lowerCamelCase__					,      """vocab_size"""						) else config.encoder.vocab_size
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   torch.randint(lowerCamelCase__					,      (batch_size, sequence_length)					,      dtype=torch.long					,      device=self.args.device						)

											if self.args.fpaa:
															logger.info("""Running training in Mixed Precision..."""						)
															if not self.args.is_gpu:
																			raise ValueError("""Mixed precision is possible only for GPU."""						)
															# amp seems to have memory leaks so that memory usage
															# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
															model.half()

											if self.args.torchscript:
															with torch.no_grad():
																			_SCREAMING_SNAKE_CASE				: Optional[int]  	=   torch.jit.trace(lowerCamelCase__					,      lowerCamelCase__						)
											else:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   model

											def encoder_decoder_forward():
															with torch.no_grad():
																			_SCREAMING_SNAKE_CASE				: Tuple  	=   inference_model(lowerCamelCase__					,      decoder_input_ids=lowerCamelCase__						)
															return outputs

											def encoder_forward():
															with torch.no_grad():
																			_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   inference_model(lowerCamelCase__						)
															return outputs

											_SCREAMING_SNAKE_CASE				: int  	=   encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
											return _forward






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   self.config_dict[model_name]

											_SCREAMING_SNAKE_CASE				: str  	=   (
											    hasattr(lowerCamelCase__					,      """architectures"""						)
											    and isinstance(config.architectures					,      lowerCamelCase__						)
											    and len(config.architectures						) > 0
											)
											if not self.args.only_pretrain_model and has_model_class_in_config:
															try:
																			_SCREAMING_SNAKE_CASE				: List[str]  	=   config.architectures[0]
																			_SCREAMING_SNAKE_CASE				: Any  	=   __import__("""transformers"""					,      fromlist=[model_class]						)
																			_SCREAMING_SNAKE_CASE				: int  	=   getattr(lowerCamelCase__					,      lowerCamelCase__						)
																			_SCREAMING_SNAKE_CASE				: str  	=   model_cls(lowerCamelCase__						)
															except ImportError:
																			raise ImportError(
																			    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																			    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""						)
											else:
															_SCREAMING_SNAKE_CASE				: str  	=   MODEL_WITH_LM_HEAD_MAPPING[config.__class__](lowerCamelCase__						)

											if self.args.torchscript:
															raise NotImplementedError("""Training for torchscript is currently not implemented"""						)
											else:
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   model

											model.train()
											model.to(self.args.device						)

											# encoder-decoder has vocab size saved differently
											_SCREAMING_SNAKE_CASE				: Dict  	=   config.vocab_size if hasattr(lowerCamelCase__					,      """vocab_size"""						) else config.encoder.vocab_size
											_SCREAMING_SNAKE_CASE				: Dict  	=   torch.randint(lowerCamelCase__					,      (batch_size, sequence_length)					,      dtype=torch.long					,      device=self.args.device						)

											if self.args.fpaa:
															logger.info("""Running training in Mixed Precision..."""						)
															if not self.args.is_gpu:
																			raise ValueError("""Mixed precision is possible only for GPU."""						)

															# amp seems to have memory leaks so that memory usage
															# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
															model.half()

											def compute_loss_and_backprob_encoder():
															_SCREAMING_SNAKE_CASE				: int  	=   train_model(lowerCamelCase__					,      labels=lowerCamelCase__						)[0]
															loss.backward()
															return loss

											def compute_loss_and_backprob_encoder_decoder():
															_SCREAMING_SNAKE_CASE				: str  	=   train_model(lowerCamelCase__					,      decoder_input_ids=lowerCamelCase__					,      labels=lowerCamelCase__						)[0]
															loss.backward()
															return loss

											_SCREAMING_SNAKE_CASE				: Any  	=   (
											    compute_loss_and_backprob_encoder_decoder
											    if config.is_encoder_decoder
											    else compute_loss_and_backprob_encoder
											)
											return _train






							def UpperCAmelCase_			(					self					,      __snake_case						):



											try:
															if self.args.is_tpu or self.args.torchscript:
																			# run additional 10 times to stabilize compilation for tpu and torchscript
																			logger.info("""Do inference on TPU or torchscript. Running model 5 times to stabilize compilation"""						)
																			timeit.repeat(
																			    lowerCamelCase__					,      repeat=1					,      number=5					,      )

															# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
															_SCREAMING_SNAKE_CASE				: Tuple  	=   timeit.repeat(
															    lowerCamelCase__					,      repeat=self.args.repeat					,      number=10					,      )

															if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
																			import torch_xla.debug.metrics as met

																			self.print_fn(met.metrics_report()						)

															return min(lowerCamelCase__						) / 10.0
											except RuntimeError as e:
															self.print_fn(f"""Doesn\'t fit on GPU. {e}"""						)
															return "N/A"






							def UpperCAmelCase_			(					self					,      __snake_case						):



											try:
															if self.args.trace_memory_line_by_line:
																			_SCREAMING_SNAKE_CASE				: List[Any]  	=   start_memory_tracing("""transformers"""						)

															if self.args.is_tpu:
																			# tpu
																			raise NotImplementedError(
																			    """Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with"""
																			    """ `--no-memory` or `args.memory=False`"""						)
															elif self.args.is_gpu:
																			if not is_pyanvml_available():
																							logger.warning(
																							    """py3nvml not installed, we won't log GPU memory usage. """
																							    """Install py3nvml (pip install py3nvml) to log information about GPU."""						)
																							_SCREAMING_SNAKE_CASE				: int  	=   """N/A"""
																			else:
																							logger.info(
																							    """Measuring total GPU usage on GPU device. Make sure to not have additional processes running"""
																							    """ on the same GPU."""						)
																							# init nvml
																							nvml.nvmlInit()
																							func()
																							_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx						)
																							_SCREAMING_SNAKE_CASE				: Tuple  	=   nvml.nvmlDeviceGetMemoryInfo(lowerCamelCase__						)
																							_SCREAMING_SNAKE_CASE				: int  	=   meminfo.used
																							_SCREAMING_SNAKE_CASE				: Tuple  	=   Memory(lowerCamelCase__						)
																							# shutdown nvml
																							nvml.nvmlShutdown()
															else:
																			# cpu
																			_SCREAMING_SNAKE_CASE				: Dict  	=   measure_peak_memory_cpu(lowerCamelCase__						)
																			_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   Memory(lowerCamelCase__						) if isinstance(lowerCamelCase__					,      lowerCamelCase__						) else memory_bytes

															if self.args.trace_memory_line_by_line:
																			_SCREAMING_SNAKE_CASE				: Dict  	=   stop_memory_tracing(lowerCamelCase__						)
															else:
																			_SCREAMING_SNAKE_CASE				: Dict  	=   None

															return memory, summary
											except RuntimeError as e:
															self.print_fn(f"""Doesn\'t fit on GPU. {e}"""						)
															return "N/A", None








'''simple docstring'''


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 					lowercase__						:





							'''simple docstring'''


							def __init__(					self					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Dict  	=   parent
											_SCREAMING_SNAKE_CASE				: Any  	=   13
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   7
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: str  	=   True
											_SCREAMING_SNAKE_CASE				: Dict  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   False
											_SCREAMING_SNAKE_CASE				: Tuple  	=   False
											_SCREAMING_SNAKE_CASE				: Any  	=   False
											_SCREAMING_SNAKE_CASE				: Dict  	=   2
											_SCREAMING_SNAKE_CASE				: str  	=   99
											_SCREAMING_SNAKE_CASE				: Any  	=   0
											_SCREAMING_SNAKE_CASE				: List[str]  	=   32
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   2
											_SCREAMING_SNAKE_CASE				: List[str]  	=   4
											_SCREAMING_SNAKE_CASE				: List[str]  	=   0.1
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   0.1
											_SCREAMING_SNAKE_CASE				: int  	=   512
											_SCREAMING_SNAKE_CASE				: List[str]  	=   16
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   2
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   0.02
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   3
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   4
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   """last"""
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   None
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   0






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   random_attention_mask([self.batch_size, self.seq_length]					,      dtype=tf.floataa						)

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

											_SCREAMING_SNAKE_CASE				: Tuple  	=   None
											if self.use_token_type_ids:
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   ids_tensor([self.batch_size, self.seq_length]					,      self.n_langs						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   None
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   None
											_SCREAMING_SNAKE_CASE				: Dict  	=   None
											if self.use_labels:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   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				: Tuple  	=   ids_tensor([self.batch_size]					,      2					,      dtype=tf.floataa						)
															_SCREAMING_SNAKE_CASE				: Optional[int]  	=   ids_tensor([self.batch_size]					,      self.num_choices						)

											_SCREAMING_SNAKE_CASE				: Dict  	=   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					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMModel(config=__snake_case						)
											_SCREAMING_SNAKE_CASE				: int  	=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: int  	=   model(__snake_case						)

											_SCREAMING_SNAKE_CASE				: str  	=   [input_ids, input_mask]
											_SCREAMING_SNAKE_CASE				: str  	=   model(__snake_case						)
											self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size)						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMWithLMHeadModel(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   model(__snake_case						)

											_SCREAMING_SNAKE_CASE				: str  	=   outputs

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






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: List[str]  	=   TFXLMForQuestionAnsweringSimple(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Any  	=   {"""input_ids""": input_ids, """lengths""": input_lengths}

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   model(__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 UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Dict  	=   TFXLMForSequenceClassification(__snake_case						)

											_SCREAMING_SNAKE_CASE				: int  	=   {"""input_ids""": input_ids, """lengths""": input_lengths}

											_SCREAMING_SNAKE_CASE				: List[str]  	=   model(__snake_case						)

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






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   self.num_labels
											_SCREAMING_SNAKE_CASE				: Dict  	=   TFXLMForTokenClassification(config=__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: Dict  	=   model(__snake_case						)
											self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.num_labels)						)






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






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   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
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, 
											)				: Tuple  	=   config_and_inputs
											_SCREAMING_SNAKE_CASE				: Tuple  	=   {
											    """input_ids""": input_ids,
											    """token_type_ids""": token_type_ids,
											    """langs""": token_type_ids,
											    """lengths""": input_lengths,
											}
											return config, inputs_dict





@require_tf
class 					lowercase__						(		_snake_case  ,  _snake_case  ,  unittest.TestCase      ):





							'''simple docstring'''


							A_							:   List[str]   			=						(
							    (
							        TFXLMModel,
							        TFXLMWithLMHeadModel,
							        TFXLMForSequenceClassification,
							        TFXLMForQuestionAnsweringSimple,
							        TFXLMForTokenClassification,
							        TFXLMForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							A_							:   List[str]   			=						(
							    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							A_							:   List[str]   			=						(
							    {
							        """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 {}
							)
							A_							:   Tuple   			=						False
							A_							:   Dict   			=						False






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case						):
											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						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMModelTester(self						)
											_SCREAMING_SNAKE_CASE				: List[str]  	=   ConfigTester(self					,      config_class=__snake_case					,      emb_dim=37						)






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






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: int  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_model(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_lm_head(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_qa(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_sequence_classif(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_token_classification(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_multiple_choice(*__snake_case						)






							@slow
							def UpperCAmelCase_			(					self						):
											for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE				: int  	=   TFXLMModel.from_pretrained(__snake_case						)
															self.assertIsNotNone(__snake_case						)





@require_tf
class 					lowercase__						(		unittest.TestCase      ):





							'''simple docstring'''


							@slow
							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""						)
											_SCREAMING_SNAKE_CASE				: Any  	=   tf.convert_to_tensor([[14, 447]]					,      dtype=tf.intaa						)  # the president
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   [
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											    14,
											    447,
											]  # 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
											_SCREAMING_SNAKE_CASE				: Dict  	=   model.generate(__snake_case					,      do_sample=__snake_case						)
											self.assertListEqual(output_ids[0].numpy().tolist()					,      __snake_case						)




