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






						def __init__(	self     ,						_UpperCamelCase     ,						_UpperCamelCase=13     ,						_UpperCamelCase=7     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=False     ,						_UpperCamelCase=False     ,						_UpperCamelCase=False     ,						_UpperCamelCase=2     ,						_UpperCamelCase=99     ,						_UpperCamelCase=0     ,						_UpperCamelCase=32     ,						_UpperCamelCase=5     ,						_UpperCamelCase=4     ,						_UpperCamelCase=0.1     ,						_UpperCamelCase=0.1     ,						_UpperCamelCase=5_12     ,						_UpperCamelCase=2     ,						_UpperCamelCase=0.02     ,						_UpperCamelCase=2     ,						_UpperCamelCase=4     ,						_UpperCamelCase="last"     ,						_UpperCamelCase=True     ,						_UpperCamelCase=None     ,						_UpperCamelCase=0     ,						):






												"""simple docstring"""
												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       UpperCamelCase__      (	self   ):






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






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMModel(config=snake_case_   )
												model.to(snake_case_   )
												model.eval()
												lowerCAmelCase__    						=						model(snake_case_     ,						lengths=snake_case_     ,						langs=snake_case_   )
												lowerCAmelCase__    						=						model(snake_case_     ,						langs=snake_case_   )
												lowerCAmelCase__    						=						model(snake_case_   )
												self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size)   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMWithLMHeadModel(snake_case_   )
												model.to(snake_case_   )
												model.eval()

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






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMForQuestionAnsweringSimple(snake_case_   )
												model.to(snake_case_   )
												model.eval()

												lowerCAmelCase__    						=						model(snake_case_   )

												lowerCAmelCase__    						=						model(snake_case_     ,						start_positions=snake_case_     ,						end_positions=snake_case_   )
												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       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMForQuestionAnswering(snake_case_   )
												model.to(snake_case_   )
												model.eval()

												lowerCAmelCase__    						=						model(snake_case_   )

												lowerCAmelCase__    						=						model(
												    snake_case_     ,						start_positions=snake_case_     ,						end_positions=snake_case_     ,						cls_index=snake_case_     ,						is_impossible=snake_case_     ,						p_mask=snake_case_     ,						)

												lowerCAmelCase__    						=						model(
												    snake_case_     ,						start_positions=snake_case_     ,						end_positions=snake_case_     ,						cls_index=snake_case_     ,						is_impossible=snake_case_     ,						)

												(lowerCAmelCase__					)    						=						result_with_labels.to_tuple()

												lowerCAmelCase__    						=						model(snake_case_     ,						start_positions=snake_case_     ,						end_positions=snake_case_   )

												(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       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMForSequenceClassification(snake_case_   )
												model.to(snake_case_   )
												model.eval()

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






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.num_labels
												lowerCAmelCase__    						=						XLMForTokenClassification(snake_case_   )
												model.to(snake_case_   )
												model.eval()

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






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.num_choices
												lowerCAmelCase__    						=						XLMForMultipleChoice(config=snake_case_   )
												model.to(snake_case_   )
												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(
												    snake_case_     ,						attention_mask=snake_case_     ,						token_type_ids=snake_case_     ,						labels=snake_case_     ,						)
												self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_choices)   )







						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.prepare_config_and_inputs()
												(
												    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     __SCREAMING_SNAKE_CASE					(   _snake_case		,					_snake_case		,					_snake_case		,					unittest.TestCase):
						_SCREAMING_SNAKE_CASE	:       Dict   =					(
						    (
						        XLMModel,
						        XLMWithLMHeadModel,
						        XLMForQuestionAnswering,
						        XLMForSequenceClassification,
						        XLMForQuestionAnsweringSimple,
						        XLMForTokenClassification,
						        XLMForMultipleChoice,
						    )
						    if is_torch_available()
						    else ()
						)
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					(
						    (XLMWithLMHeadModel,) if is_torch_available() else ()
						)  # TODO (PVP): Check other models whether language generation is also applicable
						_SCREAMING_SNAKE_CASE	:       Optional[int]   =					(
						    {
						        """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     ,						_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       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase=False   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						super()._prepare_for_class(snake_case_     ,						snake_case_     ,						return_labels=snake_case_   )

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

												return inputs_dict






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMModelTester(self   )
												lowerCAmelCase__    						=						ConfigTester(self     ,						config_class=snake_case_     ,						emb_dim=37   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_model(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_lm_head(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_simple_qa(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_qa(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_token_classif(*snake_case_   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase=False     ,						_UpperCamelCase=1   ):






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

												for idx, iter_attentions in enumerate(snake_case_   ):
																		# 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(snake_case_   )   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase     ,						_UpperCamelCase=False     ,						_UpperCamelCase=1   ):






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

												for idx, iter_hidden_states in enumerate(snake_case_   ):
																		# 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(snake_case_   )     ,						)
												pass







						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						XLMModel.from_pretrained(snake_case_   )
																		self.assertIsNotNone(snake_case_   )




@require_torch
class     __SCREAMING_SNAKE_CASE					(   unittest.TestCase):






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'   )
												model.to(snake_case_   )
												lowerCAmelCase__    						=						torch.tensor([[14, 4_47]]     ,						dtype=torch.long     ,						device=snake_case_   )  # 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(snake_case_     ,						do_sample=snake_case_   )
												self.assertListEqual(output_ids[0].cpu().numpy().tolist()     ,						snake_case_   )













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


__snake_case    :    Dict         =     {"""configuration_speech_encoder_decoder""": ["""SpeechEncoderDecoderConfig"""]}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    Union[str, Any]         =     ["""SpeechEncoderDecoderModel"""]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    str         =     ["""FlaxSpeechEncoderDecoderModel"""]

if TYPE_CHECKING:
					from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
					import sys

					__snake_case    :    Tuple         =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





