





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 					A__   :





      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       ,							):
       '''simple docstring'''




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





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   ids_tensor([self.batch_size, self.seq_length]       ,							self.vocab_size   )
       UpperCamelCase	:					int       	=   random_attention_mask([self.batch_size, self.seq_length]   )

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

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

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

       UpperCamelCase	:					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   ):
       '''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       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					List[str]       	=   XLMModel(config=A_   )
       model.to(A_   )
       model.eval()
       UpperCamelCase	:					Optional[int]       	=   model(A_       ,							lengths=A_       ,							langs=A_   )
       UpperCamelCase	:					Optional[int]       	=   model(A_       ,							langs=A_   )
       UpperCamelCase	:					Any       	=   model(A_   )
       self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.seq_length, self.hidden_size)   )





      def        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					Union[str, Any]       	=   XLMWithLMHeadModel(A_   )
       model.to(A_   )
       model.eval()

       UpperCamelCase	:					List[Any]       	=   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        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					List[str]       	=   XLMForQuestionAnsweringSimple(A_   )
       model.to(A_   )
       model.eval()

       UpperCamelCase	:					str       	=   model(A_   )

       UpperCamelCase	:					List[Any]       	=   model(A_       ,							start_positions=A_       ,							end_positions=A_   )
       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        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					Optional[Any]       	=   XLMForQuestionAnswering(A_   )
       model.to(A_   )
       model.eval()

       UpperCamelCase	:					Tuple       	=   model(A_   )

       UpperCamelCase	:					int       	=   model(
           A_       ,							start_positions=A_       ,							end_positions=A_       ,							cls_index=A_       ,							is_impossible=A_       ,							p_mask=A_       ,							)

       UpperCamelCase	:					Dict       	=   model(
           A_       ,							start_positions=A_       ,							end_positions=A_       ,							cls_index=A_       ,							is_impossible=A_       ,							)

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

       UpperCamelCase	:					Tuple       	=   model(A_       ,							start_positions=A_       ,							end_positions=A_   )

       ((UpperCamelCase)	,    )	:					Any       	=   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       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					Any       	=   XLMForSequenceClassification(A_   )
       model.to(A_   )
       model.eval()

       UpperCamelCase	:					Any       	=   model(A_   )
       UpperCamelCase	:					str       	=   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        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




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

       UpperCamelCase	:					Optional[int]       	=   model(A_       ,							attention_mask=A_       ,							labels=A_   )
       self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.seq_length, self.num_labels)   )





      def        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					Optional[int]       	=   self.num_choices
       UpperCamelCase	:					Tuple       	=   XLMForMultipleChoice(config=A_   )
       model.to(A_   )
       model.eval()
       UpperCamelCase	:					str       	=   input_ids.unsqueeze(1   ).expand(-1       ,							self.num_choices       ,							-1   ).contiguous()
       UpperCamelCase	:					Optional[Any]       	=   token_type_ids.unsqueeze(1   ).expand(-1       ,							self.num_choices       ,							-1   ).contiguous()
       UpperCamelCase	:					List[Any]       	=   input_mask.unsqueeze(1   ).expand(-1       ,							self.num_choices       ,							-1   ).contiguous()
       UpperCamelCase	:					Optional[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        __UpperCamelCase( self   ):
       '''simple docstring'''




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



@require_torch
class 					A__   (       __snake_case       ,   __snake_case       ,   __snake_case       ,   unittest.TestCase			):
      _UpperCAmelCase	:int						    =   (
          (
              XLMModel,
              XLMWithLMHeadModel,
              XLMForQuestionAnswering,
              XLMForSequenceClassification,
              XLMForQuestionAnsweringSimple,
              XLMForTokenClassification,
              XLMForMultipleChoice,
          )
          if is_torch_available()
          else ()
      )
      _UpperCAmelCase	:Optional[Any]						    =   (
          (XLMWithLMHeadModel,) if is_torch_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      _UpperCAmelCase	: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        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_   ):
       '''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       ,							A_       ,							A_       ,							A_=False   ):
       '''simple docstring'''




       UpperCamelCase	:					Union[str, Any]       	=   super()._prepare_for_class(A_       ,							A_       ,							return_labels=A_   )

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

       return inputs_dict





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[int]       	=   XLMModelTester(self   )
       UpperCamelCase	:					Any       	=   ConfigTester(self       ,							config_class=A_       ,							emb_dim=37   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       self.config_tester.run_common_tests()





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					str       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_model(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_lm_head(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					Tuple       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_simple_qa(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					List[Any]       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_qa(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_sequence_classif(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					List[str]       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_token_classif(*A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					str       	=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_multiple_choice(*A_   )





      def        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_=False       ,							A_=1   ):
       '''simple docstring'''




       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
        UpperCamelCase	:					str       	=   min_length + idx + 1
        UpperCamelCase	:					int       	=   min_length + idx + 1

        UpperCamelCase	:					str       	=   (
            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        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_       ,							A_=False       ,							A_=1   ):
       '''simple docstring'''




       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
        UpperCamelCase	:					Any       	=   min_length + idx + 1
        UpperCamelCase	:					Optional[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(A_   )       ,							)
       pass





      @slow
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCamelCase	:					Optional[Any]       	=   XLMModel.from_pretrained(A_   )
        self.assertIsNotNone(A_   )



@require_torch
class 					A__   (       unittest.TestCase			):





      @slow
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




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








def 						_a    (      a :int )							->			list:

 # bit count represents no. of bits in the gray code
 if bit_count < 0:
  raise ValueError('''The given input must be positive''' )

 # get the generated string sequence
 a		  =      gray_code_sequence_string(a )
 #
 # convert them to integers
 for i in range(len(a ) ):
  a		  =      int(sequence[i]	,							2 )

 return sequence
def 						_a    (      a :int )							->			list:

 # The approach is a recursive one
 # Base case achieved when either n = 0 or n=1
 if bit_count == 0:
  return ["0"]

 if bit_count == 1:
  return ["0", "1"]

 a		  =      1 << bit_count  # defines the length of the sequence
 # 1<< n is equivalent to 2^n

 # recursive answer will generate answer for n-1 bits
 a		  =      gray_code_sequence_string(bit_count - 1 )

 a		  =      []

 # append 0 to first half of the smaller sequence generated
 for i in range(seq_len // 2 ):
  a		  =      '''0''' + smaller_sequence[i]
  sequence.append(a )

 # append 1 to second half ... start from the end of the list
 for i in reversed(range(seq_len // 2 ) ):
  a		  =      '''1''' + smaller_sequence[i]
  sequence.append(a )

 return sequence


if __name__ == "__main__":
     import doctest

     doctest.testmod()


