





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


     def __init__(    self				,     snake_case_				,     snake_case_=2				,     snake_case_=8				,     snake_case_=True				,     snake_case_=True				,     snake_case_=True				,     snake_case_=True				,     snake_case_=99				,     snake_case_=16				,     snake_case_=5				,     snake_case_=2				,     snake_case_=36				,     snake_case_="gelu"				,     snake_case_=0.0				,     snake_case_=0.0				,     snake_case_=512				,     snake_case_=16				,     snake_case_=2				,     snake_case_=0.02				,     snake_case_=3				,     snake_case_=4				,     snake_case_=None				,     ):
         _A     =							parent
         _A     =							batch_size
         _A     =							seq_length
         _A     =							is_training
         _A     =							use_input_mask
         _A     =							use_token_type_ids
         _A     =							use_labels
         _A     =							vocab_size
         _A     =							hidden_size
         _A     =							num_hidden_layers
         _A     =							num_attention_heads
         _A     =							intermediate_size
         _A     =							hidden_act
         _A     =							hidden_dropout_prob
         _A     =							attention_probs_dropout_prob
         _A     =							max_position_embeddings
         _A     =							type_vocab_size
         _A     =							type_sequence_label_size
         _A     =							initializer_range
         _A     =							num_labels
         _A     =							num_choices
         _A     =							scope




     def        lowerCAmelCase__		(    self							):
         _A     =							ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size							)

         _A     =							None
         if self.use_input_mask:
             _A     =							random_attention_mask([self.batch_size, self.seq_length]							)

         _A     =							None
         if self.use_token_type_ids:
             _A     =							ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size							)

         _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]				,     self.num_choices							)

         _A     =							self.get_config()

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




     def        lowerCAmelCase__		(    self							):
         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=snake_case_				,     initializer_range=self.initializer_range				,     )




     def        lowerCAmelCase__		(    self							):
         _A     =							self.get_config()
         _A     =							300
         return config




     def        lowerCAmelCase__		(    self							):
         (
             (
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			
         )     =							self.prepare_config_and_inputs()

         _A     =							True
         _A     =							floats_tensor([self.batch_size, self.seq_length, self.hidden_size]							)
         _A     =							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        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							MraModel(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_							)
         _A     =							model(snake_case_				,     token_type_ids=snake_case_							)
         _A     =							model(snake_case_							)
         self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     ):
         _A     =							True
         _A     =							MraModel(snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(
             snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     encoder_hidden_states=snake_case_				,     encoder_attention_mask=snake_case_				,     )
         _A     =							model(
             snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     encoder_hidden_states=snake_case_				,     )
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_							)
         self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							MraForMaskedLM(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							MraForQuestionAnswering(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(
             snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     start_positions=snake_case_				,     end_positions=snake_case_				,     )
         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				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							self.num_labels
         _A     =							MraForSequenceClassification(snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							self.num_labels
         _A     =							MraForTokenClassification(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)							)




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




     def        lowerCAmelCase__		(    self							):
         _A     =							self.prepare_config_and_inputs()
         (
             (
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			
         )     =							config_and_inputs
         _A     =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict







@require_torch
class      lowerCamelCase(						__snake_case			, unittest.TestCase	):
     '''simple docstring'''


     __magic_name__   =			(
         (
             MraModel,
             MraForMaskedLM,
             MraForMultipleChoice,
             MraForQuestionAnswering,
             MraForSequenceClassification,
             MraForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__   =			False
     __magic_name__   =			False
     __magic_name__   =			False
     __magic_name__   =			False

     __magic_name__   =			()




     def        lowerCAmelCase__		(    self							):
         _A     =							MraModelTester(self							)
         _A     =							ConfigTester(self				,     config_class=snake_case_				,     hidden_size=37							)




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




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             _A     =							type
             self.model_tester.create_and_check_model(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*snake_case_							)




     @slow
     def        lowerCAmelCase__		(    self							):
         for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A     =							MraModel.from_pretrained(snake_case_							)
             self.assertIsNotNone(snake_case_							)




     @unittest.skip(reason='MRA does not output attentions'							)
     def        lowerCAmelCase__		(    self							):
         return







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


     @slow
     def        lowerCAmelCase__		(    self							):
         _A     =							MraModel.from_pretrained('uw-madison/mra-base-512-4'							)
         _A     =							torch.arange(256							).unsqueeze(0							)

         with torch.no_grad():
             _A     =							model(snake_case_							)[0]

         _A     =							torch.Size((1, 256, 768)							)
         self.assertEqual(output.shape				,     snake_case_							)

         _A     =							torch.tensor(
             [[[-0.0140, 0.0830, -0.0381], [0.1546, 0.1402, 0.0220], [0.1162, 0.0851, 0.0165]]]							)

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




     @slow
     def        lowerCAmelCase__		(    self							):
         _A     =							MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4'							)
         _A     =							torch.arange(256							).unsqueeze(0							)

         with torch.no_grad():
             _A     =							model(snake_case_							)[0]

         _A     =							5_0265

         _A     =							torch.Size((1, 256, vocab_size)							)
         self.assertEqual(output.shape				,     snake_case_							)

         _A     =							torch.tensor(
             [[[9.2595, -3.6038, 11.8819], [9.3869, -3.2693, 11.0956], [11.8524, -3.4938, 13.1210]]]							)

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




     @slow
     def        lowerCAmelCase__		(    self							):
         _A     =							MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3'							)
         _A     =							torch.arange(4096							).unsqueeze(0							)

         with torch.no_grad():
             _A     =							model(snake_case_							)[0]

         _A     =							5_0265

         _A     =							torch.Size((1, 4096, vocab_size)							)
         self.assertEqual(output.shape				,     snake_case_							)

         _A     =							torch.tensor(
             [[[5.4789, -2.3564, 7.5064], [7.9067, -1.3369, 9.9668], [9.0712, -1.8106, 7.0380]]]							)

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












from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer




@dataclass
class 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       42




class 	UpperCamelCase_							(  UpperCamelCase__					,	UpperCamelCase__     ):


							@register_to_config
							def __init__(				self     :Union[str, Any]				,					__A     :int = 3				,					__A     :int = 3				,					__A     :Tuple[str] = ("DownEncoderBlock2D",)				,					__A     :Tuple[str] = ("UpDecoderBlock2D",)				,					__A     :Tuple[int] = (64,)				,					__A     :int = 1				,					__A     :str = "silu"				,					__A     :int = 3				,					__A     :int = 32				,					__A     :int = 256				,					__A     :int = 32				,					__A     :Optional[int] = None				,					__A     :float = 0.1_8_2_1_5				,					__A     :str = "group"				,					) -> Any:



									"""simple docstring"""



									super().__init__()

									# pass init params to Encoder
									SCREAMING_SNAKE_CASE__								=   Encoder(
									    in_channels=__A				,					out_channels=__A				,					down_block_types=__A				,					block_out_channels=__A				,					layers_per_block=__A				,					act_fn=__A				,					norm_num_groups=__A				,					double_z=__A				,					)

									SCREAMING_SNAKE_CASE__								=   vq_embed_dim if vq_embed_dim is not None else latent_channels

									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)
									SCREAMING_SNAKE_CASE__								=   VectorQuantizer(__A				,					__A				,					beta=0.2_5				,					remap=__A				,					sane_index_shape=__A		)
									SCREAMING_SNAKE_CASE__								=   nn.Convad(__A				,					__A				,					1		)

									# pass init params to Decoder
									SCREAMING_SNAKE_CASE__								=   Decoder(
									    in_channels=__A				,					out_channels=__A				,					up_block_types=__A				,					block_out_channels=__A				,					layers_per_block=__A				,					act_fn=__A				,					norm_num_groups=__A				,					norm_type=__A				,					)


							@apply_forward_hook
							def   _snake_case	(				self     :Union[str, Any]				,					__A     :torch.FloatTensor				,					__A     :bool = True		) -> VQEncoderOutput:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.encoder(__A		)
									SCREAMING_SNAKE_CASE__								=   self.quant_conv(__A		)

									if not return_dict:
											return (h,)

									return VQEncoderOutput(latents=__A		)


							@apply_forward_hook
							def   _snake_case	(				self     :Tuple				,					__A     :torch.FloatTensor				,					__A     :bool = False				,					__A     :bool = True		) -> Union[DecoderOutput, torch.FloatTensor]:



									"""simple docstring"""



									if not force_not_quantize:
											SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self.quantize(__A		)
									else:
											SCREAMING_SNAKE_CASE__								=   h
									SCREAMING_SNAKE_CASE__								=   self.post_quant_conv(__A		)
									SCREAMING_SNAKE_CASE__								=   self.decoder(__A				,					quant if self.config.norm_type == """spatial""" else None		)

									if not return_dict:
											return (dec,)

									return DecoderOutput(sample=__A		)


							def   _snake_case	(				self     :int				,					__A     :torch.FloatTensor				,					__A     :bool = True		) -> Union[DecoderOutput, torch.FloatTensor]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   sample
									SCREAMING_SNAKE_CASE__								=   self.encode(__A		).latents
									SCREAMING_SNAKE_CASE__								=   self.decode(__A		).sample

									if not return_dict:
											return (dec,)

									return DecoderOutput(sample=__A		)