


"""simple docstring"""







import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         XLMForMultipleChoice,
         XLMForQuestionAnswering,
         XLMForQuestionAnsweringSimple,
         XLMForSequenceClassification,
         XLMForTokenClassification,
         XLMModel,
         XLMWithLMHeadModel,
     )
     from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST


class       SCREAMING_SNAKE_CASE__				:
       """simple docstring"""


       def __init__(						self		,     snake_case__		,     snake_case__=13		,     snake_case__=7		,     snake_case__=True		,     snake_case__=True		,     snake_case__=True		,     snake_case__=True		,     snake_case__=True		,     snake_case__=False		,     snake_case__=False		,     snake_case__=False		,     snake_case__=2		,     snake_case__=99		,     snake_case__=0		,     snake_case__=32		,     snake_case__=5		,     snake_case__=4		,     snake_case__=0.1		,     snake_case__=0.1		,     snake_case__=512		,     snake_case__=2		,     snake_case__=0.02		,     snake_case__=2		,     snake_case__=4		,     snake_case__="last"		,     snake_case__=True		,     snake_case__=None		,     snake_case__=0		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							parent
         lowerCAmelCase     :     str								=							batch_size
         lowerCAmelCase     :     int								=							seq_length
         lowerCAmelCase     :     Union[str, Any]								=							is_training
         lowerCAmelCase     :     List[Any]								=							use_input_lengths
         lowerCAmelCase     :     Tuple								=							use_token_type_ids
         lowerCAmelCase     :     Optional[Any]								=							use_labels
         lowerCAmelCase     :     str								=							gelu_activation
         lowerCAmelCase     :     List[Any]								=							sinusoidal_embeddings
         lowerCAmelCase     :     Any								=							causal
         lowerCAmelCase     :     List[str]								=							asm
         lowerCAmelCase     :     str								=							n_langs
         lowerCAmelCase     :     Union[str, Any]								=							vocab_size
         lowerCAmelCase     :     Optional[int]								=							n_special
         lowerCAmelCase     :     str								=							hidden_size
         lowerCAmelCase     :     Any								=							num_hidden_layers
         lowerCAmelCase     :     Dict								=							num_attention_heads
         lowerCAmelCase     :     List[Any]								=							hidden_dropout_prob
         lowerCAmelCase     :     List[str]								=							attention_probs_dropout_prob
         lowerCAmelCase     :     List[str]								=							max_position_embeddings
         lowerCAmelCase     :     Optional[int]								=							type_sequence_label_size
         lowerCAmelCase     :     List[str]								=							initializer_range
         lowerCAmelCase     :     List[str]								=							num_labels
         lowerCAmelCase     :     Union[str, Any]								=							num_choices
         lowerCAmelCase     :     Any								=							summary_type
         lowerCAmelCase     :     Tuple								=							use_proj
         lowerCAmelCase     :     int								=							scope
         lowerCAmelCase     :     Union[str, Any]								=							bos_token_id

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size						)
         lowerCAmelCase     :     Tuple								=							random_attention_mask([self.batch_size, self.seq_length]						)

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

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

         lowerCAmelCase     :     Union[str, Any]								=							None
         lowerCAmelCase     :     List[str]								=							None
         lowerCAmelCase     :     List[Any]								=							None
         if self.use_labels:
           lowerCAmelCase     :     int								=							ids_tensor([self.batch_size]		,     self.type_sequence_label_size						)
           lowerCAmelCase     :     Any								=							ids_tensor([self.batch_size, self.seq_length]		,     self.num_labels						)
           lowerCAmelCase     :     Union[str, Any]								=							ids_tensor([self.batch_size]		,     2						).float()
           lowerCAmelCase     :     List[Any]								=							ids_tensor([self.batch_size]		,     self.num_choices						)

         lowerCAmelCase     :     Union[str, Any]								=							self.get_config()

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

       def        lowercase__							(						self						):






         """simple docstring"""





         return 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		,     num_labels=self.num_labels		,     bos_token_id=self.bos_token_id		,     )

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							XLMModel(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     str								=							model(snake_case__		,     lengths=snake_case__		,     langs=snake_case__						)
         lowerCAmelCase     :     str								=							model(snake_case__		,     langs=snake_case__						)
         lowerCAmelCase     :     List[Any]								=							model(snake_case__						)
         self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							XLMWithLMHeadModel(snake_case__						)
         model.to(snake_case__						)
         model.eval()

         lowerCAmelCase     :     Any								=							model(snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.loss.shape		,     ()						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							XLMForQuestionAnsweringSimple(snake_case__						)
         model.to(snake_case__						)
         model.eval()

         lowerCAmelCase     :     Tuple								=							model(snake_case__						)

         lowerCAmelCase     :     List[str]								=							model(snake_case__		,     start_positions=snake_case__		,     end_positions=snake_case__						)
         lowerCAmelCase     :     List[str]								=							outputs
         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        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							XLMForQuestionAnswering(snake_case__						)
         model.to(snake_case__						)
         model.eval()

         lowerCAmelCase     :     Union[str, Any]								=							model(snake_case__						)

         lowerCAmelCase     :     int								=							model(
             snake_case__		,     start_positions=snake_case__		,     end_positions=snake_case__		,     cls_index=snake_case__		,     is_impossible=snake_case__		,     p_mask=snake_case__		,     )

         lowerCAmelCase     :     List[Any]								=							model(
             snake_case__		,     start_positions=snake_case__		,     end_positions=snake_case__		,     cls_index=snake_case__		,     is_impossible=snake_case__		,     )

         ((lowerCAmelCase)						,  )     :     str								=							result_with_labels.to_tuple()

         lowerCAmelCase     :     int								=							model(snake_case__		,     start_positions=snake_case__		,     end_positions=snake_case__						)

         ((lowerCAmelCase)						,  )     :     Optional[int]								=							result_with_labels.to_tuple()

         self.parent.assertEqual(result_with_labels.loss.shape		,     ()						)
         self.parent.assertEqual(result.start_top_log_probs.shape		,     (self.batch_size, model.config.start_n_top)						)
         self.parent.assertEqual(result.start_top_index.shape		,     (self.batch_size, model.config.start_n_top)						)
         self.parent.assertEqual(
             result.end_top_log_probs.shape		,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
         self.parent.assertEqual(
             result.end_top_index.shape		,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
         self.parent.assertEqual(result.cls_logits.shape		,     (self.batch_size,)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Optional[int]								=							XLMForSequenceClassification(snake_case__						)
         model.to(snake_case__						)
         model.eval()

         lowerCAmelCase     :     Any								=							model(snake_case__						)
         lowerCAmelCase     :     Any								=							model(snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.loss.shape		,     ()						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.type_sequence_label_size)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							self.num_labels
         lowerCAmelCase     :     str								=							XLMForTokenClassification(snake_case__						)
         model.to(snake_case__						)
         model.eval()

         lowerCAmelCase     :     Optional[Any]								=							model(snake_case__		,     attention_mask=snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.num_labels)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							self.num_choices
         lowerCAmelCase     :     List[Any]								=							XLMForMultipleChoice(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     int								=							input_ids.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     int								=							token_type_ids.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     str								=							input_mask.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     int								=							model(
             snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__		,     )
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)						)







       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							self.prepare_config_and_inputs()
         (
             (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  
         )     :     List[Any]								=							config_and_inputs
         lowerCAmelCase     :     Any								=							{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
         return config, inputs_dict


@require_torch
class       SCREAMING_SNAKE_CASE__				(		lowercase   ,    lowercase   ,    lowercase   ,    unittest.TestCase				):
       """simple docstring"""


       a  :				int   =(
           (
               XLMModel,
               XLMWithLMHeadModel,
               XLMForQuestionAnswering,
               XLMForSequenceClassification,
               XLMForQuestionAnsweringSimple,
               XLMForTokenClassification,
               XLMForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       a  :				str   =(
           (XLMWithLMHeadModel,) if is_torch_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       a  :				Union[str, Any]   =(
           {
               "feature-extraction": XLMModel,
               "fill-mask": XLMWithLMHeadModel,
               "question-answering": XLMForQuestionAnsweringSimple,
               "text-classification": XLMForSequenceClassification,
               "text-generation": XLMWithLMHeadModel,
               "token-classification": XLMForTokenClassification,
               "zero-shot": XLMForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """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        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__=False						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							super()._prepare_for_class(snake_case__		,     snake_case__		,     return_labels=snake_case__						)

         if return_labels:
           if model_class.__name__ == "XLMForQuestionAnswering":
             lowerCAmelCase     :     str								=							torch.zeros(
                 self.model_tester.batch_size		,     dtype=torch.long		,     device=snake_case__						)
             lowerCAmelCase     :     Any								=							torch.zeros(
                 self.model_tester.batch_size		,     dtype=torch.long		,     device=snake_case__						)

         return inputs_dict

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							XLMModelTester(self						)
         lowerCAmelCase     :     Dict								=							ConfigTester(self		,     config_class=snake_case__		,     emb_dim=37						)

       def        lowercase__							(						self						):






         """simple docstring"""





         self.config_tester.run_common_tests()

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[Any]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_simple_qa(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[Any]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_token_classif(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case__						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__=False		,     snake_case__=1						):






         """simple docstring"""





         self.assertIsInstance(snake_case__		,     snake_case__						)
         self.assertListEqual(
             [isinstance(snake_case__		,     snake_case__						) for iter_attentions in attentions]		,     [True] * len(snake_case__						)						)
         self.assertEqual(len(snake_case__						)		,     (max_length - min_length) * num_beam_groups						)

         for idx, iter_attentions in enumerate(snake_case__						):
           # adds PAD dummy token
           lowerCAmelCase     :     Optional[int]								=							min_length + idx + 1
           lowerCAmelCase     :     List[str]								=							min_length + idx + 1

           lowerCAmelCase     :     Dict								=							(
               batch_size * num_beam_groups,
               config.num_attention_heads,
               tgt_len,
               src_len,
           )
           # check attn size
           self.assertListEqual(
               [layer_attention.shape for layer_attention in iter_attentions]		,     [expected_shape] * len(snake_case__						)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__=False		,     snake_case__=1						):






         """simple docstring"""





         self.assertIsInstance(snake_case__		,     snake_case__						)
         self.assertListEqual(
             [isinstance(snake_case__		,     snake_case__						) for iter_hidden_states in hidden_states]		,     [True] * len(snake_case__						)		,     )
         self.assertEqual(len(snake_case__						)		,     (max_length - min_length) * num_beam_groups						)

         for idx, iter_hidden_states in enumerate(snake_case__						):
           # adds PAD dummy token
           lowerCAmelCase     :     List[str]								=							min_length + idx + 1
           lowerCAmelCase     :     Tuple								=							(batch_size * num_beam_groups, seq_len, config.hidden_size)
           # check hidden size
           self.assertListEqual(
               [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]		,     [expected_shape] * len(snake_case__						)		,     )
         pass







       @slow
       def        lowercase__							(						self						):






         """simple docstring"""





         for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase     :     Optional[int]								=							XLMModel.from_pretrained(snake_case__						)
           self.assertIsNotNone(snake_case__						)


@require_torch
class       SCREAMING_SNAKE_CASE__				(		unittest.TestCase				):
       """simple docstring"""


       @slow
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[Any]								=							XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"						)
         model.to(snake_case__						)
         lowerCAmelCase     :     Union[str, Any]								=							torch.tensor([[14, 447]]		,     dtype=torch.long		,     device=snake_case__						)  # the president
         lowerCAmelCase     :     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
         lowerCAmelCase     :     Tuple								=							model.generate(snake_case__		,     do_sample=snake_case__						)
         self.assertListEqual(output_ids[0].cpu().numpy().tolist()		,     snake_case__						)









"""simple docstring"""







lowerCAmelCase__      				=   [
    '''Audio''',
    '''Array2D''',
    '''Array3D''',
    '''Array4D''',
    '''Array5D''',
    '''ClassLabel''',
    '''Features''',
    '''Sequence''',
    '''Value''',
    '''Image''',
    '''Translation''',
    '''TranslationVariableLanguages''',
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages





