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




							def __init__(       self     ,A__     ,A__=1_3     ,A__=7     ,A__=True     ,A__=True     ,A__=True     ,A__=True     ,A__=True     ,A__=False     ,A__=False     ,A__=False     ,A__=2     ,A__=9_9     ,A__=0     ,A__=3_2     ,A__=5     ,A__=4     ,A__=0.1     ,A__=0.1     ,A__=5_1_2     ,A__=2     ,A__=0.02     ,A__=2     ,A__=4     ,A__="last"     ,A__=True     ,A__=None     ,A__=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):
												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):
												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     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,):
												lowercase					=		XLMModel(config=A__)
												model.to(A__)
												model.eval()
												lowercase					=		model(A__     ,lengths=A__     ,langs=A__)
												lowercase					=		model(A__     ,langs=A__)
												lowercase					=		model(A__)
												self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size))




							def 				A__   (       self     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,):
												lowercase					=		XLMWithLMHeadModel(A__)
												model.to(A__)
												model.eval()

												lowercase					=		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 				A__   (       self     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,):
												lowercase					=		XLMForQuestionAnsweringSimple(A__)
												model.to(A__)
												model.eval()

												lowercase					=		model(A__)

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

												lowercase					=		model(A__)

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

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

												((lowercase)			,		)					=		result_with_labels.to_tuple()

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

												((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     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,A__     ,):
												lowercase					=		XLMForSequenceClassification(A__)
												model.to(A__)
												model.eval()

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

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




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





							def 				A__   (       self):
												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        lowercase	(      SCREAMING_SNAKE_CASE__ ,						SCREAMING_SNAKE_CASE__ ,						SCREAMING_SNAKE_CASE__ ,						unittest.TestCase	):
							lowercase_ : Any       =(
							    (
							        XLMModel,
							        XLMWithLMHeadModel,
							        XLMForQuestionAnswering,
							        XLMForSequenceClassification,
							        XLMForQuestionAnsweringSimple,
							        XLMForTokenClassification,
							        XLMForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase_ : Optional[int]       =(
							    (XLMWithLMHeadModel,) if is_torch_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							lowercase_ : Dict       =(
							    {
							        '''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     ,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 				A__   (       self     ,A__     ,A__     ,A__=False):
												lowercase					=		super()._prepare_for_class(A__     ,A__     ,return_labels=A__)

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

												return inputs_dict




							def 				A__   (       self):
												lowercase					=		XLMModelTester(self)
												lowercase					=		ConfigTester(self     ,config_class=A__     ,emb_dim=3_7)




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




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_model(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_lm_head(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_simple_qa(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_qa(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_sequence_classif(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_token_classif(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_xlm_for_multiple_choice(*A__)




							def 				A__   (       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
																	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(A__))




							def 				A__   (       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
																	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(A__)     ,)
												pass





							@slow
							def 				A__   (       self):
												for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase					=		XLMModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)







@require_torch
class        lowercase	(      unittest.TestCase	):




							@slow
							def 				A__   (       self):
												lowercase					=		XLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048''')
												model.to(A__)
												lowercase					=		torch.tensor([[1_4, 4_4_7]]     ,dtype=torch.long     ,device=A__)  # the president
												lowercase					=		[
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												    1_4,
												    4_4_7,
												]  # 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(A__     ,do_sample=A__)
												self.assertListEqual(output_ids[0].cpu().numpy().tolist()     ,A__)






def  UpperCamelCase					(							lowerCAmelCase__ = 1000	):
					'''simple docstring'''
					lowercase					=		-1
					lowercase					=		0
					for a in range(1				,    n // 3	):
										# Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c
										lowercase					=		(n * n - 2 * a * n) // (2 * n - 2 * a)
										lowercase					=		n - a - b
										if c * c == (a * a + b * b):
															lowercase					=		a * b * c
															if candidate >= product:
																				lowercase					=		candidate
					return product


if __name__ == "__main__":
							print(F'{solution() = }')




