


"""simple docstring"""


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    XLMForMultipleChoice,
	    XLMForQuestionAnswering,
	    XLMForQuestionAnsweringSimple,
	    XLMForSequenceClassification,
	    XLMForTokenClassification,
	    XLMModel,
	    XLMWithLMHeadModel,
	)
	from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST



class 						_UpperCamelCase						:
							'''simple docstring'''







							def __init__(  self					,     __a					,     __a=13					,     __a=7					,     __a=True					,     __a=True					,     __a=True					,     __a=True					,     __a=True					,     __a=False					,     __a=False					,     __a=False					,     __a=2					,     __a=99					,     __a=0					,     __a=32					,     __a=5					,     __a=4					,     __a=0.1					,     __a=0.1					,     __a=5_12					,     __a=2					,     __a=0.0_2					,     __a=2					,     __a=4					,     __a="last"					,     __a=True					,     __a=None					,     __a=0					,     ):
										__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			):
										__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			):
										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					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    XLMModel(config=A_			)
										model.to(A_			)
										model.eval()
										__lowerCAmelCase       					=    model(A_					,     lengths=A_					,     langs=A_			)
										__lowerCAmelCase       					=    model(A_					,     langs=A_			)
										__lowerCAmelCase       					=    model(A_			)
										self.parent.assertEqual(result.last_hidden_state.shape					,     (self.batch_size, self.seq_length, self.hidden_size)			)

							def     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    XLMWithLMHeadModel(A_			)
										model.to(A_			)
										model.eval()

										__lowerCAmelCase       					=    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     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    XLMForQuestionAnsweringSimple(A_			)
										model.to(A_			)
										model.eval()

										__lowerCAmelCase       					=    model(A_			)

										__lowerCAmelCase       					=    model(A_					,     start_positions=A_					,     end_positions=A_			)
										__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					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    XLMForQuestionAnswering(A_			)
										model.to(A_			)
										model.eval()

										__lowerCAmelCase       					=    model(A_			)

										__lowerCAmelCase       					=    model(
										    A_					,     start_positions=A_					,     end_positions=A_					,     cls_index=A_					,     is_impossible=A_					,     p_mask=A_					,     )

										__lowerCAmelCase       					=    model(
										    A_					,     start_positions=A_					,     end_positions=A_					,     cls_index=A_					,     is_impossible=A_					,     )

										((__lowerCAmelCase      )					,			      )       					=    result_with_labels.to_tuple()

										__lowerCAmelCase       					=    model(A_					,     start_positions=A_					,     end_positions=A_			)

										((__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					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    XLMForSequenceClassification(A_			)
										model.to(A_			)
										model.eval()

										__lowerCAmelCase       					=    model(A_			)
										__lowerCAmelCase       					=    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     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    self.num_labels
										__lowerCAmelCase       					=    XLMForTokenClassification(A_			)
										model.to(A_			)
										model.eval()

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

							def     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a					,     ):
										__lowerCAmelCase       					=    self.num_choices
										__lowerCAmelCase       					=    XLMForMultipleChoice(config=A_			)
										model.to(A_			)
										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(
										    A_					,     attention_mask=A_					,     token_type_ids=A_					,     labels=A_					,     )
										self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_choices)			)



							def     snake_case       (  self			):
										__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 						_UpperCamelCase						(     _lowercase ,_lowercase ,_lowercase ,unittest.TestCase	):
							'''simple docstring'''







							__UpperCAmelCase		:					Dict          =(
							    (
							        XLMModel,
							        XLMWithLMHeadModel,
							        XLMForQuestionAnswering,
							        XLMForSequenceClassification,
							        XLMForQuestionAnsweringSimple,
							        XLMForTokenClassification,
							        XLMForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							__UpperCAmelCase		:					Dict          =(
							    (XLMWithLMHeadModel,) if is_torch_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							__UpperCAmelCase		:					Optional[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					,     __a					,     __a					,     __a					,     __a					,     __a			):
										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					,     __a					,     __a					,     __a=False			):
										__lowerCAmelCase       					=    super()._prepare_for_class(A_					,     A_					,     return_labels=A_			)

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

										return inputs_dict

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    XLMModelTester(self			)
										__lowerCAmelCase       					=    ConfigTester(self					,     config_class=A_					,     emb_dim=37			)

							def     snake_case       (  self			):
										self.config_tester.run_common_tests()

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_simple_qa(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_token_classif(*A_			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*A_			)

							def     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a=False					,     __a=1			):
										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
													__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(A_			)			)

							def     snake_case       (  self					,     __a					,     __a					,     __a					,     __a					,     __a					,     __a=False					,     __a=1			):
										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
													__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(A_			)					,     )
										pass



							@slow
							def     snake_case       (  self			):
										for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowerCAmelCase       					=    XLMModel.from_pretrained(A_			)
													self.assertIsNotNone(A_			)



@require_torch
class 						_UpperCamelCase						(     unittest.TestCase	):
							'''simple docstring'''







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








"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A  :     Union[str, Any]    					=    {
    "configuration_x_clip": [
        "XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "XCLIPConfig",
        "XCLIPTextConfig",
        "XCLIPVisionConfig",
    ],
    "processing_x_clip": ["XCLIPProcessor"],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A  :     Optional[int]    					=    [
	    "XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "XCLIPModel",
	    "XCLIPPreTrainedModel",
	    "XCLIPTextModel",
	    "XCLIPVisionModel",
	]

if TYPE_CHECKING:
	from .configuration_x_clip import (
	    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    XCLIPConfig,
	    XCLIPTextConfig,
	    XCLIPVisionConfig,
	)
	from .processing_x_clip import XCLIPProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_x_clip import (
		    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XCLIPModel,
		    XCLIPPreTrainedModel,
		    XCLIPTextModel,
		    XCLIPVisionModel,
		)

else:
	import sys

	A  :     Union[str, Any]    					=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




