





"""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  :
       """simple docstring"""




       def __init__(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase=1_3       ,					__UpperCAmelCase=7       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=2       ,					__UpperCAmelCase=9_9       ,					__UpperCAmelCase=0       ,					__UpperCAmelCase=3_2       ,					__UpperCAmelCase=5       ,					__UpperCAmelCase=4       ,					__UpperCAmelCase=0.1       ,					__UpperCAmelCase=0.1       ,					__UpperCAmelCase=5_1_2       ,					__UpperCAmelCase=2       ,					__UpperCAmelCase=0.02       ,					__UpperCAmelCase=2       ,					__UpperCAmelCase=4       ,					__UpperCAmelCase="last"       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=None       ,					__UpperCAmelCase=0       ,					):



         '''simple docstring'''

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






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Any											=				ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size )
         lowerCAmelCase__     :Tuple											=				random_attention_mask([self.batch_size, self.seq_length] )

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

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

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

         lowerCAmelCase__     :Tuple											=				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 ):



         '''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 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

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






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :List[str]											=				XLMWithLMHeadModel(__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()

         lowerCAmelCase__     :Any											=				model(__UpperCAmelCase       ,					token_type_ids=__UpperCAmelCase       ,					labels=__UpperCAmelCase )
         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       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :Tuple											=				XLMForQuestionAnsweringSimple(__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()

         lowerCAmelCase__     :str											=				model(__UpperCAmelCase )

         lowerCAmelCase__     :List[Any]											=				model(__UpperCAmelCase       ,					start_positions=__UpperCAmelCase       ,					end_positions=__UpperCAmelCase )
         lowerCAmelCase__     :Tuple											=				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       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :Optional[int]											=				XLMForQuestionAnswering(__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()

         lowerCAmelCase__     :Tuple											=				model(__UpperCAmelCase )

         lowerCAmelCase__     :str											=				model(
             __UpperCAmelCase       ,					start_positions=__UpperCAmelCase       ,					end_positions=__UpperCAmelCase       ,					cls_index=__UpperCAmelCase       ,					is_impossible=__UpperCAmelCase       ,					p_mask=__UpperCAmelCase       ,					)

         lowerCAmelCase__     :int											=				model(
             __UpperCAmelCase       ,					start_positions=__UpperCAmelCase       ,					end_positions=__UpperCAmelCase       ,					cls_index=__UpperCAmelCase       ,					is_impossible=__UpperCAmelCase       ,					)

         ((lowerCAmelCase__)				,							)     :Tuple											=				result_with_labels.to_tuple()

         lowerCAmelCase__     :Tuple											=				model(__UpperCAmelCase       ,					start_positions=__UpperCAmelCase       ,					end_positions=__UpperCAmelCase )

         ((lowerCAmelCase__)				,							)     :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 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :int											=				XLMForSequenceClassification(__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()

         lowerCAmelCase__     :Optional[int]											=				model(__UpperCAmelCase )
         lowerCAmelCase__     :str											=				model(__UpperCAmelCase       ,					labels=__UpperCAmelCase )
         self.parent.assertEqual(result.loss.shape       ,					() )
         self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.type_sequence_label_size) )






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :Tuple											=				self.num_labels
         lowerCAmelCase__     :Any											=				XLMForTokenClassification(__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()

         lowerCAmelCase__     :Union[str, Any]											=				model(__UpperCAmelCase       ,					attention_mask=__UpperCAmelCase       ,					labels=__UpperCAmelCase )
         self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.seq_length, self.num_labels) )






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					):



         '''simple docstring'''

         lowerCAmelCase__     :List[str]											=				self.num_choices
         lowerCAmelCase__     :str											=				XLMForMultipleChoice(config=__UpperCAmelCase )
         model.to(__UpperCAmelCase )
         model.eval()
         lowerCAmelCase__     :str											=				input_ids.unsqueeze(1 ).expand(-1       ,					self.num_choices       ,					-1 ).contiguous()
         lowerCAmelCase__     :Tuple											=				token_type_ids.unsqueeze(1 ).expand(-1       ,					self.num_choices       ,					-1 ).contiguous()
         lowerCAmelCase__     :Dict											=				input_mask.unsqueeze(1 ).expand(-1       ,					self.num_choices       ,					-1 ).contiguous()
         lowerCAmelCase__     :Dict											=				model(
             __UpperCAmelCase       ,					attention_mask=__UpperCAmelCase       ,					token_type_ids=__UpperCAmelCase       ,					labels=__UpperCAmelCase       ,					)
         self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.num_choices) )






       def 	snake_case		(       self ):



         '''simple docstring'''

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






@require_torch
class    _lowerCAmelCase  (	a    ,  a    ,  a    ,  unittest.TestCase			):
       """simple docstring"""




       __magic_name__	:str						    =   (
           (
               XLMModel,
               XLMWithLMHeadModel,
               XLMForQuestionAnswering,
               XLMForSequenceClassification,
               XLMForQuestionAnsweringSimple,
               XLMForTokenClassification,
               XLMForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       __magic_name__	:List[Any]						    =   (
           (XLMWithLMHeadModel,) if is_torch_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       __magic_name__	: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       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase ):



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



         '''simple docstring'''

         lowerCAmelCase__     :Dict											=				super()._prepare_for_class(__UpperCAmelCase       ,					__UpperCAmelCase       ,					return_labels=__UpperCAmelCase )

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

         return inputs_dict






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :List[str]											=				XLMModelTester(self )
         lowerCAmelCase__     :Tuple											=				ConfigTester(self       ,					config_class=__UpperCAmelCase       ,					emb_dim=3_7 )






       def 	snake_case		(       self ):



         '''simple docstring'''

         self.config_tester.run_common_tests()






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :List[Any]											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Optional[int]											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Tuple											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_simple_qa(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :List[Any]											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :List[str]											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Any											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_token_classif(*__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :str											=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*__UpperCAmelCase )






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=1 ):



         '''simple docstring'''

         self.assertIsInstance(__UpperCAmelCase       ,					__UpperCAmelCase )
         self.assertListEqual(
             [isinstance(__UpperCAmelCase       ,					__UpperCAmelCase ) for iter_attentions in attentions]       ,					[True] * len(__UpperCAmelCase ) )
         self.assertEqual(len(__UpperCAmelCase )       ,					(max_length - min_length) * num_beam_groups )

         for idx, iter_attentions in enumerate(__UpperCAmelCase ):
           # adds PAD dummy token
           lowerCAmelCase__     :Tuple											=				min_length + idx + 1
           lowerCAmelCase__     :int											=				min_length + idx + 1

           lowerCAmelCase__     :Dict											=				(
               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(__UpperCAmelCase ) )






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=1 ):



         '''simple docstring'''

         self.assertIsInstance(__UpperCAmelCase       ,					__UpperCAmelCase )
         self.assertListEqual(
             [isinstance(__UpperCAmelCase       ,					__UpperCAmelCase ) for iter_hidden_states in hidden_states]       ,					[True] * len(__UpperCAmelCase )       ,					)
         self.assertEqual(len(__UpperCAmelCase )       ,					(max_length - min_length) * num_beam_groups )

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






       @slow
       def 	snake_case		(       self ):



         '''simple docstring'''

         for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase__     :List[str]											=				XLMModel.from_pretrained(__UpperCAmelCase )
           self.assertIsNotNone(__UpperCAmelCase )






@require_torch
class    _lowerCAmelCase  (	unittest.TestCase			):
       """simple docstring"""




       @slow
       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Any											=				XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048' )
         model.to(__UpperCAmelCase )
         lowerCAmelCase__     :Tuple											=				torch.tensor([[1_4, 4_4_7]]       ,					dtype=torch.long       ,					device=__UpperCAmelCase )  # the president
         lowerCAmelCase__     :Dict											=				[
             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
         lowerCAmelCase__     :Tuple											=				model.generate(__UpperCAmelCase       ,					do_sample=__UpperCAmelCase )
         self.assertListEqual(output_ids[0].cpu().numpy().tolist()       ,					__UpperCAmelCase )


from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import numpy
							import tensorflow as tf

							from transformers import (
							    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
							    BertConfig,
							    DPRConfig,
							    TFDPRContextEncoder,
							    TFDPRQuestionEncoder,
							    TFDPRReader,
							)




class   __lowercase						:






	def __init__(self				: Dict      ,	snake_case				: Dict      ,	snake_case				: List[Any]=13      ,	snake_case				: int=7      ,	snake_case				: List[str]=True      ,	snake_case				: List[Any]=True      ,	snake_case				: Union[str, Any]=True      ,	snake_case				: Dict=True      ,	snake_case				: Optional[Any]=99      ,	snake_case				: str=32      ,	snake_case				: Any=2      ,	snake_case				: Optional[Any]=4      ,	snake_case				: int=37      ,	snake_case				: Dict="gelu"      ,	snake_case				: Dict=0.1      ,	snake_case				: Dict=0.1      ,	snake_case				: Optional[int]=512      ,	snake_case				: Dict=16      ,	snake_case				: Union[str, Any]=2      ,	snake_case				: Dict=0.02      ,	snake_case				: str=3      ,	snake_case				: str=4      ,	snake_case				: Optional[Any]=None      ,	snake_case				: str=0      ,	) ->			Optional[Any]:
							_lowercase       :	int           =   parent
							_lowercase       :	Tuple           =   batch_size
							_lowercase       :	str           =   seq_length
							_lowercase       :	Optional[Any]           =   is_training
							_lowercase       :	List[Any]           =   use_input_mask
							_lowercase       :	Tuple           =   use_token_type_ids
							_lowercase       :	List[Any]           =   use_labels
							_lowercase       :	List[str]           =   vocab_size
							_lowercase       :	Dict           =   hidden_size
							_lowercase       :	str           =   num_hidden_layers
							_lowercase       :	Tuple           =   num_attention_heads
							_lowercase       :	Dict           =   intermediate_size
							_lowercase       :	List[Any]           =   hidden_act
							_lowercase       :	Optional[Any]           =   hidden_dropout_prob
							_lowercase       :	Dict           =   attention_probs_dropout_prob
							_lowercase       :	int           =   max_position_embeddings
							_lowercase       :	Tuple           =   type_vocab_size
							_lowercase       :	List[str]           =   type_sequence_label_size
							_lowercase       :	str           =   initializer_range
							_lowercase       :	Tuple           =   num_labels
							_lowercase       :	List[Any]           =   num_choices
							_lowercase       :	Dict           =   scope
							_lowercase       :	Optional[Any]           =   projection_dim






	def       _a(self				: Tuple    ) ->			List[str]:
							_lowercase       :	Optional[int]           =   ids_tensor([self.batch_size, self.seq_length]      ,	self.vocab_size    )

							_lowercase       :	Optional[int]           =   None
							if self.use_input_mask:
													# follow test_modeling_tf_ctrl.py
													_lowercase       :	List[Any]           =   random_attention_mask([self.batch_size, self.seq_length]    )

							_lowercase       :	List[Any]           =   None
							if self.use_token_type_ids:
													_lowercase       :	List[Any]           =   ids_tensor([self.batch_size, self.seq_length]      ,	self.type_vocab_size    )

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

							_lowercase       :	Union[str, Any]           =   BertConfig(
							    vocab_size=self.vocab_size      ,	hidden_size=self.hidden_size      ,	num_hidden_layers=self.num_hidden_layers      ,	num_attention_heads=self.num_attention_heads      ,	intermediate_size=self.intermediate_size      ,	hidden_act=self.hidden_act      ,	hidden_dropout_prob=self.hidden_dropout_prob      ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,	max_position_embeddings=self.max_position_embeddings      ,	type_vocab_size=self.type_vocab_size      ,	is_decoder=snake_case      ,	initializer_range=self.initializer_range      ,	)
							_lowercase       :	Any           =   DPRConfig(projection_dim=self.projection_dim      ,	**config.to_dict()    )

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






	def       _a(self				: Union[str, Any]      ,	snake_case				: Any      ,	snake_case				: Tuple      ,	snake_case				: str      ,	snake_case				: str      ,	snake_case				: Union[str, Any]      ,	snake_case				: Tuple      ,	snake_case				: str    ) ->			List[str]:
							_lowercase       :	List[Any]           =   TFDPRContextEncoder(config=snake_case    )
							_lowercase       :	Dict           =   model(snake_case      ,	attention_mask=snake_case      ,	token_type_ids=snake_case    )
							_lowercase       :	Optional[int]           =   model(snake_case      ,	token_type_ids=snake_case    )
							_lowercase       :	Union[str, Any]           =   model(snake_case    )
							self.parent.assertEqual(result.pooler_output.shape      ,	(self.batch_size, self.projection_dim or self.hidden_size)    )






	def       _a(self				: List[Any]      ,	snake_case				: List[str]      ,	snake_case				: Tuple      ,	snake_case				: Any      ,	snake_case				: int      ,	snake_case				: Optional[int]      ,	snake_case				: Any      ,	snake_case				: Union[str, Any]    ) ->			int:
							_lowercase       :	Optional[Any]           =   TFDPRQuestionEncoder(config=snake_case    )
							_lowercase       :	int           =   model(snake_case      ,	attention_mask=snake_case      ,	token_type_ids=snake_case    )
							_lowercase       :	str           =   model(snake_case      ,	token_type_ids=snake_case    )
							_lowercase       :	str           =   model(snake_case    )
							self.parent.assertEqual(result.pooler_output.shape      ,	(self.batch_size, self.projection_dim or self.hidden_size)    )






	def       _a(self				: Union[str, Any]      ,	snake_case				: Any      ,	snake_case				: int      ,	snake_case				: List[str]      ,	snake_case				: Union[str, Any]      ,	snake_case				: Tuple      ,	snake_case				: Optional[Any]      ,	snake_case				: Union[str, Any]    ) ->			Any:
							_lowercase       :	Any           =   TFDPRReader(config=snake_case    )
							_lowercase       :	Optional[Any]           =   model(snake_case      ,	attention_mask=snake_case    )

							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)    )
							self.parent.assertEqual(result.relevance_logits.shape      ,	(self.batch_size,)    )






	def       _a(self				: int    ) ->			Optional[Any]:
							_lowercase       :	Union[str, Any]           =   self.prepare_config_and_inputs()
							(
							    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    (
							    _lowercase
							)      ,    
							)       :	int           =   config_and_inputs
							_lowercase       :	int           =   {"input_ids": input_ids}
							return config, inputs_dict




@require_tf
class   __lowercase						(						__snake_case   , __snake_case   , unittest.TestCase       ):
	_A       =   (
	    (
	        TFDPRContextEncoder,
	        TFDPRQuestionEncoder,
	        TFDPRReader,
	    )
	    if is_tf_available()
	    else ()
	)
	_A       =   {"feature-extraction": TFDPRQuestionEncoder} if is_tf_available() else {}

	_A       =   False
	_A       =   False
	_A       =   False
	_A       =   False
	_A       =   False






	def       _a(self				: str    ) ->			List[str]:
							_lowercase       :	List[Any]           =   TFDPRModelTester(self    )
							_lowercase       :	Any           =   ConfigTester(self      ,	config_class=snake_case      ,	hidden_size=37    )






	def       _a(self				: str    ) ->			Union[str, Any]:
							self.config_tester.run_common_tests()






	def       _a(self				: Any    ) ->			Tuple:
							_lowercase       :	List[str]           =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_context_encoder(*snake_case    )






	def       _a(self				: Dict    ) ->			Optional[Any]:
							_lowercase       :	str           =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_question_encoder(*snake_case    )






	def       _a(self				: List[Any]    ) ->			Any:
							_lowercase       :	Optional[Any]           =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_reader(*snake_case    )






	@slow
	def       _a(self				: int    ) ->			str:
							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_lowercase       :	str           =   TFDPRContextEncoder.from_pretrained(snake_case    )
													self.assertIsNotNone(snake_case    )

							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_lowercase       :	List[str]           =   TFDPRContextEncoder.from_pretrained(snake_case    )
													self.assertIsNotNone(snake_case    )

							for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_lowercase       :	int           =   TFDPRQuestionEncoder.from_pretrained(snake_case    )
													self.assertIsNotNone(snake_case    )

							for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_lowercase       :	Any           =   TFDPRReader.from_pretrained(snake_case    )
													self.assertIsNotNone(snake_case    )




@require_tf
class   __lowercase						(						unittest.TestCase       ):






	@slow
	def       _a(self				: Dict    ) ->			Any:
							_lowercase       :	Any           =   TFDPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base"    )

							_lowercase       :	Optional[int]           =   tf.constant(
							    [[101, 7592, 1010, 2003, 2026, 3899, 1_0140, 1029, 102]]    )  # [CLS] hello, is my dog cute? [SEP]
							_lowercase       :	List[Any]           =   model(snake_case    )[0]  # embedding shape = (1, 768)
							# compare the actual values for a slice.
							_lowercase       :	Optional[Any]           =   tf.constant(
							    [
							        [
							            0.03_23_62_53,
							            0.12_75_33_35,
							            0.16_81_85_09,
							            0.00_27_97_86,
							            0.3_89_69_33,
							            0.24_26_49_45,
							            0.2_17_89_71,
							            -0.02_33_52_27,
							            -0.08_48_19_59,
							            -0.14_32_41_17,
							        ]
							    ]    )
							self.assertTrue(numpy.allclose(output[:, :10].numpy()      ,	expected_slice.numpy()      ,	atol=1e-4    )    )




