






"""simple docstring"""





import inspect
import unittest

from transformers import ConvNextConfig
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_backbone_common import BackboneTesterMixin
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 transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
				from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor


class      _lowercase :


						def __init__(    self				:	Any							,   a				:	Dict							,   a				:	int=1_3							,   a				:	Union[str, Any]=3_2							,   a				:	int=3							,   a				:	int=4							,   a				:	List[str]=[1_0, 2_0, 3_0, 4_0]							,   a				:	Optional[int]=[2, 2, 3, 2]							,   a				:	Any=True							,   a				:	Optional[int]=True							,   a				:	Dict=3_7							,   a				:	Union[str, Any]="gelu"							,   a				:	Any=1_0							,   a				:	List[str]=0.0_2							,   a				:	Any=["stage2", "stage3", "stage4"]							,   a				:	Union[str, Any]=[2, 3, 4]							,   a				:	List[str]=None							,   ):





												"""simple docstring"""







												__snake_case      :    Any  			=parent
												__snake_case      :    List[str]  			=batch_size
												__snake_case      :    Any  			=image_size
												__snake_case      :    Optional[int]  			=num_channels
												__snake_case      :    int  			=num_stages
												__snake_case      :    Tuple  			=hidden_sizes
												__snake_case      :    Any  			=depths
												__snake_case      :    Optional[int]  			=is_training
												__snake_case      :    Union[str, Any]  			=use_labels
												__snake_case      :    int  			=intermediate_size
												__snake_case      :    Optional[int]  			=hidden_act
												__snake_case      :    str  			=num_labels
												__snake_case      :    Any  			=initializer_range
												__snake_case      :    Any  			=out_features
												__snake_case      :    Optional[Any]  			=out_indices
												__snake_case      :    Dict  			=scope


						def _UpperCamelCase						(    self				:	Dict						):





												"""simple docstring"""







												__snake_case      :    List[str]  			=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

												__snake_case      :    List[Any]  			=None
												if self.use_labels:
																		__snake_case      :    int  			=ids_tensor([self.batch_size]							,   self.num_labels						)

												__snake_case      :    Optional[int]  			=self.get_config()
												return config, pixel_values, labels


						def _UpperCamelCase						(    self				:	int						):





												"""simple docstring"""







												return ConvNextConfig(
												    num_channels=self.num_channels							,   hidden_sizes=self.hidden_sizes							,   depths=self.depths							,   num_stages=self.num_stages							,   hidden_act=self.hidden_act							,   is_decoder=a							,   initializer_range=self.initializer_range							,   out_features=self.out_features							,   out_indices=self.out_indices							,   num_labels=self.num_labels							,   )


						def _UpperCamelCase						(    self				:	Dict							,   a				:	Union[str, Any]							,   a				:	List[Any]							,   a				:	Optional[Any]						):





												"""simple docstring"""







												__snake_case      :    Union[str, Any]  			=ConvNextModel(config=a						)
												model.to(a						)
												model.eval()
												__snake_case      :    List[Any]  			=model(a						)
												# expected last hidden states: B, C, H // 32, W // 32
												self.parent.assertEqual(
												    result.last_hidden_state.shape							,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)							,   )


						def _UpperCamelCase						(    self				:	List[Any]							,   a				:	List[str]							,   a				:	Optional[Any]							,   a				:	List[Any]						):





												"""simple docstring"""







												__snake_case      :    Union[str, Any]  			=ConvNextForImageClassification(a						)
												model.to(a						)
												model.eval()
												__snake_case      :    Tuple  			=model(a							,   labels=a						)
												self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)						)


						def _UpperCamelCase						(    self				:	Dict							,   a				:	Any							,   a				:	List[Any]							,   a				:	List[str]						):





												"""simple docstring"""







												__snake_case      :    Union[str, Any]  			=ConvNextBackbone(config=a						)
												model.to(a						)
												model.eval()
												__snake_case      :    str  			=model(a						)

												# verify hidden states
												self.parent.assertEqual(len(result.feature_maps						)							,   len(config.out_features						)						)
												self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,   [self.batch_size, self.hidden_sizes[1], 4, 4]						)

												# verify channels
												self.parent.assertEqual(len(model.channels						)							,   len(config.out_features						)						)
												self.parent.assertListEqual(model.channels							,   config.hidden_sizes[1:]						)

												# verify backbone works with out_features=None
												__snake_case      :    str  			=None
												__snake_case      :    List[Any]  			=ConvNextBackbone(config=a						)
												model.to(a						)
												model.eval()
												__snake_case      :    Tuple  			=model(a						)

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps						)							,   1						)
												self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,   [self.batch_size, self.hidden_sizes[-1], 1, 1]						)

												# verify channels
												self.parent.assertEqual(len(model.channels						)							,   1						)
												self.parent.assertListEqual(model.channels							,   [config.hidden_sizes[-1]]						)







						def _UpperCamelCase						(    self				:	Tuple						):





												"""simple docstring"""







												__snake_case      :    str  			=self.prepare_config_and_inputs()
												__snake_case			,				__snake_case			,				__snake_case      :    int  			=config_and_inputs
												__snake_case      :    List[str]  			={'''pixel_values''': pixel_values}
												return config, inputs_dict



@require_torch
class      _lowercase (     lowercase_		,  lowercase_		,  unittest.TestCase						):
						_a   :     Optional[Any]								=   (
						    (
						        ConvNextModel,
						        ConvNextForImageClassification,
						        ConvNextBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						_a   :     List[str]								=   (
						    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
						    if is_torch_available()
						    else {}
						)

						_a   :     Dict								=   True
						_a   :     int								=   False
						_a   :     List[str]								=   False
						_a   :     List[str]								=   False
						_a   :     Optional[int]								=   False


						def _UpperCamelCase						(    self				:	Dict						):





												"""simple docstring"""







												__snake_case      :    List[Any]  			=ConvNextModelTester(self						)
												__snake_case      :    Optional[int]  			=ConfigTester(self							,   config_class=a							,   has_text_modality=a							,   hidden_size=3_7						)


						def _UpperCamelCase						(    self				:	str						):





												"""simple docstring"""







												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()


						def _UpperCamelCase						(    self				:	Union[str, Any]						):





												"""simple docstring"""







												return


						@unittest.skip(reason='''ConvNext does not use inputs_embeds'''						)
						def _UpperCamelCase						(    self				:	Union[str, Any]						):





												"""simple docstring"""







												pass


						@unittest.skip(reason='''ConvNext does not support input and output embeddings'''						)
						def _UpperCamelCase						(    self				:	int						):





												"""simple docstring"""







												pass


						@unittest.skip(reason='''ConvNext does not use feedforward chunking'''						)
						def _UpperCamelCase						(    self				:	Optional[Any]						):





												"""simple docstring"""







												pass


						def _UpperCamelCase						(    self				:	Any						):





												"""simple docstring"""







												__snake_case			,				__snake_case      :    Dict  			=self.model_tester.prepare_config_and_inputs_for_common()

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

																		__snake_case      :    Optional[int]  			=['''pixel_values''']
																		self.assertListEqual(arg_names[:1]							,   a						)


						def _UpperCamelCase						(    self				:	Any						):





												"""simple docstring"""







												__snake_case      :    Optional[Any]  			=self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*a						)


						def _UpperCamelCase						(    self				:	Dict						):





												"""simple docstring"""







												__snake_case      :    str  			=self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*a						)


						def _UpperCamelCase						(    self				:	str						):





												"""simple docstring"""







												def check_hidden_states_output(a				:	Optional[Any]							,   a				:	Dict							,   a				:	Optional[Any]						):
																		__snake_case      :    List[Any]  			=model_class(a						)
																		model.to(a						)
																		model.eval()

																		with torch.no_grad():
																								__snake_case      :    str  			=model(**self._prepare_for_class(a							,   a						)						)

																		__snake_case      :    Any  			=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																		__snake_case      :    Tuple  			=self.model_tester.num_stages
																		self.assertEqual(len(a						)							,   expected_num_stages + 1						)

																		# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:]						)							,   [self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,   )

												__snake_case			,				__snake_case      :    List[str]  			=self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		__snake_case      :    int  			=True
																		check_hidden_states_output(a							,   a							,   a						)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		__snake_case      :    Optional[Any]  			=True

																		check_hidden_states_output(a							,   a							,   a						)


						def _UpperCamelCase						(    self				:	List[str]						):





												"""simple docstring"""







												__snake_case      :    Any  			=self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*a						)







						@slow
						def _UpperCamelCase						(    self				:	Any						):





												"""simple docstring"""







												for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		__snake_case      :    Union[str, Any]  			=ConvNextModel.from_pretrained(a						)
																		self.assertIsNotNone(a						)



def     __lowercase					(    )					->					Optional[int]:
						__snake_case      :    Union[str, Any]  			=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
						return image


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


						@cached_property
						def _UpperCamelCase						(    self				:	Dict						):





												"""simple docstring"""







												return AutoImageProcessor.from_pretrained('''facebook/convnext-tiny-224'''						) if is_vision_available() else None







						@slow
						def _UpperCamelCase						(    self				:	Any						):





												"""simple docstring"""







												__snake_case      :    str  			=ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''						).to(a						)

												__snake_case      :    List[Any]  			=self.default_image_processor
												__snake_case      :    Tuple  			=prepare_img()
												__snake_case      :    int  			=image_processor(images=a							,   return_tensors='''pt'''						).to(a						)

												# forward pass
												with torch.no_grad():
																		__snake_case      :    Optional[Any]  			=model(**a						)

												# verify the logits
												__snake_case      :    str  			=torch.Size((1, 1_0_0_0)						)
												self.assertEqual(outputs.logits.shape							,   a						)

												__snake_case      :    Optional[int]  			=torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]						).to(a						)

												self.assertTrue(torch.allclose(outputs.logits[0, :3]							,   a							,   atol=1e-4						)						)



@require_torch
class      _lowercase (     unittest.TestCase		,  lowercase_						):
						_a   :     Any								=   (ConvNextBackbone,) if is_torch_available() else ()
						_a   :     Dict								=   ConvNextConfig

						_a   :     Dict								=   False


						def _UpperCamelCase						(    self				:	Optional[Any]						):





												"""simple docstring"""







												__snake_case      :    List[str]  			=ConvNextModelTester(self						)










"""simple docstring"""





import unittest

from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
    import torch

    from transformers import (
        MraForMaskedLM,
        MraForMultipleChoice,
        MraForQuestionAnswering,
        MraForSequenceClassification,
        MraForTokenClassification,
        MraModel,
    )
    from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST


class      _lowercase :


      def __init__(    self				:	str							,   a				:	List[str]							,   a				:	Any=2							,   a				:	int=8							,   a				:	List[str]=True							,   a				:	Union[str, Any]=True							,   a				:	Union[str, Any]=True							,   a				:	Optional[int]=True							,   a				:	Union[str, Any]=9_9							,   a				:	Dict=1_6							,   a				:	Union[str, Any]=5							,   a				:	int=2							,   a				:	List[str]=3_6							,   a				:	int="gelu"							,   a				:	Optional[int]=0.0							,   a				:	Any=0.0							,   a				:	Optional[Any]=5_1_2							,   a				:	Tuple=1_6							,   a				:	Dict=2							,   a				:	Union[str, Any]=0.0_2							,   a				:	Dict=3							,   a				:	Union[str, Any]=4							,   a				:	Optional[int]=None							,   ):





            """simple docstring"""







            __snake_case      :    Any  			=parent
            __snake_case      :    int  			=batch_size
            __snake_case      :    Dict  			=seq_length
            __snake_case      :    Any  			=is_training
            __snake_case      :    Optional[int]  			=use_input_mask
            __snake_case      :    List[Any]  			=use_token_type_ids
            __snake_case      :    List[str]  			=use_labels
            __snake_case      :    Optional[Any]  			=vocab_size
            __snake_case      :    Optional[Any]  			=hidden_size
            __snake_case      :    Optional[Any]  			=num_hidden_layers
            __snake_case      :    Any  			=num_attention_heads
            __snake_case      :    Optional[int]  			=intermediate_size
            __snake_case      :    Dict  			=hidden_act
            __snake_case      :    List[str]  			=hidden_dropout_prob
            __snake_case      :    List[Any]  			=attention_probs_dropout_prob
            __snake_case      :    List[str]  			=max_position_embeddings
            __snake_case      :    Tuple  			=type_vocab_size
            __snake_case      :    Tuple  			=type_sequence_label_size
            __snake_case      :    int  			=initializer_range
            __snake_case      :    Any  			=num_labels
            __snake_case      :    List[str]  			=num_choices
            __snake_case      :    Union[str, Any]  			=scope


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







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

            __snake_case      :    int  			=None
            if self.use_input_mask:
                  __snake_case      :    Optional[int]  			=random_attention_mask([self.batch_size, self.seq_length]						)

            __snake_case      :    Optional[Any]  			=None
            if self.use_token_type_ids:
                  __snake_case      :    Optional[int]  			=ids_tensor([self.batch_size, self.seq_length]							,   self.type_vocab_size						)

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

            __snake_case      :    List[str]  			=self.get_config()

            return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            return MraConfig(
                vocab_size=self.vocab_size							,   hidden_size=self.hidden_size							,   num_hidden_layers=self.num_hidden_layers							,   num_attention_heads=self.num_attention_heads							,   intermediate_size=self.intermediate_size							,   hidden_act=self.hidden_act							,   hidden_dropout_prob=self.hidden_dropout_prob							,   attention_probs_dropout_prob=self.attention_probs_dropout_prob							,   max_position_embeddings=self.max_position_embeddings							,   type_vocab_size=self.type_vocab_size							,   is_decoder=a							,   initializer_range=self.initializer_range							,   )


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    int  			=self.get_config()
            __snake_case      :    Optional[Any]  			=3_0_0
            return config


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            (
                (
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				
            )      :    Tuple  			=self.prepare_config_and_inputs()

            __snake_case      :    Dict  			=True
            __snake_case      :    Any  			=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]						)
            __snake_case      :    Dict  			=ids_tensor([self.batch_size, self.seq_length]							,   vocab_size=2						)

            return (
                config,
                input_ids,
                token_type_ids,
                input_mask,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )


      def _UpperCamelCase						(    self				:	List[str]							,   a				:	List[Any]							,   a				:	int							,   a				:	Optional[int]							,   a				:	List[Any]							,   a				:	Tuple							,   a				:	Tuple							,   a				:	List[Any]						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=MraModel(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Union[str, Any]  			=model(a							,   attention_mask=a							,   token_type_ids=a						)
            __snake_case      :    Any  			=model(a							,   token_type_ids=a						)
            __snake_case      :    int  			=model(a						)
            self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)						)


      def _UpperCamelCase						(    self				:	str							,   a				:	Tuple							,   a				:	Any							,   a				:	int							,   a				:	Optional[int]							,   a				:	Union[str, Any]							,   a				:	int							,   a				:	Tuple							,   a				:	Optional[Any]							,   a				:	Optional[int]							,   ):





            """simple docstring"""







            __snake_case      :    Any  			=True
            __snake_case      :    Union[str, Any]  			=MraModel(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Union[str, Any]  			=model(
                a							,   attention_mask=a							,   token_type_ids=a							,   encoder_hidden_states=a							,   encoder_attention_mask=a							,   )
            __snake_case      :    List[Any]  			=model(
                a							,   attention_mask=a							,   token_type_ids=a							,   encoder_hidden_states=a							,   )
            __snake_case      :    List[str]  			=model(a							,   attention_mask=a							,   token_type_ids=a						)
            self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)						)


      def _UpperCamelCase						(    self				:	Tuple							,   a				:	Any							,   a				:	List[Any]							,   a				:	int							,   a				:	str							,   a				:	Optional[Any]							,   a				:	List[str]							,   a				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Tuple  			=MraForMaskedLM(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    str  			=model(a							,   attention_mask=a							,   token_type_ids=a							,   labels=a						)
            self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.seq_length, self.vocab_size)						)


      def _UpperCamelCase						(    self				:	List[str]							,   a				:	Optional[int]							,   a				:	int							,   a				:	List[str]							,   a				:	int							,   a				:	Any							,   a				:	Union[str, Any]							,   a				:	Union[str, Any]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=MraForQuestionAnswering(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    Dict  			=model(
                a							,   attention_mask=a							,   token_type_ids=a							,   start_positions=a							,   end_positions=a							,   )
            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				:	Dict							,   a				:	Dict							,   a				:	Dict							,   a				:	Optional[Any]							,   a				:	int							,   a				:	int							,   a				:	List[str]							,   a				:	Any						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=self.num_labels
            __snake_case      :    Optional[Any]  			=MraForSequenceClassification(a						)
            model.to(a						)
            model.eval()
            __snake_case      :    str  			=model(a							,   attention_mask=a							,   token_type_ids=a							,   labels=a						)
            self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)						)


      def _UpperCamelCase						(    self				:	Optional[int]							,   a				:	Tuple							,   a				:	Any							,   a				:	Optional[int]							,   a				:	Any							,   a				:	int							,   a				:	str							,   a				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Tuple  			=self.num_labels
            __snake_case      :    Optional[int]  			=MraForTokenClassification(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    List[str]  			=model(a							,   attention_mask=a							,   token_type_ids=a							,   labels=a						)
            self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.seq_length, self.num_labels)						)


      def _UpperCamelCase						(    self				:	str							,   a				:	Tuple							,   a				:	Tuple							,   a				:	Optional[Any]							,   a				:	Dict							,   a				:	Dict							,   a				:	Dict							,   a				:	str						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.num_choices
            __snake_case      :    Optional[int]  			=MraForMultipleChoice(config=a						)
            model.to(a						)
            model.eval()
            __snake_case      :    List[str]  			=input_ids.unsqueeze(1						).expand(-1							,   self.num_choices							,   -1						).contiguous()
            __snake_case      :    Tuple  			=token_type_ids.unsqueeze(1						).expand(-1							,   self.num_choices							,   -1						).contiguous()
            __snake_case      :    Any  			=input_mask.unsqueeze(1						).expand(-1							,   self.num_choices							,   -1						).contiguous()
            __snake_case      :    int  			=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				:	str						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.prepare_config_and_inputs()
            (
                (
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				(
                __snake_case
            )			,				
            )      :    Optional[int]  			=config_and_inputs
            __snake_case      :    Tuple  			={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
            return config, inputs_dict



@require_torch
class      _lowercase (     lowerCAmelCase		,  unittest.TestCase						):
      _a   :     Union[str, Any]								=   (
          (
              MraModel,
              MraForMaskedLM,
              MraForMultipleChoice,
              MraForQuestionAnswering,
              MraForSequenceClassification,
              MraForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      _a   :     int								=   False
      _a   :     Union[str, Any]								=   False
      _a   :     Dict								=   False
      _a   :     Dict								=   False

      _a   :     Any								=   ()


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=MraModelTester(self						)
            __snake_case      :    List[Any]  			=ConfigTester(self							,   config_class=a							,   hidden_size=3_7						)


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            self.config_tester.run_common_tests()


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Dict  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*a						)


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
                  __snake_case      :    Any  			=type
                  self.model_tester.create_and_check_model(*a						)


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*a						)


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*a						)


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*a						)


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    str  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*a						)


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*a						)


      @slow
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  __snake_case      :    Tuple  			=MraModel.from_pretrained(a						)
                  self.assertIsNotNone(a						)







      @unittest.skip(reason='''MRA does not output attentions'''						)
      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            return



@require_torch
class      _lowercase (     unittest.TestCase						):


      @slow
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    str  			=MraModel.from_pretrained('''uw-madison/mra-base-512-4'''						)
            __snake_case      :    Optional[int]  			=torch.arange(2_5_6						).unsqueeze(0						)

            with torch.no_grad():
                  __snake_case      :    List[str]  			=model(a						)[0]

            __snake_case      :    Any  			=torch.Size((1, 2_5_6, 7_6_8)						)
            self.assertEqual(output.shape							,   a						)

            __snake_case      :    int  			=torch.tensor(
                [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]]						)

            self.assertTrue(torch.allclose(output[:, :3, :3]							,   a							,   atol=1e-4						)						)


      @slow
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Any  			=MraForMaskedLM.from_pretrained('''uw-madison/mra-base-512-4'''						)
            __snake_case      :    Union[str, Any]  			=torch.arange(2_5_6						).unsqueeze(0						)

            with torch.no_grad():
                  __snake_case      :    Optional[int]  			=model(a						)[0]

            __snake_case      :    Union[str, Any]  			=5_0_2_6_5

            __snake_case      :    List[str]  			=torch.Size((1, 2_5_6, vocab_size)						)
            self.assertEqual(output.shape							,   a						)

            __snake_case      :    str  			=torch.tensor(
                [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]]						)

            self.assertTrue(torch.allclose(output[:, :3, :3]							,   a							,   atol=1e-4						)						)







      @slow
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=MraForMaskedLM.from_pretrained('''uw-madison/mra-base-4096-8-d3'''						)
            __snake_case      :    Optional[int]  			=torch.arange(4_0_9_6						).unsqueeze(0						)

            with torch.no_grad():
                  __snake_case      :    Tuple  			=model(a						)[0]

            __snake_case      :    Optional[int]  			=5_0_2_6_5

            __snake_case      :    Tuple  			=torch.Size((1, 4_0_9_6, vocab_size)						)
            self.assertEqual(output.shape							,   a						)

            __snake_case      :    List[str]  			=torch.tensor(
                [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]]						)

            self.assertTrue(torch.allclose(output[:, :3, :3]							,   a							,   atol=1e-4						)						)


