


'''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       a__				:







				"""simple docstring"""



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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			):
										__lowerCAmelCase							       =				XLMWithLMHeadModel(__lowercase		)
										model.to(__lowercase		)
										model.eval()

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

										__lowerCAmelCase							       =				model(__lowercase		)

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

										__lowerCAmelCase							       =				model(__lowercase		)

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

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

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

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

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

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

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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			):
										__lowerCAmelCase							       =				self.num_choices
										__lowerCAmelCase							       =				XLMForMultipleChoice(config=__lowercase		)
										model.to(__lowercase		)
										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(
										    __lowercase       ,			attention_mask=__lowercase       ,			token_type_ids=__lowercase       ,			labels=__lowercase       ,			)
										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       a__				( __A							,						__A							,						__A							,						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       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										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       ,			__lowercase       ,			__lowercase       ,			__lowercase=False		):
										__lowerCAmelCase							       =				super()._prepare_for_class(__lowercase       ,			__lowercase       ,			return_labels=__lowercase		)

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

										return inputs_dict




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				XLMModelTester(self		)
										__lowerCAmelCase							       =				ConfigTester(self       ,			config_class=__lowercase       ,			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(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_simple_qa(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_token_classif(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowercase		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase=False       ,			__lowercase=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
																__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(__lowercase		)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase=False       ,			__lowercase=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
																__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(__lowercase		)       ,			)
										pass




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


@require_torch
class       a__				( unittest.TestCase      ):







				"""simple docstring"""



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





'''simple docstring'''

from __future__ import annotations

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				sorted(numsa + numsa)
						__lowerCAmelCase       ,					__lowerCAmelCase							       =				divmod(len(lowerCamelCase),				2)
						if mod == 1:
												return all_numbers[div]
						else:
												return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	_UpperCAmelCase				: Union[str, Any]							    =				[float(x) for x in input("""Enter the elements of first array: """).split()]
	_UpperCAmelCase				: int							    =				[float(x) for x in input("""Enter the elements of second array: """).split()]
	print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")

