



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




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




    def 							A__      (						self					:						int						):
       lowercase__					  =				ids_tensor([self.batch_size, self.seq_length],					self.vocab_size						)
       lowercase__					  =				random_attention_mask([self.batch_size, self.seq_length]						)

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

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

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

       lowercase__					  =				self.get_config()

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




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




    def 							A__      (						self					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Optional[int],					__lowercase					:						Tuple,					__lowercase					:						List[Any],					__lowercase					:						List[Any],					__lowercase					:						Any,					__lowercase					:						Dict,					__lowercase					:						Optional[Any],					__lowercase					:						Dict,					):
       lowercase__					  =				XLMWithLMHeadModel(__lowercase						)
       model.to(__lowercase						)
       model.eval()

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




    def 							A__      (						self					:						Optional[Any],					__lowercase					:						Tuple,					__lowercase					:						List[str],					__lowercase					:						str,					__lowercase					:						List[str],					__lowercase					:						Tuple,					__lowercase					:						List[str],					__lowercase					:						Any,					__lowercase					:						Union[str, Any],					__lowercase					:						int,					):
       lowercase__					  =				XLMForQuestionAnsweringSimple(__lowercase						)
       model.to(__lowercase						)
       model.eval()

       lowercase__					  =				model(__lowercase						)

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

       lowercase__					  =				model(__lowercase						)

       lowercase__					  =				model(
           __lowercase,					start_positions=__lowercase,					end_positions=__lowercase,					cls_index=__lowercase,					is_impossible=__lowercase,					p_mask=__lowercase,					)

       lowercase__					  =				model(
           __lowercase,					start_positions=__lowercase,					end_positions=__lowercase,					cls_index=__lowercase,					is_impossible=__lowercase,					)

       ((lowercase__       )  ,              )					  =				result_with_labels.to_tuple()

       lowercase__					  =				model(__lowercase,					start_positions=__lowercase,					end_positions=__lowercase						)

       ((lowercase__       )  ,              )					  =				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 							A__      (						self					:						Optional[int],					__lowercase					:						int,					__lowercase					:						Optional[Any],					__lowercase					:						Tuple,					__lowercase					:						List[Any],					__lowercase					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Dict,					__lowercase					:						Optional[int],					__lowercase					:						Any,					):
       lowercase__					  =				XLMForSequenceClassification(__lowercase						)
       model.to(__lowercase						)
       model.eval()

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




    def 							A__      (						self					:						Optional[int],					__lowercase					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Tuple,					__lowercase					:						Optional[Any],					__lowercase					:						Union[str, Any],					__lowercase					:						int,					__lowercase					:						Optional[Any],					__lowercase					:						int,					__lowercase					:						Optional[int],					):
       lowercase__					  =				self.num_labels
       lowercase__					  =				XLMForTokenClassification(__lowercase						)
       model.to(__lowercase						)
       model.eval()

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




    def 							A__      (						self					:						List[Any],					__lowercase					:						Optional[Any],					__lowercase					:						List[Any],					__lowercase					:						int,					__lowercase					:						List[Any],					__lowercase					:						List[str],					__lowercase					:						Dict,					__lowercase					:						Union[str, Any],					__lowercase					:						int,					__lowercase					:						Dict,					):
       lowercase__					  =				self.num_choices
       lowercase__					  =				XLMForMultipleChoice(config=__lowercase						)
       model.to(__lowercase						)
       model.eval()
       lowercase__					  =				input_ids.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
       lowercase__					  =				token_type_ids.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
       lowercase__					  =				input_mask.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
       lowercase__					  =				model(
           __lowercase,					attention_mask=__lowercase,					token_type_ids=__lowercase,					labels=__lowercase,					)
       self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_choices)						)




    def 							A__      (						self					:						Optional[int]						):
       lowercase__					  =				self.prepare_config_and_inputs()
       (
           (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,       (
           lowercase__       
       )  ,              
       )					  =				config_and_inputs
       lowercase__					  =				{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
       return config, inputs_dict
@require_torch
class 				_snake_case			(					lowercase__    ,	lowercase__    ,	lowercase__    ,	unittest.TestCase):
    UpperCamelCase__				:					Optional[int]     		=(
        (
            XLMModel,
            XLMWithLMHeadModel,
            XLMForQuestionAnswering,
            XLMForSequenceClassification,
            XLMForQuestionAnsweringSimple,
            XLMForTokenClassification,
            XLMForMultipleChoice,
        )
        if is_torch_available()
        else ()
    )
    UpperCamelCase__				:					Union[str, 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 							A__      (						self					:						Tuple,					__lowercase					:						str,					__lowercase					:						Optional[Any],					__lowercase					:						Any,					__lowercase					:						Optional[Any],					__lowercase					:						Tuple						):
       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 							A__      (						self					:						str,					__lowercase					:						str,					__lowercase					:						Tuple,					__lowercase					:						Optional[int]=False						):
       lowercase__					  =				super()._prepare_for_class(__lowercase,					__lowercase,					return_labels=__lowercase						)

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

       return inputs_dict




    def 							A__      (						self					:						Any						):
       lowercase__					  =				XLMModelTester(self						)
       lowercase__					  =				ConfigTester(self,					config_class=__lowercase,					emb_dim=37						)




    def 							A__      (						self					:						Tuple						):
       self.config_tester.run_common_tests()




    def 							A__      (						self					:						Union[str, Any]						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_model(*__lowercase						)




    def 							A__      (						self					:						List[str]						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_lm_head(*__lowercase						)




    def 							A__      (						self					:						Tuple						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_simple_qa(*__lowercase						)




    def 							A__      (						self					:						Any						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_qa(*__lowercase						)




    def 							A__      (						self					:						Union[str, Any]						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_sequence_classif(*__lowercase						)




    def 							A__      (						self					:						Optional[int]						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_token_classif(*__lowercase						)




    def 							A__      (						self					:						str						):
       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowercase						)




    def 							A__      (						self					:						Optional[int],					__lowercase					:						Optional[int],					__lowercase					:						List[str],					__lowercase					:						int,					__lowercase					:						str,					__lowercase					:						int,					__lowercase					:						Any=False,					__lowercase					:						Dict=1						):
       self.assertIsInstance(__lowercase,					__lowercase						)
       self.assertListEqual(
           [isinstance(__lowercase,					__lowercase						) for iter_attentions in attentions],					[True] * len(__lowercase						)						)
       self.assertEqual(len(__lowercase						),					(max_length - min_length) * num_beam_groups						)

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

          lowercase__					  =				(
              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(__lowercase						)						)




    def 							A__      (						self					:						Optional[Any],					__lowercase					:						str,					__lowercase					:						List[str],					__lowercase					:						Optional[int],					__lowercase					:						List[str],					__lowercase					:						Tuple,					__lowercase					:						Optional[int]=False,					__lowercase					:						int=1						):
       self.assertIsInstance(__lowercase,					__lowercase						)
       self.assertListEqual(
           [isinstance(__lowercase,					__lowercase						) for iter_hidden_states in hidden_states],					[True] * len(__lowercase						),					)
       self.assertEqual(len(__lowercase						),					(max_length - min_length) * num_beam_groups						)

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




    @slow
    def 							A__      (						self					:						Dict						):
       for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowercase__					  =				XLMModel.from_pretrained(__lowercase						)
          self.assertIsNotNone(__lowercase						)
@require_torch
class 				_snake_case			(					unittest.TestCase):




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









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_								=     {
    """configuration_xmod""": [
        """XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XmodConfig""",
        """XmodOnnxConfig""",
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_								=     [
							    """XMOD_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """XmodForCausalLM""",
							    """XmodForMaskedLM""",
							    """XmodForMultipleChoice""",
							    """XmodForQuestionAnswering""",
							    """XmodForSequenceClassification""",
							    """XmodForTokenClassification""",
							    """XmodModel""",
							    """XmodPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xmod import (
														    XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XmodForCausalLM,
														    XmodForMaskedLM,
														    XmodForMultipleChoice,
														    XmodForQuestionAnswering,
														    XmodForSequenceClassification,
														    XmodForTokenClassification,
														    XmodModel,
														    XmodPreTrainedModel,
														)

else:
							import sys

							lowercase_								=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




