


"""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    (  lowerCAmelCase__			,lowerCAmelCase__			,lowerCAmelCase__			,unittest.TestCase						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =(
							    (
							        XLMModel,
							        XLMWithLMHeadModel,
							        XLMForQuestionAnswering,
							        XLMForSequenceClassification,
							        XLMForQuestionAnsweringSimple,
							        XLMForTokenClassification,
							        XLMForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							__UpperCAmelCase		:       List[Any]							 =(
							    (XLMWithLMHeadModel,) if is_torch_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							__UpperCAmelCase		:       Union[str, 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 __future__ import annotations
class     _UpperCamelCase    :
							'''simple docstring'''







							def __init__(	self       ,  __a=None      ):
										__lowerCAmelCase							       =     data
										__lowerCAmelCase							       =     None



							def __repr__(	self      ):
										__lowerCAmelCase							       =     []
										__lowerCAmelCase							       =     self
										while temp:
													string_rep.append(f"{temp.data}"      )
													__lowerCAmelCase							       =     temp.next
										return "->".join(__a      )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			if not elements_list:
						raise Exception("The Elements List is empty" )

			__lowerCAmelCase							       =     __lowerCAmelCase							       =     Node(elements_list[0] )
			for i in range(1       ,					len(_UpperCamelCase ) ):
						__lowerCAmelCase							       =     Node(elements_list[i] )
						__lowerCAmelCase							       =     current.next
			return head


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			if head_node is not None and isinstance(_UpperCamelCase       ,					_UpperCamelCase ):
						print_reverse(head_node.next )
						print(head_node.data )


def _lowerCamelCase      (						):

			'''simple docstring'''




			from doctest import testmod

			testmod()

			__lowerCAmelCase							       =     make_linked_list([14, 52, 14, 12, 43] )
			print("Linked List:" )
			print(_UpperCamelCase )
			print("Elements in Reverse:" )
			print_reverse(_UpperCamelCase )


if __name__ == "__main__":
	main()




