


'''simple docstring'''


import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor







def     snake_case_     (						):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE				: str  	=   set()
				# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
				for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
								_SCREAMING_SNAKE_CASE				: Any  	=   getattr(transformers.models.auto							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )
								if module is None:
												continue
								# all mappings in a single auto modeling file
								_SCREAMING_SNAKE_CASE				: str  	=   [
								    x
								    for x in dir(SCREAMING_SNAKE_CASE__  )
								    if x.endswith("""_MAPPING_NAMES"""  )
								    and (x.startswith("""MODEL_"""  ) or x.startswith("""TF_MODEL_"""  ) or x.startswith("""FLAX_MODEL_"""  ))
								]
								for name in mapping_names:
												_SCREAMING_SNAKE_CASE				: Optional[int]  	=   getattr(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )
												if mapping is not None:
																for v in mapping.values():
																				if isinstance(SCREAMING_SNAKE_CASE__							,   (list, tuple)  ):
																								model_names.update(SCREAMING_SNAKE_CASE__  )
																				elif isinstance(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):
																								model_names.add(SCREAMING_SNAKE_CASE__  )

				return sorted(SCREAMING_SNAKE_CASE__  )







def     snake_case_     (						):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   set(get_all_model_names()  )

				with open("""tests/utils/tiny_model_summary.json"""  ) as fp:
								_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   json.load(SCREAMING_SNAKE_CASE__  )
				_SCREAMING_SNAKE_CASE				: str  	=   set()
				for model_base_name in tiny_model_info:
								tiny_models_names.update(tiny_model_info[model_base_name]["""model_classes"""]  )

				# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
				_SCREAMING_SNAKE_CASE				: str  	=   model_names.difference(SCREAMING_SNAKE_CASE__  )
				for model_name in copy.copy(SCREAMING_SNAKE_CASE__  ):
								if not model_name.startswith("""TF"""  ) and f"""TF{model_name}""" in not_on_hub:
												tiny_models_names.remove(SCREAMING_SNAKE_CASE__  )
								elif model_name.startswith("""TF"""  ) and model_name[2:] in not_on_hub:
												tiny_models_names.remove(SCREAMING_SNAKE_CASE__  )

				return sorted(SCREAMING_SNAKE_CASE__  )







def     snake_case_     (						SCREAMING_SNAKE_CASE__  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE				: Optional[int]  	=   COMPOSITE_MODELS.values()

				# All tiny model base names on Hub
				_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   get_all_model_names()
				_SCREAMING_SNAKE_CASE				: Optional[int]  	=   hf_api.list_models(
				    filter=ModelFilter(
				        author="""hf-internal-testing"""							,   )  )
				_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   set()
				for x in models:
								_SCREAMING_SNAKE_CASE				: Tuple  	=   x.modelId
								_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   model.split("""/"""  )
								if not model.startswith("""tiny-random-"""  ):
												continue
								_SCREAMING_SNAKE_CASE				: List[Any]  	=   model.replace("""tiny-random-"""							,   """"""  )
								if not model[0].isupper():
												continue
								if model not in model_names and model not in special_models:
												continue
								_models.add(SCREAMING_SNAKE_CASE__  )

				_SCREAMING_SNAKE_CASE				: Optional[int]  	=   sorted(_models  )
				# All tiny model names on Hub
				_SCREAMING_SNAKE_CASE				: Dict  	=   {}
				for model in models:
								_SCREAMING_SNAKE_CASE				: str  	=   f"""hf-internal-testing/tiny-random-{model}"""
								_SCREAMING_SNAKE_CASE				: List[Any]  	=   model.split("""-"""  )[0]
								try:
												_SCREAMING_SNAKE_CASE				: Tuple  	=   hf_api.repo_info(SCREAMING_SNAKE_CASE__  )
												_SCREAMING_SNAKE_CASE				: Optional[int]  	=   {
												    """tokenizer_classes""": set(),
												    """processor_classes""": set(),
												    """model_classes""": set(),
												    """sha""": repo_info.sha,
												}
								except Exception:
												continue
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: Optional[int]  	=   AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__  )
												content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__  )
								except Exception:
												pass
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: int  	=   AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__							,   use_fast=SCREAMING_SNAKE_CASE__  )
												content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__  )
								except Exception:
												pass
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: str  	=   AutoImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE__  )
												content["processor_classes"].add(img_p.__class__.__name__  )
								except Exception:
												pass
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: Any  	=   AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__  )
												if not isinstance(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):
																content["processor_classes"].add(feat_p.__class__.__name__  )
								except Exception:
												pass
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: int  	=   getattr(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )
												_SCREAMING_SNAKE_CASE				: Tuple  	=   model_class.from_pretrained(SCREAMING_SNAKE_CASE__  )
												content["model_classes"].add(m.__class__.__name__  )
								except Exception:
												pass
								try:
												time.sleep(1  )
												_SCREAMING_SNAKE_CASE				: List[Any]  	=   getattr(SCREAMING_SNAKE_CASE__							,   f"""TF{model}"""  )
												_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   model_class.from_pretrained(SCREAMING_SNAKE_CASE__  )
												content["model_classes"].add(m.__class__.__name__  )
								except Exception:
												pass

								_SCREAMING_SNAKE_CASE				: List[Any]  	=   sorted(content["""tokenizer_classes"""]  )
								_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   sorted(content["""processor_classes"""]  )
								_SCREAMING_SNAKE_CASE				: List[Any]  	=   sorted(content["""model_classes"""]  )

								_SCREAMING_SNAKE_CASE				: List[Any]  	=   content
								with open(os.path.join(SCREAMING_SNAKE_CASE__							,   """hub_tiny_model_summary.json"""  )							,   """w"""  ) as fp:
												json.dump(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   ensure_ascii=SCREAMING_SNAKE_CASE__							,   indent=4  )


if __name__ == "__main__":
				UpperCAmelCase_	:     Any							     =	argparse.ArgumentParser()
				parser.add_argument('--num_workers', default=1, type=int, help='The number of workers to run.')
				UpperCAmelCase_	:     Optional[int]							     =	parser.parse_args()

				# This has to be `spawn` to avoid hanging forever!
				multiprocessing.set_start_method('spawn')

				UpperCAmelCase_	:     Any							     =	'tiny_models'
				UpperCAmelCase_	:     Tuple							     =	True
				UpperCAmelCase_	:     Tuple							     =	None
				UpperCAmelCase_	:     Optional[int]							     =	get_tiny_model_names_from_repo()
				UpperCAmelCase_	:     Dict							     =	True
				UpperCAmelCase_	:     str							     =	True
				UpperCAmelCase_	:     Optional[int]							     =	'hf-internal-testing'

				create_tiny_models(
				    output_path,
				    all,
				    model_types,
				    models_to_skip,
				    no_check,
				    upload,
				    organization,
				    token=os.environ.get('TOKEN', None),
				    num_workers=args.num_workers,
				)








'''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						)




