


import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import SwiftFormerForImageClassification, SwiftFormerModel
				from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import ViTImageProcessor






class    _UpperCamelCase     :

				"""simple docstring"""







				def __init__(    self					, a__					, a__=13					, a__=3					, a__=True					, a__=True					, a__=0.1					, a__=0.1					, a__=224					, a__=1000					, a__=[3, 3, 6, 4]					, a__=[48, 56, 112, 220]					, )						->					Optional[Any]:
					A             =					parent
					A             =					batch_size
					A             =					num_channels
					A             =					is_training
					A             =					use_labels
					A             =					hidden_dropout_prob
					A             =					attention_probs_dropout_prob
					A             =					num_labels
					A             =					image_size
					A             =					layer_depths
					A             =					embed_dims

				def   _UpperCAmelCase       (    self )						->					Any:
					A             =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

					A             =					None
					if self.use_labels:
						A             =					ids_tensor([self.batch_size]					, self.num_labels )

					A             =					self.get_config()

					return config, pixel_values, labels

				def   _UpperCAmelCase       (    self )						->					List[str]:
					return SwiftFormerConfig(
					    depths=self.layer_depths					, embed_dims=self.embed_dims					, mlp_ratio=4					, downsamples=[True, True, True, True]					, hidden_act="""gelu"""					, num_labels=self.num_labels					, down_patch_size=3					, down_stride=2					, down_pad=1					, drop_rate=0.0					, drop_path_rate=0.0					, use_layer_scale=a__					, layer_scale_init_value=1e-5					, )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__ )						->					str:
					A             =					SwiftFormerModel(config=a__ )
					model.to(a__ )
					model.eval()
					A             =					model(a__ )
					self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.embed_dims[-1], 7, 7) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__ )						->					Tuple:
					A             =					self.num_labels
					A             =					SwiftFormerForImageClassification(a__ )
					model.to(a__ )
					model.eval()
					A             =					model(a__					, labels=a__ )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels) )

					A             =					SwiftFormerForImageClassification(a__ )
					model.to(a__ )
					model.eval()

					A             =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
					A             =					model(a__ )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels) )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					((A)       ,      (A)       ,      (A))             =					self.prepare_config_and_inputs()
					A             =					{"""pixel_values""": pixel_values}
					return config, inputs_dict






@require_torch
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
				lowerCAmelCase					=			(
				    {'feature-extraction': SwiftFormerModel, 'image-classification': SwiftFormerForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					SwiftFormerModelTester(self )
					A             =					ConfigTester(
					    self					, config_class=a__					, has_text_modality=a__					, hidden_size=37					, num_attention_heads=12					, num_hidden_layers=12					, )

				def   _UpperCAmelCase       (    self )						->					Dict:
					self.config_tester.run_common_tests()

				@unittest.skip(reason="""SwiftFormer does not use inputs_embeds""" )
				def   _UpperCAmelCase       (    self )						->					List[str]:
					pass

				def   _UpperCAmelCase       (    self )						->					str:
					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						A             =					model_class(a__ )
						A             =					model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(a__					, nn.Linear ) )

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						A             =					model_class(a__ )
						A             =					inspect.signature(model.forward )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						A             =					[*signature.parameters.keys()]

						A             =					["""pixel_values"""]
						self.assertListEqual(arg_names[:1]					, a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*a__ )

				def   _UpperCAmelCase       (    self )						->					Any:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*a__ )

				@slow
				def   _UpperCAmelCase       (    self )						->					List[Any]:
					for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A             =					SwiftFormerModel.from_pretrained(a__ )
						self.assertIsNotNone(a__ )

				@unittest.skip(reason="""SwiftFormer does not output attentions""" )
				def   _UpperCAmelCase       (    self )						->					Dict:
					pass

				def   _UpperCAmelCase       (    self )						->					int:
					def check_hidden_states_output(a__					, a__					, a__ ):
						A             =					model_class(a__ )
						model.to(a__ )
						model.eval()

						with torch.no_grad():
							A             =					model(**self._prepare_for_class(a__					, a__ ) )

						A             =					outputs.hidden_states

						A             =					8
						self.assertEqual(len(a__ )					, a__ )  # TODO

						# SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
						# with the width and height being successively divided by 2, after every 2 blocks
						for i in range(len(a__ ) ):
							self.assertEqual(
							    hidden_states[i].shape					, torch.Size(
							        [
							            self.model_tester.batch_size,
							            self.model_tester.embed_dims[i // 2],
							            (self.model_tester.image_size // 4) // 2 ** (i // 2),
							            (self.model_tester.image_size // 4) // 2 ** (i // 2),
							        ] )					, )

					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						A             =					True
						check_hidden_states_output(a__					, a__					, a__ )

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						A             =					True

						check_hidden_states_output(a__					, a__					, a__ )

				def   _UpperCAmelCase       (    self )						->					List[str]:
					def _config_zero_init(a__ ):
						A             =					copy.deepcopy(a__ )
						for key in configs_no_init.__dict__.keys():
							if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
								setattr(a__					, a__					, 1e-10 )
							if isinstance(getattr(a__					, a__					, a__ )					, a__ ):
								A             =					_config_zero_init(getattr(a__					, a__ ) )
								setattr(a__					, a__					, a__ )
						return configs_no_init

					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					A             =					_config_zero_init(a__ )
					for model_class in self.all_model_classes:
						A             =					model_class(config=a__ )
						for name, param in model.named_parameters():
							if param.requires_grad:
								self.assertIn(
								    ((param.data.mean() * 1e9) / 1e9).round().item()					, [0.0, 1.0]					, msg=f'Parameter {name} of model {model_class} seems not properly initialized'					, )

				@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
				def   _UpperCAmelCase       (    self )						->					int:
					pass





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





	"""simple docstring"""







	A             =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
	return image






@require_torch
@require_vision
class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				@cached_property
				def   _UpperCAmelCase       (    self )						->					int:
					return ViTImageProcessor.from_pretrained("""MBZUAI/swiftformer-xs""" ) if is_vision_available() else None

				@slow
				def   _UpperCAmelCase       (    self )						->					str:
					A             =					SwiftFormerForImageClassification.from_pretrained("""MBZUAI/swiftformer-xs""" ).to(a__ )

					A             =					self.default_image_processor
					A             =					prepare_img()
					A             =					image_processor(images=a__					, return_tensors="""pt""" ).to(a__ )

					# forward pass
					with torch.no_grad():
						A             =					model(**a__ )

					# verify the logits
					A             =					torch.Size((1, 1000) )
					self.assertEqual(outputs.logits.shape					, a__ )

					A             =					torch.tensor([[-2.1_703e00, 2.1_107e00, -2.0_811e00]] ).to(a__ )
					self.assertTrue(torch.allclose(outputs.logits[0, :3]					, a__					, atol=1e-4 ) )







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__=512					, a__=2					, a__=0.02					, a__=2					, a__=4					, a__="last"					, a__=True					, a__=None					, a__=0					, )						->					Any:
					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 )						->					Optional[int]:
					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 )						->					int:
					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__					, )						->					str:
					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__					, )						->					str:
					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__					, )						->					Any:
					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__					, )						->					Optional[Any]:
					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__					, )						->					Optional[Any]:
					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__					, )						->					List[str]:
					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__					, )						->					Dict:
					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 )						->					Optional[int]:
					A             =					self.prepare_config_and_inputs()
					(
					    (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    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    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(
				    (
				        XLMModel,
				        XLMWithLMHeadModel,
				        XLMForQuestionAnswering,
				        XLMForSequenceClassification,
				        XLMForQuestionAnsweringSimple,
				        XLMForTokenClassification,
				        XLMForMultipleChoice,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCAmelCase					=			(
				    (XLMWithLMHeadModel,) if is_torch_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				lowerCAmelCase					=			(
				    {
				        '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__ )						->					Union[str, Any]:
					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 )						->					Optional[Any]:
					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 )						->					Union[str, Any]:
					A             =					XLMModelTester(self )
					A             =					ConfigTester(self					, config_class=a__					, emb_dim=37 )

				def   _UpperCAmelCase       (    self )						->					str:
					self.config_tester.run_common_tests()

				def   _UpperCAmelCase       (    self )						->					Any:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_model(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_lm_head(*a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_simple_qa(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_qa(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_sequence_classif(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_token_classif(*a__ )

				def   _UpperCAmelCase       (    self )						->					Tuple:
					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 )						->					List[str]:
					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 )						->					List[Any]:
					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 )						->					Any:
					for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A             =					XLMModel.from_pretrained(a__ )
						self.assertIsNotNone(a__ )






@require_torch
class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				@slow
				def   _UpperCAmelCase       (    self )						->					List[Any]:
					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__ )



