




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


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




   '''simple docstring'''



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


 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Any			=						ids_tensor([self.batch_size, self.seq_length],   self.vocab_size	)
   _snake_case							:	List[str]			=						random_attention_mask([self.batch_size, self.seq_length]	)

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

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

   _snake_case							:	Optional[int]			=						None
   _snake_case							:	str			=						None
   _snake_case							:	Optional[Any]			=						None
   if self.use_labels:
     _snake_case							:	Optional[Any]			=						ids_tensor([self.batch_size],   self.type_sequence_label_size	)
     _snake_case							:	Tuple			=						ids_tensor([self.batch_size, self.seq_length],   self.num_labels	)
     _snake_case							:	Optional[Any]			=						ids_tensor([self.batch_size],   2	).float()
     _snake_case							:	Optional[int]			=						ids_tensor([self.batch_size],   self.num_choices	)

   _snake_case							:	Optional[int]			=						self.get_config()

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


 def 				UpperCamelCase_     (       self:	str	):




   '''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 				UpperCamelCase_     (       self:	str,   a_:	Any,   a_:	Any,   a_:	Tuple,   a_:	Dict,   a_:	Optional[int],   a_:	Union[str, Any],   a_:	Dict,   a_:	Tuple,   a_:	Any,   ):




   '''simple docstring'''



   _snake_case							:	Tuple			=						XLMModel(config=snake_case_	)
   model.to(snake_case_	)
   model.eval()
   _snake_case							:	List[str]			=						model(snake_case_,   lengths=snake_case_,   langs=snake_case_	)
   _snake_case							:	Optional[Any]			=						model(snake_case_,   langs=snake_case_	)
   _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:	Union[str, Any],   a_:	str,   a_:	List[Any],   a_:	Any,   a_:	Union[str, Any],   a_:	Tuple,   a_:	int,   a_:	List[Any],   a_:	Union[str, Any],   a_:	Any,   ):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						XLMWithLMHeadModel(snake_case_	)
   model.to(snake_case_	)
   model.eval()

   _snake_case							:	int			=						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 				UpperCamelCase_     (       self:	Dict,   a_:	Any,   a_:	str,   a_:	Union[str, Any],   a_:	int,   a_:	List[Any],   a_:	Tuple,   a_:	Union[str, Any],   a_:	Any,   a_:	Optional[int],   ):




   '''simple docstring'''



   _snake_case							:	List[Any]			=						XLMForQuestionAnsweringSimple(snake_case_	)
   model.to(snake_case_	)
   model.eval()

   _snake_case							:	Optional[int]			=						model(snake_case_	)

   _snake_case							:	Tuple			=						model(snake_case_,   start_positions=snake_case_,   end_positions=snake_case_	)
   _snake_case							:	Union[str, Any]			=						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 				UpperCamelCase_     (       self:	List[str],   a_:	List[str],   a_:	Dict,   a_:	str,   a_:	str,   a_:	Tuple,   a_:	str,   a_:	List[Any],   a_:	int,   a_:	Any,   ):




   '''simple docstring'''



   _snake_case							:	Union[str, Any]			=						XLMForQuestionAnswering(snake_case_	)
   model.to(snake_case_	)
   model.eval()

   _snake_case							:	int			=						model(snake_case_	)

   _snake_case							:	List[Any]			=						model(
       snake_case_,   start_positions=snake_case_,   end_positions=snake_case_,   cls_index=snake_case_,   is_impossible=snake_case_,   p_mask=snake_case_,   )

   _snake_case							:	Optional[Any]			=						model(
       snake_case_,   start_positions=snake_case_,   end_positions=snake_case_,   cls_index=snake_case_,   is_impossible=snake_case_,   )

   (_snake_case					)							:	Dict			=						result_with_labels.to_tuple()

   _snake_case							:	Optional[Any]			=						model(snake_case_,   start_positions=snake_case_,   end_positions=snake_case_	)

   (_snake_case					)							:	List[str]			=						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 				UpperCamelCase_     (       self:	List[str],   a_:	List[Any],   a_:	Tuple,   a_:	Dict,   a_:	Optional[Any],   a_:	int,   a_:	Any,   a_:	List[str],   a_:	List[str],   a_:	Optional[int],   ):




   '''simple docstring'''



   _snake_case							:	Union[str, Any]			=						XLMForSequenceClassification(snake_case_	)
   model.to(snake_case_	)
   model.eval()

   _snake_case							:	Optional[int]			=						model(snake_case_	)
   _snake_case							:	Union[str, 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 				UpperCamelCase_     (       self:	Dict,   a_:	str,   a_:	Dict,   a_:	List[str],   a_:	Union[str, Any],   a_:	Dict,   a_:	Tuple,   a_:	Dict,   a_:	Optional[Any],   a_:	List[Any],   ):




   '''simple docstring'''



   _snake_case							:	List[str]			=						self.num_labels
   _snake_case							:	Union[str, Any]			=						XLMForTokenClassification(snake_case_	)
   model.to(snake_case_	)
   model.eval()

   _snake_case							:	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 				UpperCamelCase_     (       self:	Optional[int],   a_:	Tuple,   a_:	Any,   a_:	int,   a_:	int,   a_:	Optional[Any],   a_:	Union[str, Any],   a_:	Optional[Any],   a_:	List[str],   a_:	Union[str, Any],   ):




   '''simple docstring'''



   _snake_case							:	List[str]			=						self.num_choices
   _snake_case							:	Union[str, Any]			=						XLMForMultipleChoice(config=snake_case_	)
   model.to(snake_case_	)
   model.eval()
   _snake_case							:	int			=						input_ids.unsqueeze(1	).expand(-1,   self.num_choices,   -1	).contiguous()
   _snake_case							:	int			=						token_type_ids.unsqueeze(1	).expand(-1,   self.num_choices,   -1	).contiguous()
   _snake_case							:	List[str]			=						input_mask.unsqueeze(1	).expand(-1,   self.num_choices,   -1	).contiguous()
   _snake_case							:	List[Any]			=						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 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Dict			=						self.prepare_config_and_inputs()
   (
       _snake_case					
   )							:	Any			=						config_and_inputs
   _snake_case							:	str			=						{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
   return config, inputs_dict







@require_torch
class       lowercase(  _snake_case ,    _snake_case ,    _snake_case ,    unittest.TestCase				):
 lowercase__				      =      (
     (
         XLMModel,
         XLMWithLMHeadModel,
         XLMForQuestionAnswering,
         XLMForSequenceClassification,
         XLMForQuestionAnsweringSimple,
         XLMForTokenClassification,
         XLMForMultipleChoice,
     )
     if is_torch_available()
     else ()
 )
 lowercase__				      =      (
     (XLMWithLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 lowercase__				      =      (
     {
         """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 				UpperCamelCase_     (       self:	List[Any],   a_:	Optional[int],   a_:	str,   a_:	Optional[Any],   a_:	Optional[int],   a_:	str	):




   '''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:	Dict,   a_:	Optional[int],   a_:	List[str],   a_:	Tuple=False	):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						super()._prepare_for_class(snake_case_,   snake_case_,   return_labels=snake_case_	)

   if return_labels:
     if model_class.__name__ == "XLMForQuestionAnswering":
       _snake_case							:	Any			=						torch.zeros(
           self.model_tester.batch_size,   dtype=torch.long,   device=snake_case_	)
       _snake_case							:	Union[str, Any]			=						torch.zeros(
           self.model_tester.batch_size,   dtype=torch.long,   device=snake_case_	)

   return inputs_dict


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




   '''simple docstring'''



   _snake_case							:	int			=						XLMModelTester(self	)
   _snake_case							:	Any			=						ConfigTester(self,   config_class=snake_case_,   emb_dim=37	)


 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   self.config_tester.run_common_tests()


 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   _snake_case							:	Tuple			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_model(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	int			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_lm_head(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	Union[str, Any]			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_simple_qa(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	str			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_qa(*snake_case_	)


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




   '''simple docstring'''



   _snake_case							:	Union[str, Any]			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	Any			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_token_classif(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Tuple	):




   '''simple docstring'''



   _snake_case							:	Dict			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_	)


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	Tuple,   a_:	List[Any],   a_:	Any,   a_:	int,   a_:	List[str],   a_:	Dict=False,   a_:	Optional[int]=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
     _snake_case							:	Optional[Any]			=						min_length + idx + 1
     _snake_case							:	Optional[Any]			=						min_length + idx + 1

     _snake_case							:	Any			=						(
         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 				UpperCamelCase_     (       self:	List[Any],   a_:	Tuple,   a_:	Dict,   a_:	str,   a_:	int,   a_:	str,   a_:	List[Any]=False,   a_:	Any=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
     _snake_case							:	Dict			=						min_length + idx + 1
     _snake_case							:	Optional[Any]			=						(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 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     _snake_case							:	Any			=						XLMModel.from_pretrained(snake_case_	)
     self.assertIsNotNone(snake_case_	)







@require_torch
class       lowercase(  unittest.TestCase				):


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




   '''simple docstring'''



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








"""simple docstring"""


from abc import ABC, abstractmethod
from argparse import ArgumentParser






class       lowercase(  __a				):







 '''simple docstring'''





 @staticmethod
 @abstractmethod
 def 				UpperCamelCase_     (       a_:	ArgumentParser	):




   '''simple docstring'''



   raise NotImplementedError()


 @abstractmethod
 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   raise NotImplementedError()


