




'''simple docstring'''

import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    EfficientFormerForImageClassification,
		    EfficientFormerForImageClassificationWithTeacher,
		    EfficientFormerModel,
		)
		from transformers.models.efficientformer.modeling_efficientformer import (
		    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		)


if is_vision_available():
		from PIL import Image

		from transformers import EfficientFormerImageProcessor





class __magic_name__:






						def __init__(   self						:						Union[str, Any]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						int = 1_3					,   __UpperCamelCase						:						int = 6_4					,   __UpperCamelCase						:						int = 2					,   __UpperCamelCase						:						int = 3					,   __UpperCamelCase						:						int = 3					,   __UpperCamelCase						:						bool = True					,   __UpperCamelCase						:						bool = True					,   __UpperCamelCase						:						int = 1_2_8					,   __UpperCamelCase						:						int=[1_6, 3_2, 6_4, 1_2_8]					,   __UpperCamelCase						:						int = 7					,   __UpperCamelCase						:						int = 4					,   __UpperCamelCase						:						int = 3_7					,   __UpperCamelCase						:						str = "gelu"					,   __UpperCamelCase						:						float = 0.1					,   __UpperCamelCase						:						float = 0.1					,   __UpperCamelCase						:						int = 1_0					,   __UpperCamelCase						:						float = 0.02					,   __UpperCamelCase						:						int = 2					,   __UpperCamelCase						:						int = 1					,   __UpperCamelCase						:						int = 1_2_8					,   __UpperCamelCase						:						List[int] = [2, 2, 2, 2]					,   __UpperCamelCase						:						int = 2					,   __UpperCamelCase						:						int = 2					,   ):



									'''simple docstring'''






									snake_case__          =						parent
									snake_case__          =						batch_size
									snake_case__          =						image_size
									snake_case__          =						patch_size
									snake_case__          =						num_channels
									snake_case__          =						is_training
									snake_case__          =						use_labels
									snake_case__          =						hidden_size
									snake_case__          =						num_hidden_layers
									snake_case__          =						num_attention_heads
									snake_case__          =						intermediate_size
									snake_case__          =						hidden_act
									snake_case__          =						hidden_dropout_prob
									snake_case__          =						attention_probs_dropout_prob
									snake_case__          =						type_sequence_label_size
									snake_case__          =						initializer_range
									snake_case__          =						encoder_stride
									snake_case__          =						num_attention_outputs
									snake_case__          =						embed_dim
									snake_case__          =						embed_dim + 1
									snake_case__          =						resolution
									snake_case__          =						depths
									snake_case__          =						hidden_sizes
									snake_case__          =						dim
									snake_case__          =						mlp_expansion_ratio






						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

									snake_case__          =						None
									if self.use_labels:
												snake_case__          =						ids_tensor([self.batch_size]					,   self.type_sequence_label_size       )

									snake_case__          =						self.get_config()
									return config, pixel_values, labels






						def       __lowerCAmelCase(   self						:						List[Any]       ):



									'''simple docstring'''






									return EfficientFormerConfig(
									    image_size=self.image_size					,   patch_size=self.patch_size					,   num_channels=self.num_channels					,   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					,   is_decoder=__UpperCamelCase					,   initializer_range=self.initializer_range					,   encoder_stride=self.encoder_stride					,   resolution=self.resolution					,   depths=self.depths					,   hidden_sizes=self.hidden_sizes					,   dim=self.dim					,   mlp_expansion_ratio=self.mlp_expansion_ratio					,   )






						def       __lowerCAmelCase(   self						:						Union[str, Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Dict       ):



									'''simple docstring'''






									snake_case__          =						EfficientFormerModel(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(__UpperCamelCase       )
									self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)       )






						def       __lowerCAmelCase(   self						:						str					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.type_sequence_label_size
									snake_case__          =						EfficientFormerForImageClassification(__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(__UpperCamelCase					,   labels=__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size)       )

									# test greyscale images
									snake_case__          =						1
									snake_case__          =						EfficientFormerForImageClassification(__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()

									snake_case__          =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
									snake_case__          =						model(__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size)       )







						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.prepare_config_and_inputs()
									(
									    (
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			
									)          =						config_and_inputs
									snake_case__          =						{"""pixel_values""": pixel_values}
									return config, inputs_dict







@require_torch
class __magic_name__(						__lowerCAmelCase    ,		__lowerCAmelCase    ,		unittest.TestCase      ):
						UpperCAmelCase_		:					int    =  (
						    (
						        EfficientFormerModel,
						        EfficientFormerForImageClassificationWithTeacher,
						        EfficientFormerForImageClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase_		:					Union[str, Any]    =  (
						    {
						        """feature-extraction""": EfficientFormerModel,
						        """image-classification""": (
						            EfficientFormerForImageClassification,
						            EfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_torch_available()
						    else {}
						)
						UpperCAmelCase_		:					List[str]    =  False

						UpperCAmelCase_		:					Tuple    =  False
						UpperCAmelCase_		:					List[str]    =  False
						UpperCAmelCase_		:					Tuple    =  False






						def       __lowerCAmelCase(   self						:						Tuple       ):



									'''simple docstring'''






									snake_case__          =						EfficientFormerModelTester(self       )
									snake_case__          =						ConfigTester(
									    self					,   config_class=__UpperCamelCase					,   has_text_modality=__UpperCamelCase					,   hidden_size=3_7       )






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									self.config_tester.run_common_tests()






						@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""       )
						def       __lowerCAmelCase(   self						:						Dict       ):



									'''simple docstring'''






									pass






						@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""       )
						def       __lowerCAmelCase(   self						:						Dict       ):



									'''simple docstring'''






									pass






						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									snake_case__    ,			snake_case__          =						self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												snake_case__          =						model_class(__UpperCamelCase       )
												snake_case__          =						inspect.signature(model.forward       )
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												snake_case__          =						[*signature.parameters.keys()]

												snake_case__          =						["""pixel_values"""]
												self.assertListEqual(arg_names[:1]					,   __UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									def check_hidden_states_output(__UpperCamelCase						:						int					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						int       ):
												snake_case__          =						model_class(__UpperCamelCase       )
												model.to(__UpperCamelCase       )
												model.eval()

												with torch.no_grad():
															snake_case__          =						model(**self._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase       )       )

												snake_case__          =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

												snake_case__          =						getattr(
												    self.model_tester					,   """expected_num_hidden_layers"""					,   self.model_tester.num_hidden_layers + 1       )
												self.assertEqual(len(__UpperCamelCase       )					,   __UpperCamelCase       )

												if hasattr(self.model_tester					,   """encoder_seq_length"""       ):
															snake_case__          =						self.model_tester.encoder_seq_length
															if hasattr(self.model_tester					,   """chunk_length"""       ) and self.model_tester.chunk_length > 1:
																		snake_case__          =						seq_length * self.model_tester.chunk_length
												else:
															snake_case__          =						self.model_tester.seq_length

												self.assertListEqual(
												    list(hidden_states[-1].shape[-2:]       )					,   [seq_length, self.model_tester.hidden_size]					,   )

												if config.is_encoder_decoder:
															snake_case__          =						outputs.decoder_hidden_states

															self.assertIsInstance(__UpperCamelCase					,   (list, tuple)       )
															self.assertEqual(len(__UpperCamelCase       )					,   __UpperCamelCase       )
															snake_case__          =						getattr(self.model_tester					,   """seq_length"""					,   __UpperCamelCase       )
															snake_case__          =						getattr(self.model_tester					,   """decoder_seq_length"""					,   __UpperCamelCase       )

															self.assertListEqual(
															    list(hidden_states[-1].shape[-2:]       )					,   [decoder_seq_length, self.model_tester.hidden_size]					,   )

									snake_case__    ,			snake_case__          =						self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												snake_case__          =						True
												check_hidden_states_output(__UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase       )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												snake_case__          =						True

												check_hidden_states_output(__UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						List[str]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						str=False       ):



									'''simple docstring'''






									snake_case__          =						super()._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase					,   return_labels=__UpperCamelCase       )

									if return_labels:
												if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
															del inputs_dict["labels"]

									return inputs_dict






						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__UpperCamelCase       )






						@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""       )
						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									if not self.model_tester.is_training:
												return

									snake_case__    ,			snake_case__          =						self.model_tester.prepare_config_and_inputs_for_common()
									snake_case__          =						True

									for model_class in self.all_model_classes:
												# EfficientFormerForImageClassificationWithTeacher supports inference-only
												if (
												    model_class in get_values(__UpperCamelCase       )
												    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
												):
															continue
												snake_case__          =						model_class(__UpperCamelCase       )
												model.to(__UpperCamelCase       )
												model.train()
												snake_case__          =						self._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase					,   return_labels=__UpperCamelCase       )
												snake_case__          =						model(**__UpperCamelCase       ).loss
												loss.backward()






						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									snake_case__    ,			snake_case__          =						self.model_tester.prepare_config_and_inputs_for_common()

									snake_case__          =						[
									    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
									    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
									    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
									]

									for model_class in self.all_model_classes:
												if (
												    model_class
												    not in [
												        *get_values(__UpperCamelCase       ),
												    ]
												    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
												):
															continue

												for problem_type in problem_types:
															with self.subTest(msg=f"""Testing {model_class} with {problem_type["title"]}"""       ):
																		snake_case__          =						problem_type["""title"""]
																		snake_case__          =						problem_type["""num_labels"""]

																		snake_case__          =						model_class(__UpperCamelCase       )
																		model.to(__UpperCamelCase       )
																		model.train()

																		snake_case__          =						self._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase					,   return_labels=__UpperCamelCase       )

																		if problem_type["num_labels"] > 1:
																					snake_case__          =						inputs["""labels"""].unsqueeze(1       ).repeat(1					,   problem_type["""num_labels"""]       )

																		snake_case__          =						inputs["""labels"""].to(problem_type["""dtype"""]       )

																		# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																		# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																		# they have the same size." which is a symptom something in wrong for the regression problem.
																		# See https://github.com/huggingface/transformers/issues/11780
																		with warnings.catch_warnings(record=__UpperCamelCase       ) as warning_list:
																					snake_case__          =						model(**__UpperCamelCase       ).loss
																		for w in warning_list:
																					if "Using a target size that is different to the input size" in str(w.message       ):
																								raise ValueError(
																								    f"""Something is going wrong in the regression problem: intercepted {w.message}"""       )

																		loss.backward()






						@slow
						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												snake_case__          =						EfficientFormerModel.from_pretrained(__UpperCamelCase       )
												self.assertIsNotNone(__UpperCamelCase       )







						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									snake_case__    ,			snake_case__          =						self.model_tester.prepare_config_and_inputs_for_common()
									snake_case__          =						True

									snake_case__          =						getattr(self.model_tester					,   """seq_length"""					,   __UpperCamelCase       )
									snake_case__          =						getattr(self.model_tester					,   """encoder_seq_length"""					,   __UpperCamelCase       )
									snake_case__          =						getattr(self.model_tester					,   """key_length"""					,   __UpperCamelCase       )
									snake_case__          =						getattr(self.model_tester					,   """chunk_length"""					,   __UpperCamelCase       )

									if chunk_length is not None and hasattr(self.model_tester					,   """num_hashes"""       ):
												snake_case__          =						encoder_seq_length * self.model_tester.num_hashes

									for model_class in self.all_model_classes:
												snake_case__          =						True
												snake_case__          =						False
												snake_case__          =						True
												snake_case__          =						model_class(__UpperCamelCase       )
												model.to(__UpperCamelCase       )
												model.eval()
												with torch.no_grad():
															snake_case__          =						model(**self._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase       )       )
												snake_case__          =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
												self.assertEqual(len(__UpperCamelCase       )					,   self.model_tester.num_attention_outputs       )

												# check that output_attentions also work using config
												del inputs_dict["output_attentions"]
												snake_case__          =						True
												snake_case__          =						model_class(__UpperCamelCase       )
												model.to(__UpperCamelCase       )
												model.eval()
												with torch.no_grad():
															snake_case__          =						model(**self._prepare_for_class(__UpperCamelCase					,   __UpperCamelCase       )       )
												snake_case__          =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
												self.assertEqual(len(__UpperCamelCase       )					,   self.model_tester.num_attention_outputs       )

												if chunk_length is not None:
															self.assertListEqual(
															    list(attentions[0].shape[-4:]       )					,   [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]					,   )
												else:
															self.assertListEqual(
															    list(attentions[0].shape[-3:]       )					,   [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,   )







def    snake_case__     (  )			->       List[str]:





			'''simple docstring'''






			snake_case__          =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
			return image





@require_torch
@require_vision
class __magic_name__(						unittest.TestCase      ):






						@cached_property
						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									return (
									    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""       )
									    if is_vision_available()
									    else None
									)






						@slow
						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""       ).to(
									    __UpperCamelCase       )

									snake_case__          =						self.default_image_processor
									snake_case__          =						prepare_img()
									snake_case__          =						image_processor(images=__UpperCamelCase					,   return_tensors="""pt"""       ).to(__UpperCamelCase       )

									# forward pass
									with torch.no_grad():
												snake_case__          =						model(**__UpperCamelCase       )

									# verify the logits
									snake_case__          =						(1, 1_0_0_0)
									self.assertEqual(outputs.logits.shape					,   __UpperCamelCase       )

									snake_case__          =						torch.tensor([-0.05_55, 0.48_25, -0.08_52]       ).to(__UpperCamelCase       )
									self.assertTrue(torch.allclose(outputs.logits[0][:3]					,   __UpperCamelCase					,   atol=1E-4       )       )







						@slow
						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									snake_case__          =						EfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    """snap-research/efficientformer-l1-300"""       ).to(__UpperCamelCase       )

									snake_case__          =						self.default_image_processor
									snake_case__          =						prepare_img()
									snake_case__          =						image_processor(images=__UpperCamelCase					,   return_tensors="""pt"""       ).to(__UpperCamelCase       )

									# forward pass
									with torch.no_grad():
												snake_case__          =						model(**__UpperCamelCase       )

									# verify the logits
									snake_case__          =						(1, 1_0_0_0)
									self.assertEqual(outputs.logits.shape					,   __UpperCamelCase       )

									snake_case__          =						torch.tensor([-0.13_12, 0.43_53, -1.04_99]       ).to(__UpperCamelCase       )
									self.assertTrue(torch.allclose(outputs.logits[0][:3]					,   __UpperCamelCase					,   atol=1E-4       )       )

"""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 A_      :




  '''simple docstring'''







  def __init__(						self							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       parent
     UpperCAmelCase_   :   Any     	=       13
     UpperCAmelCase_   :   Dict     	=       7
     UpperCAmelCase_   :   str     	=       True
     UpperCAmelCase_   :   Optional[int]     	=       True
     UpperCAmelCase_   :   Optional[Any]     	=       True
     UpperCAmelCase_   :   Tuple     	=       True
     UpperCAmelCase_   :   Tuple     	=       True
     UpperCAmelCase_   :   str     	=       False
     UpperCAmelCase_   :   Optional[Any]     	=       False
     UpperCAmelCase_   :   Any     	=       False
     UpperCAmelCase_   :   Tuple     	=       2
     UpperCAmelCase_   :   str     	=       99
     UpperCAmelCase_   :   str     	=       0
     UpperCAmelCase_   :   Dict     	=       32
     UpperCAmelCase_   :   Dict     	=       2
     UpperCAmelCase_   :   Union[str, Any]     	=       4
     UpperCAmelCase_   :   Union[str, Any]     	=       0.1
     UpperCAmelCase_   :   Dict     	=       0.1
     UpperCAmelCase_   :   Optional[Any]     	=       512
     UpperCAmelCase_   :   Any     	=       16
     UpperCAmelCase_   :   Tuple     	=       2
     UpperCAmelCase_   :   int     	=       0.02
     UpperCAmelCase_   :   Union[str, Any]     	=       3
     UpperCAmelCase_   :   str     	=       4
     UpperCAmelCase_   :   Union[str, Any]     	=       "last"
     UpperCAmelCase_   :   Optional[int]     	=       True
     UpperCAmelCase_   :   str     	=       None
     UpperCAmelCase_   :   Dict     	=       0







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[int]     	=       ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size    )
     UpperCAmelCase_   :   Any     	=       random_attention_mask([self.batch_size, self.seq_length]							,  dtype=tf.floataa    )

     UpperCAmelCase_   :   Union[str, Any]     	=       None
     if self.use_input_lengths:
        UpperCAmelCase_   :   Dict     	=       (
            ids_tensor([self.batch_size]							,  vocab_size=2    ) + self.seq_length - 2
        )  # small variation of seq_length

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

     UpperCAmelCase_   :   Dict     	=       None
     UpperCAmelCase_   :   int     	=       None
     UpperCAmelCase_   :   str     	=       None
     if self.use_labels:
        UpperCAmelCase_   :   Optional[Any]     	=       ids_tensor([self.batch_size]							,  self.type_sequence_label_size    )
        UpperCAmelCase_   :   Optional[int]     	=       ids_tensor([self.batch_size, self.seq_length]							,  self.num_labels    )
        UpperCAmelCase_   :   Optional[int]     	=       ids_tensor([self.batch_size]							,  2							,  dtype=tf.floataa    )
        UpperCAmelCase_   :   Dict     	=       ids_tensor([self.batch_size]							,  self.num_choices    )

     UpperCAmelCase_   :   Optional[Any]     	=       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							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       TFXLMModel(config=lowercase_    )
     UpperCAmelCase_   :   Any     	=       {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
     UpperCAmelCase_   :   Tuple     	=       model(lowercase_    )

     UpperCAmelCase_   :   Any     	=       [input_ids, input_mask]
     UpperCAmelCase_   :   Union[str, Any]     	=       model(lowercase_    )
     self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size)    )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Tuple     	=       TFXLMWithLMHeadModel(lowercase_    )

     UpperCAmelCase_   :   List[Any]     	=       {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
     UpperCAmelCase_   :   Dict     	=       model(lowercase_    )

     UpperCAmelCase_   :   Optional[int]     	=       outputs

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







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   int     	=       TFXLMForQuestionAnsweringSimple(lowercase_    )

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

     UpperCAmelCase_   :   Union[str, Any]     	=       model(lowercase_    )

     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							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Union[str, Any]     	=       TFXLMForSequenceClassification(lowercase_    )

     UpperCAmelCase_   :   Optional[int]     	=       {"input_ids": input_ids, "lengths": input_lengths}

     UpperCAmelCase_   :   Any     	=       model(lowercase_    )

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







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       self.num_labels
     UpperCAmelCase_   :   Any     	=       TFXLMForTokenClassification(config=lowercase_    )
     UpperCAmelCase_   :   Any     	=       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
     UpperCAmelCase_   :   List[Any]     	=       model(lowercase_    )
     self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.seq_length, self.num_labels)    )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  ):

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







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[str]     	=       self.prepare_config_and_inputs()
     (
         (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  (
         UpperCAmelCase_
     )	,  
     )   :   Dict     	=       config_and_inputs
     UpperCAmelCase_   :   Optional[int]     	=       {
         "input_ids": input_ids,
         "token_type_ids": token_type_ids,
         "langs": token_type_ids,
         "lengths": input_lengths,
     }
     return config, inputs_dict




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




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__     :		Any    	=						(
      (
          TFXLMModel,
          TFXLMWithLMHeadModel,
          TFXLMForSequenceClassification,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForTokenClassification,
          TFXLMForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  SCREAMING_SNAKE_CASE__     :		List[Any]    	=						(
      (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  SCREAMING_SNAKE_CASE__     :		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__     :		List[str]    	=						False
  SCREAMING_SNAKE_CASE__     :		Optional[Any]    	=						False







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     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    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[Any]     	=       TFXLMModelTester(self    )
     UpperCAmelCase_   :   List[str]     	=       ConfigTester(self							,  config_class=lowercase_							,  emb_dim=37    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     self.config_tester.run_common_tests()







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[int]     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_model(*lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   int     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_lm_head(*lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_qa(*lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_sequence_classif(*lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[int]     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_token_classification(*lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_multiple_choice(*lowercase_    )







  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCAmelCase_   :   Tuple     	=       TFXLMModel.from_pretrained(lowercase_    )
        self.assertIsNotNone(lowercase_    )




@require_tf
class A_      (unittest.TestCase ):




  '''simple docstring'''







  @slow
  def 			UpperCamelCase__   (						self    ):

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


