
"""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 				lowercase__:
	'''simple docstring'''

	def __init__(						self    :List[str]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :int=13		, lowerCamelCase_    :Optional[int]=7		, lowerCamelCase_    :List[Any]=True		, lowerCamelCase_    :Any=True		, lowerCamelCase_    :Union[str, Any]=True		, lowerCamelCase_    :Tuple=True		, lowerCamelCase_    :Optional[int]=True		, lowerCamelCase_    :Optional[int]=False		, lowerCamelCase_    :List[Any]=False		, lowerCamelCase_    :Optional[int]=False		, lowerCamelCase_    :List[str]=2		, lowerCamelCase_    :Any=99		, lowerCamelCase_    :Tuple=0		, lowerCamelCase_    :List[Any]=32		, lowerCamelCase_    :Tuple=5		, lowerCamelCase_    :Union[str, Any]=4		, lowerCamelCase_    :Tuple=0.1		, lowerCamelCase_    :Optional[Any]=0.1		, lowerCamelCase_    :Any=5_12		, lowerCamelCase_    :Any=2		, lowerCamelCase_    :str=0.0_2		, lowerCamelCase_    :List[Any]=2		, lowerCamelCase_    :List[str]=4		, lowerCamelCase_    :Tuple="last"		, lowerCamelCase_    :Optional[Any]=True		, lowerCamelCase_    :List[Any]=None		, lowerCamelCase_    :Any=0		, )							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= parent
			SCREAMING_SNAKE_CASE       :     Dict				= batch_size
			SCREAMING_SNAKE_CASE       :     Dict				= seq_length
			SCREAMING_SNAKE_CASE       :     Dict				= is_training
			SCREAMING_SNAKE_CASE       :     Tuple				= use_input_lengths
			SCREAMING_SNAKE_CASE       :     str				= use_token_type_ids
			SCREAMING_SNAKE_CASE       :     List[str]				= use_labels
			SCREAMING_SNAKE_CASE       :     Any				= gelu_activation
			SCREAMING_SNAKE_CASE       :     int				= sinusoidal_embeddings
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= causal
			SCREAMING_SNAKE_CASE       :     str				= asm
			SCREAMING_SNAKE_CASE       :     Dict				= n_langs
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= vocab_size
			SCREAMING_SNAKE_CASE       :     Dict				= n_special
			SCREAMING_SNAKE_CASE       :     List[str]				= hidden_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= num_hidden_layers
			SCREAMING_SNAKE_CASE       :     Dict				= num_attention_heads
			SCREAMING_SNAKE_CASE       :     List[str]				= hidden_dropout_prob
			SCREAMING_SNAKE_CASE       :     int				= attention_probs_dropout_prob
			SCREAMING_SNAKE_CASE       :     int				= max_position_embeddings
			SCREAMING_SNAKE_CASE       :     Dict				= type_sequence_label_size
			SCREAMING_SNAKE_CASE       :     Any				= initializer_range
			SCREAMING_SNAKE_CASE       :     List[str]				= num_labels
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= num_choices
			SCREAMING_SNAKE_CASE       :     Tuple				= summary_type
			SCREAMING_SNAKE_CASE       :     List[Any]				= use_proj
			SCREAMING_SNAKE_CASE       :     Dict				= scope
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= bos_token_id





	def   __lowerCAmelCase (						self    :int					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= ids_tensor([self.batch_size, self.seq_length]		, self.vocab_size					)
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= random_attention_mask([self.batch_size, self.seq_length]					)

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

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= None
			if self.use_token_type_ids:
					SCREAMING_SNAKE_CASE       :     List[Any]				= ids_tensor([self.batch_size, self.seq_length]		, self.n_langs					)

			SCREAMING_SNAKE_CASE       :     List[Any]				= None
			SCREAMING_SNAKE_CASE       :     List[str]				= None
			SCREAMING_SNAKE_CASE       :     Optional[int]				= None
			if self.use_labels:
					SCREAMING_SNAKE_CASE       :     List[Any]				= ids_tensor([self.batch_size]		, self.type_sequence_label_size					)
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= ids_tensor([self.batch_size, self.seq_length]		, self.num_labels					)
					SCREAMING_SNAKE_CASE       :     str				= ids_tensor([self.batch_size]		, 2					).float()
					SCREAMING_SNAKE_CASE       :     int				= ids_tensor([self.batch_size]		, self.num_choices					)

			SCREAMING_SNAKE_CASE       :     int				= self.get_config()

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





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			int:







			'''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   __lowerCAmelCase (						self    :Dict		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :str		, lowerCamelCase_    :Any		, lowerCamelCase_    :str		, )							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= XLMModel(config=lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()
			SCREAMING_SNAKE_CASE       :     Any				= model(lowerCamelCase_		, lengths=lowerCamelCase_		, langs=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Optional[int]				= model(lowerCamelCase_		, langs=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Tuple				= model(lowerCamelCase_					)
			self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, self.seq_length, self.hidden_size)					)





	def   __lowerCAmelCase (						self    :Tuple		, lowerCamelCase_    :Any		, lowerCamelCase_    :int		, lowerCamelCase_    :int		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :str		, lowerCamelCase_    :int		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :Any		, lowerCamelCase_    :List[str]		, )							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= XLMWithLMHeadModel(lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= model(lowerCamelCase_		, token_type_ids=lowerCamelCase_		, labels=lowerCamelCase_					)
			self.parent.assertEqual(result.loss.shape		, ()					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.vocab_size)					)





	def   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :Any		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Any		, lowerCamelCase_    :str		, lowerCamelCase_    :int		, lowerCamelCase_    :List[Any]		, )							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= XLMForQuestionAnsweringSimple(lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()

			SCREAMING_SNAKE_CASE       :     int				= model(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Optional[int]				= model(lowerCamelCase_		, start_positions=lowerCamelCase_		, end_positions=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= 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   __lowerCAmelCase (						self    :Optional[Any]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Any		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :str		, lowerCamelCase_    :Optional[int]		, )							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= XLMForQuestionAnswering(lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= model(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     str				= model(
			    lowerCamelCase_		, start_positions=lowerCamelCase_		, end_positions=lowerCamelCase_		, cls_index=lowerCamelCase_		, is_impossible=lowerCamelCase_		, p_mask=lowerCamelCase_		, )

			SCREAMING_SNAKE_CASE       :     Tuple				= model(
			    lowerCamelCase_		, start_positions=lowerCamelCase_		, end_positions=lowerCamelCase_		, cls_index=lowerCamelCase_		, is_impossible=lowerCamelCase_		, )

			((SCREAMING_SNAKE_CASE),					)       :     List[Any]				= result_with_labels.to_tuple()

			SCREAMING_SNAKE_CASE       :     Dict				= model(lowerCamelCase_		, start_positions=lowerCamelCase_		, end_positions=lowerCamelCase_					)

			((SCREAMING_SNAKE_CASE),					)       :     Optional[Any]				= 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   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :int		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :int		, lowerCamelCase_    :Any		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Any		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Union[str, Any]		, )							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= XLMForSequenceClassification(lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()

			SCREAMING_SNAKE_CASE       :     Tuple				= model(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Any				= model(lowerCamelCase_		, labels=lowerCamelCase_					)
			self.parent.assertEqual(result.loss.shape		, ()					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.type_sequence_label_size)					)





	def   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :int		, lowerCamelCase_    :Any		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Any		, lowerCamelCase_    :Tuple		, )							->			Any:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= self.num_labels
			SCREAMING_SNAKE_CASE       :     Optional[int]				= XLMForTokenClassification(lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()

			SCREAMING_SNAKE_CASE       :     List[str]				= model(lowerCamelCase_		, attention_mask=lowerCamelCase_		, labels=lowerCamelCase_					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.num_labels)					)





	def   __lowerCAmelCase (						self    :str		, lowerCamelCase_    :int		, lowerCamelCase_    :int		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Any		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Optional[Any]		, )							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= self.num_choices
			SCREAMING_SNAKE_CASE       :     List[Any]				= XLMForMultipleChoice(config=lowerCamelCase_					)
			model.to(lowerCamelCase_					)
			model.eval()
			SCREAMING_SNAKE_CASE       :     Dict				= input_ids.unsqueeze(1					).expand(-1		, self.num_choices		, -1					).contiguous()
			SCREAMING_SNAKE_CASE       :     List[Any]				= token_type_ids.unsqueeze(1					).expand(-1		, self.num_choices		, -1					).contiguous()
			SCREAMING_SNAKE_CASE       :     Tuple				= input_mask.unsqueeze(1					).expand(-1		, self.num_choices		, -1					).contiguous()
			SCREAMING_SNAKE_CASE       :     int				= model(
			    lowerCamelCase_		, attention_mask=lowerCamelCase_		, token_type_ids=lowerCamelCase_		, labels=lowerCamelCase_		, )
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.num_choices)					)







	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.prepare_config_and_inputs()
			(
			    (
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					
			)       :     List[str]				= config_and_inputs
			SCREAMING_SNAKE_CASE       :     List[Any]				= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
			return config, inputs_dict





@require_torch
class 				lowercase__(				_UpperCAmelCase		,						_UpperCAmelCase		,						_UpperCAmelCase		,						unittest.TestCase   ):
	'''simple docstring'''

	UpperCamelCase				=  (
	    (
	        XLMModel,
	        XLMWithLMHeadModel,
	        XLMForQuestionAnswering,
	        XLMForSequenceClassification,
	        XLMForQuestionAnsweringSimple,
	        XLMForTokenClassification,
	        XLMForMultipleChoice,
	    )
	    if is_torch_available()
	    else ()
	)
	UpperCamelCase				=  (
	    (XLMWithLMHeadModel,) if is_torch_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	UpperCamelCase				=  (
	    {
	        """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   __lowerCAmelCase (						self    :Optional[Any]		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :str		, lowerCamelCase_    :int		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Union[str, Any]					)							->			Tuple:







			'''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   __lowerCAmelCase (						self    :List[Any]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Any		, lowerCamelCase_    :Any=False					)							->			Any:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= super()._prepare_for_class(lowerCamelCase_		, lowerCamelCase_		, return_labels=lowerCamelCase_					)

			if return_labels:
					if model_class.__name__ == "XLMForQuestionAnswering":
							SCREAMING_SNAKE_CASE       :     int				= torch.zeros(
							    self.model_tester.batch_size		, dtype=torch.long		, device=lowerCamelCase_					)
							SCREAMING_SNAKE_CASE       :     List[str]				= torch.zeros(
							    self.model_tester.batch_size		, dtype=torch.long		, device=lowerCamelCase_					)

			return inputs_dict





	def   __lowerCAmelCase (						self    :Dict					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= XLMModelTester(self					)
			SCREAMING_SNAKE_CASE       :     Dict				= ConfigTester(self		, config_class=lowerCamelCase_		, emb_dim=37					)





	def   __lowerCAmelCase (						self    :List[Any]					)							->			Dict:







			'''simple docstring'''




			self.config_tester.run_common_tests()





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Optional[int]					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[int]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Any					)							->			Union[str, Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :str					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :List[str]					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :List[str]					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Any					)							->			Dict:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Optional[Any]		, lowerCamelCase_    :Any		, lowerCamelCase_    :Dict		, lowerCamelCase_    :int		, lowerCamelCase_    :int		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :str=False		, lowerCamelCase_    :str=1					)							->			Union[str, Any]:







			'''simple docstring'''




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

			for idx, iter_attentions in enumerate(lowerCamelCase_					):
					# adds PAD dummy token
					SCREAMING_SNAKE_CASE       :     Any				= min_length + idx + 1
					SCREAMING_SNAKE_CASE       :     Any				= min_length + idx + 1

					SCREAMING_SNAKE_CASE       :     int				= (
					    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(lowerCamelCase_					)					)





	def   __lowerCAmelCase (						self    :List[str]		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Any		, lowerCamelCase_    :int		, lowerCamelCase_    :Optional[int]=False		, lowerCamelCase_    :Dict=1					)							->			Tuple:







			'''simple docstring'''




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

			for idx, iter_hidden_states in enumerate(lowerCamelCase_					):
					# adds PAD dummy token
					SCREAMING_SNAKE_CASE       :     List[str]				= min_length + idx + 1
					SCREAMING_SNAKE_CASE       :     int				= (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(lowerCamelCase_					)		, )
			pass







	@slow
	def   __lowerCAmelCase (						self    :Optional[int]					)							->			Union[str, Any]:







			'''simple docstring'''




			for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= XLMModel.from_pretrained(lowerCamelCase_					)
					self.assertIsNotNone(lowerCamelCase_					)





@require_torch
class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	@slow
	def   __lowerCAmelCase (						self    :Dict					)							->			Dict:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= XLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''					)
			model.to(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     int				= torch.tensor([[14, 4_47]]		, dtype=torch.long		, device=lowerCamelCase_					)  # the president
			SCREAMING_SNAKE_CASE       :     int				= [
			    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
			SCREAMING_SNAKE_CASE       :     Optional[int]				= model.generate(lowerCamelCase_		, do_sample=lowerCamelCase_					)
			self.assertListEqual(output_ids[0].cpu().numpy().tolist()		, lowerCamelCase_					)







"""simple docstring"""






import math




class 				lowercase__:
	'''simple docstring'''

	def __init__(						self    :Union[str, Any]		, lowerCamelCase_    :List[str]=0					)							->			List[Any]:  # a graph with Node 0,1,...,N-1







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= n
			SCREAMING_SNAKE_CASE       :     List[Any]				= [
			    [math.inf for j in range(0		, lowerCamelCase_					)] for i in range(0		, lowerCamelCase_					)
			]  # adjacency matrix for weight
			SCREAMING_SNAKE_CASE       :     Any				= [
			    [math.inf for j in range(0		, lowerCamelCase_					)] for i in range(0		, lowerCamelCase_					)
			]  # dp[i][j] stores minimum distance from i to j





	def   __lowerCAmelCase (						self    :Dict		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Union[str, Any]					)							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= w





	def   __lowerCAmelCase (						self    :str					)							->			Union[str, Any]:







			'''simple docstring'''




			for k in range(0		, self.n					):
					for i in range(0		, self.n					):
							for j in range(0		, self.n					):
									SCREAMING_SNAKE_CASE       :     List[str]				= min(self.dp[i][j]		, self.dp[i][k] + self.dp[k][j]					)







	def   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Optional[int]					)							->			Optional[Any]:







			'''simple docstring'''




			return self.dp[u][v]


if __name__ == "__main__":
					lowerCamelCase__ :       Dict						     =			Graph(5)
					graph.add_edge(0, 2, 9)
					graph.add_edge(0, 4, 10)
					graph.add_edge(1, 3, 5)
					graph.add_edge(2, 3, 7)
					graph.add_edge(3, 0, 10)
					graph.add_edge(3, 1, 2)
					graph.add_edge(3, 2, 1)
					graph.add_edge(3, 4, 6)
					graph.add_edge(4, 1, 3)
					graph.add_edge(4, 2, 4)
					graph.add_edge(4, 3, 9)
					graph.floyd_warshall()
					graph.show_min(1, 4)
					graph.show_min(0, 3)





