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






   """simple docstring"""
   def __init__(self       ,				_a       ,				_a=13       ,				_a=7       ,				_a=True       ,				_a=True       ,				_a=True       ,				_a=True       ,				_a=True       ,				_a=False       ,				_a=False       ,				_a=False       ,				_a=2       ,				_a=99       ,				_a=0       ,				_a=32       ,				_a=5       ,				_a=4       ,				_a=0.1       ,				_a=0.1       ,				_a=512       ,				_a=2       ,				_a=0.02       ,				_a=2       ,				_a=4       ,				_a="last"       ,				_a=True       ,				_a=None       ,				_a=0       ,				)    ->     Optional[Any]:
        lowercase_					:       str     				=					parent
        lowercase_					:       Optional[int]     				=					batch_size
        lowercase_					:       Dict     				=					seq_length
        lowercase_					:       int     				=					is_training
        lowercase_					:       str     				=					use_input_lengths
        lowercase_					:       Tuple     				=					use_token_type_ids
        lowercase_					:       str     				=					use_labels
        lowercase_					:       Tuple     				=					gelu_activation
        lowercase_					:       Dict     				=					sinusoidal_embeddings
        lowercase_					:       str     				=					causal
        lowercase_					:       Dict     				=					asm
        lowercase_					:       str     				=					n_langs
        lowercase_					:       Union[str, Any]     				=					vocab_size
        lowercase_					:       Optional[int]     				=					n_special
        lowercase_					:       Dict     				=					hidden_size
        lowercase_					:       Optional[Any]     				=					num_hidden_layers
        lowercase_					:       List[Any]     				=					num_attention_heads
        lowercase_					:       Union[str, Any]     				=					hidden_dropout_prob
        lowercase_					:       Union[str, Any]     				=					attention_probs_dropout_prob
        lowercase_					:       Optional[Any]     				=					max_position_embeddings
        lowercase_					:       int     				=					type_sequence_label_size
        lowercase_					:       Dict     				=					initializer_range
        lowercase_					:       Optional[int]     				=					num_labels
        lowercase_					:       Union[str, Any]     				=					num_choices
        lowercase_					:       int     				=					summary_type
        lowercase_					:       List[Any]     				=					use_proj
        lowercase_					:       Optional[int]     				=					scope
        lowercase_					:       Tuple     				=					bos_token_id
   def 		_lowerCamelCase (self				)    ->     Dict:
        lowercase_					:       str     				=					ids_tensor([self.batch_size, self.seq_length]       ,				self.vocab_size				)
        lowercase_					:       Optional[Any]     				=					random_attention_mask([self.batch_size, self.seq_length]				)

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

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

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

        lowercase_					:       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				)    ->     Any:
        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       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     str:
        lowercase_					:       Tuple     				=					XLMModel(config=A__				)
        model.to(A__				)
        model.eval()
        lowercase_					:       str     				=					model(A__       ,				lengths=A__       ,				langs=A__				)
        lowercase_					:       Any     				=					model(A__       ,				langs=A__				)
        lowercase_					:       Optional[Any]     				=					model(A__				)
        self.parent.assertEqual(result.last_hidden_state.shape       ,				(self.batch_size, self.seq_length, self.hidden_size)				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     Union[str, Any]:
        lowercase_					:       Optional[int]     				=					XLMWithLMHeadModel(A__				)
        model.to(A__				)
        model.eval()

        lowercase_					:       Optional[int]     				=					model(A__       ,				token_type_ids=A__       ,				labels=A__				)
        self.parent.assertEqual(result.loss.shape       ,				()				)
        self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.seq_length, self.vocab_size)				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     List[str]:
        lowercase_					:       List[str]     				=					XLMForQuestionAnsweringSimple(A__				)
        model.to(A__				)
        model.eval()

        lowercase_					:       str     				=					model(A__				)

        lowercase_					:       Optional[int]     				=					model(A__       ,				start_positions=A__       ,				end_positions=A__				)
        lowercase_					:       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 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     Union[str, Any]:
        lowercase_					:       Any     				=					XLMForQuestionAnswering(A__				)
        model.to(A__				)
        model.eval()

        lowercase_					:       Any     				=					model(A__				)

        lowercase_					:       List[Any]     				=					model(
            A__       ,				start_positions=A__       ,				end_positions=A__       ,				cls_index=A__       ,				is_impossible=A__       ,				p_mask=A__       ,				)

        lowercase_					:       int     				=					model(
            A__       ,				start_positions=A__       ,				end_positions=A__       ,				cls_index=A__       ,				is_impossible=A__       ,				)

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

        lowercase_					:       str     				=					model(A__       ,				start_positions=A__       ,				end_positions=A__				)

        ((lowercase_		)				,		)					:       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 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     int:
        lowercase_					:       Any     				=					XLMForSequenceClassification(A__				)
        model.to(A__				)
        model.eval()

        lowercase_					:       List[Any]     				=					model(A__				)
        lowercase_					:       List[Any]     				=					model(A__       ,				labels=A__				)
        self.parent.assertEqual(result.loss.shape       ,				()				)
        self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.type_sequence_label_size)				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     Dict:
        lowercase_					:       Optional[int]     				=					self.num_labels
        lowercase_					:       int     				=					XLMForTokenClassification(A__				)
        model.to(A__				)
        model.eval()

        lowercase_					:       Optional[Any]     				=					model(A__       ,				attention_mask=A__       ,				labels=A__				)
        self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.seq_length, self.num_labels)				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				)    ->     Optional[Any]:
        lowercase_					:       str     				=					self.num_choices
        lowercase_					:       List[Any]     				=					XLMForMultipleChoice(config=A__				)
        model.to(A__				)
        model.eval()
        lowercase_					:       Optional[int]     				=					input_ids.unsqueeze(1				).expand(-1       ,				self.num_choices       ,				-1				).contiguous()
        lowercase_					:       int     				=					token_type_ids.unsqueeze(1				).expand(-1       ,				self.num_choices       ,				-1				).contiguous()
        lowercase_					:       List[str]     				=					input_mask.unsqueeze(1				).expand(-1       ,				self.num_choices       ,				-1				).contiguous()
        lowercase_					:       int     				=					model(
            A__       ,				attention_mask=A__       ,				token_type_ids=A__       ,				labels=A__       ,				)
        self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.num_choices)				)





   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        lowercase_					:       Optional[int]     				=					self.prepare_config_and_inputs()
        (
            (
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,(
            lowercase_		
        )				,		
        )					:       Dict     				=					config_and_inputs
        lowercase_					:       Union[str, Any]     				=					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
        return config, inputs_dict



@require_torch
class       UpperCAmelCase__  (       __a					,     __a					,     __a					,     unittest.TestCase			):






   """simple docstring"""
   A							:       List[str]     =    (
       (
           XLMModel,
           XLMWithLMHeadModel,
           XLMForQuestionAnswering,
           XLMForSequenceClassification,
           XLMForQuestionAnsweringSimple,
           XLMForTokenClassification,
           XLMForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   A							:       int     =    (
       (XLMWithLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Check other models whether language generation is also applicable
   A							:       Tuple     =    (
       {
           '''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       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a				)    ->     Any:
        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       ,				_a       ,				_a       ,				_a=False				)    ->     Optional[int]:
        lowercase_					:       Tuple     				=					super()._prepare_for_class(A__       ,				A__       ,				return_labels=A__				)

        if return_labels:
             if model_class.__name__ == "XLMForQuestionAnswering":
                  lowercase_					:       Any     				=					torch.zeros(
                      self.model_tester.batch_size       ,				dtype=torch.long       ,				device=A__				)
                  lowercase_					:       List[Any]     				=					torch.zeros(
                      self.model_tester.batch_size       ,				dtype=torch.long       ,				device=A__				)

        return inputs_dict
   def 		_lowerCamelCase (self				)    ->     Optional[int]:
        lowercase_					:       Dict     				=					XLMModelTester(self				)
        lowercase_					:       str     				=					ConfigTester(self       ,				config_class=A__       ,				emb_dim=37				)
   def 		_lowerCamelCase (self				)    ->     List[Any]:
        self.config_tester.run_common_tests()
   def 		_lowerCamelCase (self				)    ->     Tuple:
        lowercase_					:       int     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_model(*A__				)
   def 		_lowerCamelCase (self				)    ->     str:
        lowercase_					:       Dict     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_lm_head(*A__				)
   def 		_lowerCamelCase (self				)    ->     Tuple:
        lowercase_					:       Union[str, Any]     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_simple_qa(*A__				)
   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        lowercase_					:       Any     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_qa(*A__				)
   def 		_lowerCamelCase (self				)    ->     Dict:
        lowercase_					:       str     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_sequence_classif(*A__				)
   def 		_lowerCamelCase (self				)    ->     List[str]:
        lowercase_					:       str     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_token_classif(*A__				)
   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        lowercase_					:       Optional[int]     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_for_multiple_choice(*A__				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a=False       ,				_a=1				)    ->     Any:
        self.assertIsInstance(A__       ,				A__				)
        self.assertListEqual(
            [isinstance(A__       ,				A__				) for iter_attentions in attentions]       ,				[True] * len(A__				)				)
        self.assertEqual(len(A__				)       ,				(max_length - min_length) * num_beam_groups				)

        for idx, iter_attentions in enumerate(A__				):
             # adds PAD dummy token
             lowercase_					:       Any     				=					min_length + idx + 1
             lowercase_					:       List[Any]     				=					min_length + idx + 1

             lowercase_					:       Optional[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(A__				)				)
   def 		_lowerCamelCase (self       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a       ,				_a=False       ,				_a=1				)    ->     Tuple:
        self.assertIsInstance(A__       ,				A__				)
        self.assertListEqual(
            [isinstance(A__       ,				A__				) for iter_hidden_states in hidden_states]       ,				[True] * len(A__				)       ,				)
        self.assertEqual(len(A__				)       ,				(max_length - min_length) * num_beam_groups				)

        for idx, iter_hidden_states in enumerate(A__				):
             # adds PAD dummy token
             lowercase_					:       List[str]     				=					min_length + idx + 1
             lowercase_					:       List[str]     				=					(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(A__				)       ,				)
        pass





   @slow
   def 		_lowerCamelCase (self				)    ->     Tuple:
        for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_					:       List[Any]     				=					XLMModel.from_pretrained(A__				)
             self.assertIsNotNone(A__				)



@require_torch
class       UpperCAmelCase__  (       unittest.TestCase			):






   """simple docstring"""
   @slow
   def 		_lowerCamelCase (self				)    ->     List[str]:
        lowercase_					:       List[Any]     				=					XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'				)
        model.to(A__				)
        lowercase_					:       List[Any]     				=					torch.tensor([[14, 447]]       ,				dtype=torch.long       ,				device=A__				)  # the president
        lowercase_					:       List[str]     				=					[
            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
        lowercase_					:       Optional[int]     				=					model.generate(A__       ,				do_sample=A__				)
        self.assertListEqual(output_ids[0].cpu().numpy().tolist()       ,				A__				)





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A								=   {
    'configuration_bigbird_pegasus': [
        'BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'BigBirdPegasusConfig',
        'BigBirdPegasusOnnxConfig',
    ],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _A								=   [
     'BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST',
     'BigBirdPegasusForCausalLM',
     'BigBirdPegasusForConditionalGeneration',
     'BigBirdPegasusForQuestionAnswering',
     'BigBirdPegasusForSequenceClassification',
     'BigBirdPegasusModel',
     'BigBirdPegasusPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_bigbird_pegasus import (
     BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
     BigBirdPegasusConfig,
     BigBirdPegasusOnnxConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_bigbird_pegasus import (
      BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
      BigBirdPegasusForCausalLM,
      BigBirdPegasusForConditionalGeneration,
      BigBirdPegasusForQuestionAnswering,
      BigBirdPegasusForSequenceClassification,
      BigBirdPegasusModel,
      BigBirdPegasusPreTrainedModel,
  )


else:
 import sys

 _A								=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




