





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




 def __init__(						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase=13      ,  _lowerCAmelCase=7      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=2      ,  _lowerCAmelCase=99      ,  _lowerCAmelCase=0      ,  _lowerCAmelCase=32      ,  _lowerCAmelCase=5      ,  _lowerCAmelCase=4      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=512      ,  _lowerCAmelCase=2      ,  _lowerCAmelCase=0.02      ,  _lowerCAmelCase=2      ,  _lowerCAmelCase=4      ,  _lowerCAmelCase="last"      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=None      ,  _lowerCAmelCase=0      ,  )     ->				Any:
     _lowerCAmelCase						      =   parent
     _lowerCAmelCase						      =   batch_size
     _lowerCAmelCase						      =   seq_length
     _lowerCAmelCase						      =   is_training
     _lowerCAmelCase						      =   use_input_lengths
     _lowerCAmelCase						      =   use_token_type_ids
     _lowerCAmelCase						      =   use_labels
     _lowerCAmelCase						      =   gelu_activation
     _lowerCAmelCase						      =   sinusoidal_embeddings
     _lowerCAmelCase						      =   causal
     _lowerCAmelCase						      =   asm
     _lowerCAmelCase						      =   n_langs
     _lowerCAmelCase						      =   vocab_size
     _lowerCAmelCase						      =   n_special
     _lowerCAmelCase						      =   hidden_size
     _lowerCAmelCase						      =   num_hidden_layers
     _lowerCAmelCase						      =   num_attention_heads
     _lowerCAmelCase						      =   hidden_dropout_prob
     _lowerCAmelCase						      =   attention_probs_dropout_prob
     _lowerCAmelCase						      =   max_position_embeddings
     _lowerCAmelCase						      =   type_sequence_label_size
     _lowerCAmelCase						      =   initializer_range
     _lowerCAmelCase						      =   num_labels
     _lowerCAmelCase						      =   num_choices
     _lowerCAmelCase						      =   summary_type
     _lowerCAmelCase						      =   use_proj
     _lowerCAmelCase						      =   scope
     _lowerCAmelCase						      =   bos_token_id




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size		)
     _lowerCAmelCase						      =   random_attention_mask([self.batch_size, self.seq_length]		)

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

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

     _lowerCAmelCase						      =   None
     _lowerCAmelCase						      =   None
     _lowerCAmelCase						      =   None
     if self.use_labels:
         _lowerCAmelCase						      =   ids_tensor([self.batch_size]      ,  self.type_sequence_label_size		)
         _lowerCAmelCase						      =   ids_tensor([self.batch_size, self.seq_length]      ,  self.num_labels		)
         _lowerCAmelCase						      =   ids_tensor([self.batch_size]      ,  2		).float()
         _lowerCAmelCase						      =   ids_tensor([self.batch_size]      ,  self.num_choices		)

     _lowerCAmelCase						      =   self.get_config()

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




 def 				_snake_case (						self		)     ->				List[str]:
     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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				Dict:
     _lowerCAmelCase						      =   XLMModel(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  lengths=_lowerCAmelCase      ,  langs=_lowerCAmelCase		)
     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  langs=_lowerCAmelCase		)
     _lowerCAmelCase						      =   model(_lowerCAmelCase		)
     self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				Dict:
     _lowerCAmelCase						      =   XLMWithLMHeadModel(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()

     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  token_type_ids=_lowerCAmelCase      ,  labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.loss.shape      ,  ()		)
     self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				str:
     _lowerCAmelCase						      =   XLMForQuestionAnsweringSimple(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()

     _lowerCAmelCase						      =   model(_lowerCAmelCase		)

     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  start_positions=_lowerCAmelCase      ,  end_positions=_lowerCAmelCase		)
     _lowerCAmelCase						      =   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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				Tuple:
     _lowerCAmelCase						      =   XLMForQuestionAnswering(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()

     _lowerCAmelCase						      =   model(_lowerCAmelCase		)

     _lowerCAmelCase						      =   model(
         _lowerCAmelCase      ,  start_positions=_lowerCAmelCase      ,  end_positions=_lowerCAmelCase      ,  cls_index=_lowerCAmelCase      ,  is_impossible=_lowerCAmelCase      ,  p_mask=_lowerCAmelCase      ,  )

     _lowerCAmelCase						      =   model(
         _lowerCAmelCase      ,  start_positions=_lowerCAmelCase      ,  end_positions=_lowerCAmelCase      ,  cls_index=_lowerCAmelCase      ,  is_impossible=_lowerCAmelCase      ,  )

     ((_lowerCAmelCase)      ,      )						      =   result_with_labels.to_tuple()

     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  start_positions=_lowerCAmelCase      ,  end_positions=_lowerCAmelCase		)

     ((_lowerCAmelCase)      ,      )						      =   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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				Union[str, Any]:
     _lowerCAmelCase						      =   XLMForSequenceClassification(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()

     _lowerCAmelCase						      =   model(_lowerCAmelCase		)
     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.loss.shape      ,  ()		)
     self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				int:
     _lowerCAmelCase						      =   self.num_labels
     _lowerCAmelCase						      =   XLMForTokenClassification(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()

     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  attention_mask=_lowerCAmelCase      ,  labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  )     ->				Union[str, Any]:
     _lowerCAmelCase						      =   self.num_choices
     _lowerCAmelCase						      =   XLMForMultipleChoice(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase						      =   input_ids.unsqueeze(1		).expand(-1      ,  self.num_choices      ,  -1		).contiguous()
     _lowerCAmelCase						      =   token_type_ids.unsqueeze(1		).expand(-1      ,  self.num_choices      ,  -1		).contiguous()
     _lowerCAmelCase						      =   input_mask.unsqueeze(1		).expand(-1      ,  self.num_choices      ,  -1		).contiguous()
     _lowerCAmelCase						      =   model(
         _lowerCAmelCase      ,  attention_mask=_lowerCAmelCase      ,  token_type_ids=_lowerCAmelCase      ,  labels=_lowerCAmelCase      ,  )
     self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_choices)		)





 def 				_snake_case (						self		)     ->				Optional[int]:
     _lowerCAmelCase						      =   self.prepare_config_and_inputs()
     (
         (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      
     )						      =   config_and_inputs
     _lowerCAmelCase						      =   {"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
     return config, inputs_dict







@require_torch
class  lowerCAmelCase_		(		__magic_name__    ,__magic_name__    ,__magic_name__    ,unittest.TestCase		):
 __lowerCamelCase    :				int								=       (
     (
         XLMModel,
         XLMWithLMHeadModel,
         XLMForQuestionAnswering,
         XLMForSequenceClassification,
         XLMForQuestionAnsweringSimple,
         XLMForTokenClassification,
         XLMForMultipleChoice,
     )
     if is_torch_available()
     else ()
 )
 __lowerCamelCase    :				Tuple								=       (
     (XLMWithLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 __lowerCamelCase    :				List[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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				Optional[int]:
     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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase=False		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   super()._prepare_for_class(_lowerCAmelCase      ,  _lowerCAmelCase      ,  return_labels=_lowerCAmelCase		)

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

     return inputs_dict




 def 				_snake_case (						self		)     ->				Optional[int]:
     _lowerCAmelCase						      =   XLMModelTester(self		)
     _lowerCAmelCase						      =   ConfigTester(self      ,  config_class=_lowerCAmelCase      ,  emb_dim=37		)




 def 				_snake_case (						self		)     ->				Optional[Any]:
     self.config_tester.run_common_tests()




 def 				_snake_case (						self		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_model(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_lm_head(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Optional[int]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_simple_qa(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Any:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_qa(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Optional[int]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_sequence_classif(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_token_classif(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Dict:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowerCAmelCase		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=1		)     ->				int:
     self.assertIsInstance(_lowerCAmelCase      ,  _lowerCAmelCase		)
     self.assertListEqual(
         [isinstance(_lowerCAmelCase      ,  _lowerCAmelCase		) for iter_attentions in attentions]      ,  [True] * len(_lowerCAmelCase		)		)
     self.assertEqual(len(_lowerCAmelCase		)      ,  (max_length - min_length) * num_beam_groups		)

     for idx, iter_attentions in enumerate(_lowerCAmelCase		):
         # adds PAD dummy token
         _lowerCAmelCase						      =   min_length + idx + 1
         _lowerCAmelCase						      =   min_length + idx + 1

         _lowerCAmelCase						      =   (
             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(_lowerCAmelCase		)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=1		)     ->				Union[str, Any]:
     self.assertIsInstance(_lowerCAmelCase      ,  _lowerCAmelCase		)
     self.assertListEqual(
         [isinstance(_lowerCAmelCase      ,  _lowerCAmelCase		) for iter_hidden_states in hidden_states]      ,  [True] * len(_lowerCAmelCase		)      ,  )
     self.assertEqual(len(_lowerCAmelCase		)      ,  (max_length - min_length) * num_beam_groups		)

     for idx, iter_hidden_states in enumerate(_lowerCAmelCase		):
         # adds PAD dummy token
         _lowerCAmelCase						      =   min_length + idx + 1
         _lowerCAmelCase						      =   (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(_lowerCAmelCase		)      ,  )
     pass





 @slow
 def 				_snake_case (						self		)     ->				str:
     for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase						      =   XLMModel.from_pretrained(_lowerCAmelCase		)
         self.assertIsNotNone(_lowerCAmelCase		)







@require_torch
class  lowerCAmelCase_		(		unittest.TestCase		):




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









'''simple docstring'''


import warnings

from ...utils import logging
from .image_processing_yolos import YolosImageProcessor


_SCREAMING_SNAKE_CASE									=				logging.get_logger(__name__)

class  lowerCAmelCase_		(		__magic_name__		):




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				None:
     warnings.warn(
         "The class YolosFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
         " use YolosImageProcessor instead."      ,  _lowerCAmelCase      ,  )
     super().__init__(*_lowerCAmelCase      ,  **_lowerCAmelCase		)


