






"""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       snake_case_       :



	"""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=512  ,					__a=2  ,					__a=0.02  ,					__a=2  ,					__a=4  ,					__a="last"  ,					__a=True  ,					__a=None  ,					__a=0  ,					):


					"""simple docstring"""

					A__							 =       parent
					A__							 =       batch_size
					A__							 =       seq_length
					A__							 =       is_training
					A__							 =       use_input_lengths
					A__							 =       use_token_type_ids
					A__							 =       use_labels
					A__							 =       gelu_activation
					A__							 =       sinusoidal_embeddings
					A__							 =       causal
					A__							 =       asm
					A__							 =       n_langs
					A__							 =       vocab_size
					A__							 =       n_special
					A__							 =       hidden_size
					A__							 =       num_hidden_layers
					A__							 =       num_attention_heads
					A__							 =       hidden_dropout_prob
					A__							 =       attention_probs_dropout_prob
					A__							 =       max_position_embeddings
					A__							 =       type_sequence_label_size
					A__							 =       initializer_range
					A__							 =       num_labels
					A__							 =       num_choices
					A__							 =       summary_type
					A__							 =       use_proj
					A__							 =       scope
					A__							 =       bos_token_id


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       ids_tensor([self.batch_size, self.seq_length]  ,					self.vocab_size						)
					A__							 =       random_attention_mask([self.batch_size, self.seq_length]						)

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

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

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

					A__							 =       self.get_config()

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


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					return XLMConfig(
					    vocab_size=self.vocab_size  ,					n_special=self.n_special  ,					emb_dim=self.hidden_size  ,					n_layers=self.num_hidden_layers  ,					n_heads=self.num_attention_heads  ,					dropout=self.hidden_dropout_prob  ,					attention_dropout=self.attention_probs_dropout_prob  ,					gelu_activation=self.gelu_activation  ,					sinusoidal_embeddings=self.sinusoidal_embeddings  ,					asm=self.asm  ,					causal=self.causal  ,					n_langs=self.n_langs  ,					max_position_embeddings=self.max_position_embeddings  ,					initializer_range=self.initializer_range  ,					summary_type=self.summary_type  ,					use_proj=self.use_proj  ,					num_labels=self.num_labels  ,					bos_token_id=self.bos_token_id  ,					)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       XLMModel(config=a_						)
					model.to(a_						)
					model.eval()
					A__							 =       model(a_  ,					lengths=a_  ,					langs=a_						)
					A__							 =       model(a_  ,					langs=a_						)
					A__							 =       model(a_						)
					self.parent.assertEqual(result.last_hidden_state.shape  ,					(self.batch_size, self.seq_length, self.hidden_size)						)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       XLMWithLMHeadModel(a_						)
					model.to(a_						)
					model.eval()

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


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       XLMForQuestionAnsweringSimple(a_						)
					model.to(a_						)
					model.eval()

					A__							 =       model(a_						)

					A__							 =       model(a_  ,					start_positions=a_  ,					end_positions=a_						)
					A__							 =       outputs
					self.parent.assertEqual(result.start_logits.shape  ,					(self.batch_size, self.seq_length)						)
					self.parent.assertEqual(result.end_logits.shape  ,					(self.batch_size, self.seq_length)						)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       XLMForQuestionAnswering(a_						)
					model.to(a_						)
					model.eval()

					A__							 =       model(a_						)

					A__							 =       model(
					    a_  ,					start_positions=a_  ,					end_positions=a_  ,					cls_index=a_  ,					is_impossible=a_  ,					p_mask=a_  ,					)

					A__							 =       model(
					    a_  ,					start_positions=a_  ,					end_positions=a_  ,					cls_index=a_  ,					is_impossible=a_  ,					)

					(A__)							 =       result_with_labels.to_tuple()

					A__							 =       model(a_  ,					start_positions=a_  ,					end_positions=a_						)

					(A__)							 =       result_with_labels.to_tuple()

					self.parent.assertEqual(result_with_labels.loss.shape  ,					()						)
					self.parent.assertEqual(result.start_top_log_probs.shape  ,					(self.batch_size, model.config.start_n_top)						)
					self.parent.assertEqual(result.start_top_index.shape  ,					(self.batch_size, model.config.start_n_top)						)
					self.parent.assertEqual(
					    result.end_top_log_probs.shape  ,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
					self.parent.assertEqual(
					    result.end_top_index.shape  ,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
					self.parent.assertEqual(result.cls_logits.shape  ,					(self.batch_size,)						)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       XLMForSequenceClassification(a_						)
					model.to(a_						)
					model.eval()

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


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       self.num_labels
					A__							 =       XLMForTokenClassification(a_						)
					model.to(a_						)
					model.eval()

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


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					):


					"""simple docstring"""

					A__							 =       self.num_choices
					A__							 =       XLMForMultipleChoice(config=a_						)
					model.to(a_						)
					model.eval()
					A__							 =       input_ids.unsqueeze(1						).expand(-1  ,					self.num_choices  ,					-1						).contiguous()
					A__							 =       token_type_ids.unsqueeze(1						).expand(-1  ,					self.num_choices  ,					-1						).contiguous()
					A__							 =       input_mask.unsqueeze(1						).expand(-1  ,					self.num_choices  ,					-1						).contiguous()
					A__							 =       model(
					    a_  ,					attention_mask=a_  ,					token_type_ids=a_  ,					labels=a_  ,					)
					self.parent.assertEqual(result.logits.shape  ,					(self.batch_size, self.num_choices)						)






	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.prepare_config_and_inputs()
					(
					    A__
					)							 =       config_and_inputs
					A__							 =       {"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
					return config, inputs_dict





@require_torch
class       snake_case_       (    __lowerCamelCase    ,							__lowerCamelCase    ,							__lowerCamelCase    ,							unittest.TestCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							List[str]   			=					(
	    (
	        XLMModel,
	        XLMWithLMHeadModel,
	        XLMForQuestionAnswering,
	        XLMForSequenceClassification,
	        XLMForQuestionAnsweringSimple,
	        XLMForTokenClassification,
	        XLMForMultipleChoice,
	    )
	    if is_torch_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					(
	    (XLMWithLMHeadModel,) if is_torch_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	SCREAMING_SNAKE_CASE_:							List[str]   			=					(
	    {
	        '''feature-extraction''': XLMModel,
	        '''fill-mask''': XLMWithLMHeadModel,
	        '''question-answering''': XLMForQuestionAnsweringSimple,
	        '''text-classification''': XLMForSequenceClassification,
	        '''text-generation''': XLMWithLMHeadModel,
	        '''token-classification''': XLMForTokenClassification,
	        '''zero-shot''': XLMForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a						):


					"""simple docstring"""

					if (
					    pipeline_test_casse_name == "QAPipelineTests"
					    and tokenizer_name is not None
					    and not tokenizer_name.endswith('Fast'						)
					):
									# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
									# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
									# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
									return True

					return False


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a=False						):


					"""simple docstring"""

					A__							 =       super()._prepare_for_class(a_  ,					a_  ,					return_labels=a_						)

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

					return inputs_dict


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       XLMModelTester(self						)
					A__							 =       ConfigTester(self  ,					config_class=a_  ,					emb_dim=37						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					self.config_tester.run_common_tests()


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_model(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_lm_head(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_simple_qa(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_qa(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_sequence_classif(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_token_classif(*a_						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_for_multiple_choice(*a_						)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a=False  ,					__a=1						):


					"""simple docstring"""

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

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

									A__							 =       (
									    batch_size * num_beam_groups,
									    config.num_attention_heads,
									    tgt_len,
									    src_len,
									)
									# check attn size
									self.assertListEqual(
									    [layer_attention.shape for layer_attention in iter_attentions]  ,					[expected_shape] * len(a_						)						)


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a  ,					__a=False  ,					__a=1						):


					"""simple docstring"""

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

					for idx, iter_hidden_states in enumerate(a_						):
									# adds PAD dummy token
									A__							 =       min_length + idx + 1
									A__							 =       (batch_size * num_beam_groups, seq_len, config.hidden_size)
									# check hidden size
									self.assertListEqual(
									    [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]  ,					[expected_shape] * len(a_						)  ,					)
					pass






	@slow
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									A__							 =       XLMModel.from_pretrained(a_						)
									self.assertIsNotNone(a_						)





@require_torch
class       snake_case_       (    unittest.TestCase       ):



	"""simple docstring"""

	@slow
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'						)
					model.to(a_						)
					A__							 =       torch.tensor([[14, 447]]  ,					dtype=torch.long  ,					device=a_						)  # the president
					A__							 =       [
					    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
					A__							 =       model.generate(a_  ,					do_sample=a_						)
					self.assertListEqual(output_ids[0].cpu().numpy().tolist()  ,					a_						)










"""simple docstring"""






from math import ceil



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__				):
				A__							 =       list(range(0       ,lowerCAmelCase__				)				)

				A__							 =       [item for sublist in list(device_map.values()				) for item in sublist]

				# Duplicate check
				A__							 =       []
				for i in device_map_blocks:
								if device_map_blocks.count(lowerCAmelCase__				) > 1 and i not in duplicate_blocks:
												duplicate_blocks.append(lowerCAmelCase__				)
    # Missing blocks
				A__							 =       [i for i in blocks if i not in device_map_blocks]
				A__							 =       [i for i in device_map_blocks if i not in blocks]

				if len(lowerCAmelCase__				) != 0:
								raise ValueError(
								    'Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'
								    ' These attention blocks were specified more than once: ' + str(lowerCAmelCase__				)				)
				if len(lowerCAmelCase__				) != 0:
								raise ValueError(
								    'There are attention blocks for this model that are not specified in the device_map. Add these attention '
								    'blocks to a device on the device_map: ' + str(lowerCAmelCase__				)				)
				if len(lowerCAmelCase__				) != 0:
								raise ValueError(
								    'The device_map contains more attention blocks than this model has. Remove these from the device_map:'
								    + str(lowerCAmelCase__				)				)







def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__				):
				A__							 =       list(range(lowerCAmelCase__				)				)
				A__							 =       int(ceil(n_layers / len(lowerCAmelCase__				)				)				)
				A__							 =       [layers[i : i + n_blocks] for i in range(0       ,lowerCAmelCase__       ,lowerCAmelCase__				)]

				return dict(zip(lowerCAmelCase__       ,lowerCAmelCase__				)				)


