
'''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 		__UpperCAmelCase   :


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_=2					,     lowerCAmelCase_=8					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_=99					,     lowerCAmelCase_=16					,     lowerCAmelCase_=5					,     lowerCAmelCase_=2					,     lowerCAmelCase_=36					,     lowerCAmelCase_="gelu"					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=5_12					,     lowerCAmelCase_=16					,     lowerCAmelCase_=2					,     lowerCAmelCase_=0.02					,     lowerCAmelCase_=3					,     lowerCAmelCase_=4					,     lowerCAmelCase_=None					,     ):





								"""simple docstring"""






								_snake_case     		=	parent
								_snake_case     		=	batch_size
								_snake_case     		=	seq_length
								_snake_case     		=	is_training
								_snake_case     		=	use_input_mask
								_snake_case     		=	use_token_type_ids
								_snake_case     		=	use_labels
								_snake_case     		=	vocab_size
								_snake_case     		=	hidden_size
								_snake_case     		=	num_hidden_layers
								_snake_case     		=	num_attention_heads
								_snake_case     		=	intermediate_size
								_snake_case     		=	hidden_act
								_snake_case     		=	hidden_dropout_prob
								_snake_case     		=	attention_probs_dropout_prob
								_snake_case     		=	max_position_embeddings
								_snake_case     		=	type_vocab_size
								_snake_case     		=	type_sequence_label_size
								_snake_case     		=	initializer_range
								_snake_case     		=	num_labels
								_snake_case     		=	num_choices
								_snake_case     		=	scope


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	ids_tensor([self.batch_size, self.seq_length]					,     self.vocab_size						)

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

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

								_snake_case     		=	None
								_snake_case     		=	None
								_snake_case     		=	None
								if self.use_labels:
									_snake_case     		=	ids_tensor([self.batch_size]					,     self.type_sequence_label_size						)
									_snake_case     		=	ids_tensor([self.batch_size, self.seq_length]					,     self.num_labels						)
									_snake_case     		=	ids_tensor([self.batch_size]					,     self.num_choices						)

								_snake_case     		=	self.get_config()

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


							def 				lowerCamelCase       ( self						):





								"""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=lowerCAmelCase_					,     initializer_range=self.initializer_range					,     )


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_config()
								_snake_case     		=	3_00
								return config


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								(
								    (
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				(
								    _snake_case       
								)		,				       
								)     		=	self.prepare_config_and_inputs()

								_snake_case     		=	True
								_snake_case     		=	floats_tensor([self.batch_size, self.seq_length, self.hidden_size]						)
								_snake_case     		=	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					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	MraModel(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_						)
								_snake_case     		=	model(lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_						)
								_snake_case     		=	model(lowerCAmelCase_						)
								self.parent.assertEqual(result.last_hidden_state.shape					,     (self.batch_size, self.seq_length, self.hidden_size)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     ):





								"""simple docstring"""






								_snake_case     		=	True
								_snake_case     		=	MraModel(lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(
								    lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     encoder_hidden_states=lowerCAmelCase_					,     encoder_attention_mask=lowerCAmelCase_					,     )
								_snake_case     		=	model(
								    lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     encoder_hidden_states=lowerCAmelCase_					,     )
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_						)
								self.parent.assertEqual(result.last_hidden_state.shape					,     (self.batch_size, self.seq_length, self.hidden_size)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	MraForMaskedLM(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.seq_length, self.vocab_size)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	MraForQuestionAnswering(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(
								    lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     start_positions=lowerCAmelCase_					,     end_positions=lowerCAmelCase_					,     )
								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					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.num_labels
								_snake_case     		=	MraForSequenceClassification(lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.num_labels
								_snake_case     		=	MraForTokenClassification(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     token_type_ids=lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.seq_length, self.num_labels)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.num_choices
								_snake_case     		=	MraForMultipleChoice(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	input_ids.unsqueeze(1						).expand(-1					,     self.num_choices					,     -1						).contiguous()
								_snake_case     		=	token_type_ids.unsqueeze(1						).expand(-1					,     self.num_choices					,     -1						).contiguous()
								_snake_case     		=	input_mask.unsqueeze(1						).expand(-1					,     self.num_choices					,     -1						).contiguous()
								_snake_case     		=	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						):





								"""simple docstring"""






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


@require_torch
class 		__UpperCAmelCase   (      UpperCamelCase__		,     unittest.TestCase		):
							__lowercase   	= (
							    (
							        MraModel,
							        MraForMaskedLM,
							        MraForMultipleChoice,
							        MraForQuestionAnswering,
							        MraForSequenceClassification,
							        MraForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase   	= False
							__lowercase   	= False
							__lowercase   	= False
							__lowercase   	= False

							__lowercase   	= ()


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MraModelTester(self						)
								_snake_case     		=	ConfigTester(self					,     config_class=lowerCAmelCase_					,     hidden_size=37						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								self.config_tester.run_common_tests()


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
									_snake_case     		=	type
									self.model_tester.create_and_check_model(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_						)


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case     		=	MraModel.from_pretrained(lowerCAmelCase_						)
									self.assertIsNotNone(lowerCAmelCase_						)




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





								"""simple docstring"""






								return


@require_torch
class 		__UpperCAmelCase   (      unittest.TestCase		):


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MraModel.from_pretrained('uw-madison/mra-base-512-4'						)
								_snake_case     		=	torch.arange(2_56						).unsqueeze(0						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_						)[0]

								_snake_case     		=	torch.Size((1, 2_56, 7_68)						)
								self.assertEqual(output.shape					,     lowerCAmelCase_						)

								_snake_case     		=	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]					,     lowerCAmelCase_					,     atol=1E-4						)						)


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4'						)
								_snake_case     		=	torch.arange(2_56						).unsqueeze(0						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_						)[0]

								_snake_case     		=	5_02_65

								_snake_case     		=	torch.Size((1, 2_56, vocab_size)						)
								self.assertEqual(output.shape					,     lowerCAmelCase_						)

								_snake_case     		=	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]					,     lowerCAmelCase_					,     atol=1E-4						)						)




							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3'						)
								_snake_case     		=	torch.arange(40_96						).unsqueeze(0						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_						)[0]

								_snake_case     		=	5_02_65

								_snake_case     		=	torch.Size((1, 40_96, vocab_size)						)
								self.assertEqual(output.shape					,     lowerCAmelCase_						)

								_snake_case     		=	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]					,     lowerCAmelCase_					,     atol=1E-4						)						)



'''simple docstring'''







from typing import List, Optional

from tokenizers import ByteLevelBPETokenizer

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot_small import BlenderbotSmallTokenizer


lowercase					:							Optional[Any]   =      logging.get_logger(__name__)

lowercase					:							str   =      {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
    "tokenizer_config_file": "tokenizer_config.json",
}

lowercase					:							Optional[Any]   =      {
    "vocab_file": {
        "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json"
    },
    "merges_file": {
        "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt"
    },
    "tokenizer_config_file": {
        "facebook/blenderbot_small-90M": (
            "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json"
        )
    },
}

lowercase					:							List[Any]   =      {
    "facebook/blenderbot_small-90M": 512,
}


class 		__UpperCAmelCase   (      _lowerCamelCase		):
							__lowercase   	= VOCAB_FILES_NAMES
							__lowercase   	= PRETRAINED_VOCAB_FILES_MAP
							__lowercase   	= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__lowercase   	= BlenderbotSmallTokenizer


							def __init__( self					,     lowerCAmelCase_=None					,     lowerCAmelCase_=None					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_=False					,     lowerCAmelCase_=True					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								super().__init__(
								    ByteLevelBPETokenizer(
								        vocab=lowerCAmelCase_					,     merges=lowerCAmelCase_					,     add_prefix_space=lowerCAmelCase_					,     trim_offsets=lowerCAmelCase_					,     )					,     bos_token=lowerCAmelCase_					,     eos_token=lowerCAmelCase_					,     unk_token=lowerCAmelCase_					,     **lowerCAmelCase_					,     )
								_snake_case     		=	add_prefix_space


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_=None						):





								"""simple docstring"""






								_snake_case     		=	[self.bos_token_id] + token_ids_a + [self.eos_token_id]
								if token_ids_a is None:
									return output

								return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	[self.sep_token_id]
								_snake_case     		=	[self.cls_token_id]

								if token_ids_a is None:
									return len(cls + token_ids_a + sep						) * [0]
								return len(cls + token_ids_a + sep + sep + token_ids_a + sep						) * [0]

