


'''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  __magic_name__							:






       def __init__(      self  ,							snake_case  ,							snake_case=1_3  ,							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=9_9  ,							snake_case=0  ,							snake_case=3_2  ,							snake_case=5  ,							snake_case=4  ,							snake_case=0.1  ,							snake_case=0.1  ,							snake_case=5_1_2  ,							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  ,							)						->  Tuple:




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






       def       lowerCAmelCase		(      self)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =ids_tensor([self.batch_size, self.seq_length]  ,							self.vocab_size)
          _UpperCAmelCase       :       str							   =random_attention_mask([self.batch_size, self.seq_length])

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

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

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

          _UpperCAmelCase       :       List[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       lowerCAmelCase		(      self)						->  List[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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Union[str, Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Union[str, Any]							   =XLMModel(config=snake_case)
          model.to(snake_case)
          model.eval()
          _UpperCAmelCase       :       Tuple							   =model(snake_case  ,							lengths=snake_case  ,							langs=snake_case)
          _UpperCAmelCase       :       Union[str, Any]							   =model(snake_case  ,							langs=snake_case)
          _UpperCAmelCase       :       str							   =model(snake_case)
          self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size))






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =XLMWithLMHeadModel(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase       :       Dict							   =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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =XLMForQuestionAnsweringSimple(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase       :       int							   =model(snake_case)

          _UpperCAmelCase       :       str							   =model(snake_case  ,							start_positions=snake_case  ,							end_positions=snake_case)
          _UpperCAmelCase       :       Optional[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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =XLMForQuestionAnswering(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase       :       int							   =model(snake_case)

          _UpperCAmelCase       :       Optional[Any]							   =model(
              snake_case  ,							start_positions=snake_case  ,							end_positions=snake_case  ,							cls_index=snake_case  ,							is_impossible=snake_case  ,							p_mask=snake_case  ,							)

          _UpperCAmelCase       :       List[str]							   =model(
              snake_case  ,							start_positions=snake_case  ,							end_positions=snake_case  ,							cls_index=snake_case  ,							is_impossible=snake_case  ,							)

          ((_UpperCAmelCase)   ,	)       :       List[Any]							   =result_with_labels.to_tuple()

          _UpperCAmelCase       :       List[Any]							   =model(snake_case  ,							start_positions=snake_case  ,							end_positions=snake_case)

          ((_UpperCAmelCase)   ,	)       :       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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =XLMForSequenceClassification(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase       :       Optional[int]							   =model(snake_case)
          _UpperCAmelCase       :       List[str]							   =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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Dict:




          '''simple docstring'''
          _UpperCAmelCase       :       Any							   =self.num_labels
          _UpperCAmelCase       :       int							   =XLMForTokenClassification(snake_case)
          model.to(snake_case)
          model.eval()

          _UpperCAmelCase       :       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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       Any							   =self.num_choices
          _UpperCAmelCase       :       List[str]							   =XLMForMultipleChoice(config=snake_case)
          model.to(snake_case)
          model.eval()
          _UpperCAmelCase       :       Any							   =input_ids.unsqueeze(1).expand(-1  ,							self.num_choices  ,							-1).contiguous()
          _UpperCAmelCase       :       List[str]							   =token_type_ids.unsqueeze(1).expand(-1  ,							self.num_choices  ,							-1).contiguous()
          _UpperCAmelCase       :       List[str]							   =input_mask.unsqueeze(1).expand(-1  ,							self.num_choices  ,							-1).contiguous()
          _UpperCAmelCase       :       Union[str, 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       lowerCAmelCase		(      self)						->  Union[str, Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =self.prepare_config_and_inputs()
          (
              (
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	(
              _UpperCAmelCase
          )   ,	
          )       :       Tuple							   =config_and_inputs
          _UpperCAmelCase       :       Any							   ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
          return config, inputs_dict






@require_torch
class  __magic_name__							(		lowerCAmelCase ,lowerCAmelCase ,lowerCAmelCase ,unittest.TestCase    ):
       UpperCAmelCase										=(
           (
               XLMModel,
               XLMWithLMHeadModel,
               XLMForQuestionAnswering,
               XLMForSequenceClassification,
               XLMForQuestionAnsweringSimple,
               XLMForTokenClassification,
               XLMForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       UpperCAmelCase										=(
           (XLMWithLMHeadModel,) if is_torch_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       UpperCAmelCase										=(
           {
               "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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case)						->  int:




          '''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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case=False)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       Union[str, Any]							   =super()._prepare_for_class(snake_case  ,							snake_case  ,							return_labels=snake_case)

          if return_labels:
             if model_class.__name__ == "XLMForQuestionAnswering":
                _UpperCAmelCase       :       Any							   =torch.zeros(
                    self.model_tester.batch_size  ,							dtype=torch.long  ,							device=snake_case)
                _UpperCAmelCase       :       Dict							   =torch.zeros(
                    self.model_tester.batch_size  ,							dtype=torch.long  ,							device=snake_case)

          return inputs_dict






       def       lowerCAmelCase		(      self)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =XLMModelTester(self)
          _UpperCAmelCase       :       Optional[int]							   =ConfigTester(self  ,							config_class=snake_case  ,							emb_dim=3_7)






       def       lowerCAmelCase		(      self)						->  List[Any]:




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






       def       lowerCAmelCase		(      self)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*snake_case)






       def       lowerCAmelCase		(      self)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       int							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*snake_case)






       def       lowerCAmelCase		(      self)						->  List[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*snake_case)






       def       lowerCAmelCase		(      self)						->  Dict:




          '''simple docstring'''
          _UpperCAmelCase       :       List[Any]							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*snake_case)






       def       lowerCAmelCase		(      self)						->  Dict:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*snake_case)






       def       lowerCAmelCase		(      self)						->  Union[str, Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*snake_case)






       def       lowerCAmelCase		(      self)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case)






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case=False  ,							snake_case=1)						->  Dict:




          '''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
             _UpperCAmelCase       :       List[Any]							   =min_length + idx + 1
             _UpperCAmelCase       :       str							   =min_length + idx + 1

             _UpperCAmelCase       :       Union[str, 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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case  ,							snake_case=False  ,							snake_case=1)						->  Dict:




          '''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
             _UpperCAmelCase       :       Optional[Any]							   =min_length + idx + 1
             _UpperCAmelCase       :       int							   =(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       lowerCAmelCase		(      self)						->  int:




          '''simple docstring'''
          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _UpperCAmelCase       :       str							   =XLMModel.from_pretrained(snake_case)
             self.assertIsNotNone(snake_case)






@require_torch
class  __magic_name__							(		unittest.TestCase    ):






       @slow
       def       lowerCAmelCase		(      self)						->  List[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048')
          model.to(snake_case)
          _UpperCAmelCase       :       str							   =torch.tensor([[1_4, 4_4_7]]  ,							dtype=torch.long  ,							device=snake_case)  # the president
          _UpperCAmelCase       :       Union[str, Any]							   =[
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
              1_4,
              4_4_7,
          ]  # 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       :       List[Any]							   =model.generate(snake_case  ,							do_sample=snake_case)
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()  ,							snake_case)





'''simple docstring'''






from __future__ import annotations





def lowerCamelCase__      (						__lowerCamelCase	:							list[int]							):







   '''simple docstring'''




   if not nums:
      return 0
   _UpperCAmelCase       :       Tuple							   =nums[0]
   _UpperCAmelCase       :       int							   =0
   for num in nums[1:]:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       Optional[int]							   =(
          max_excluding + num,
          max(__lowerCamelCase	,   __lowerCamelCase							),
      )
   return max(__lowerCamelCase	,   __lowerCamelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

