


import unittest

from transformers import 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    RemBertConfig,
	    RemBertForCausalLM,
	    RemBertForMaskedLM,
	    RemBertForMultipleChoice,
	    RemBertForQuestionAnswering,
	    RemBertForSequenceClassification,
	    RemBertForTokenClassification,
	    RemBertModel,
	)
	from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST



class 							A					:
					'''simple docstring'''






					def __init__(self					:		int   ,      _UpperCAmelCase					:		str   ,      _UpperCAmelCase					:		Tuple=13   ,      _UpperCAmelCase					:		str=7   ,      _UpperCAmelCase					:		List[str]=True   ,      _UpperCAmelCase					:		Tuple=True   ,      _UpperCAmelCase					:		int=True   ,      _UpperCAmelCase					:		Tuple=True   ,      _UpperCAmelCase					:		List[str]=99   ,      _UpperCAmelCase					:		Optional[int]=32   ,      _UpperCAmelCase					:		List[Any]=18   ,      _UpperCAmelCase					:		Tuple=43   ,      _UpperCAmelCase					:		Dict=5   ,      _UpperCAmelCase					:		List[str]=4   ,      _UpperCAmelCase					:		str=37   ,      _UpperCAmelCase					:		int="gelu"   ,      _UpperCAmelCase					:		Optional[int]=0.1   ,      _UpperCAmelCase					:		Optional[Any]=0.1   ,      _UpperCAmelCase					:		Dict=512   ,      _UpperCAmelCase					:		str=16   ,      _UpperCAmelCase					:		List[Any]=2   ,      _UpperCAmelCase					:		Optional[Any]=0.02   ,      _UpperCAmelCase					:		Any=3   ,      _UpperCAmelCase					:		int=4   ,      _UpperCAmelCase					:		Optional[Any]=None   ,      )		->     int:




							"""simple docstring"""


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

					def 						lowerCamelCase__  (self					:		List[str]	)		->     List[str]:




							"""simple docstring"""


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

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

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

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

							lowercase__      =	RemBertConfig(
							    vocab_size=self.vocab_size   ,      hidden_size=self.hidden_size   ,      input_embedding_size=self.input_embedding_size   ,      output_embedding_size=self.output_embedding_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=_UpperCAmelCase   ,      initializer_range=self.initializer_range   ,      )

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

					def 						lowerCamelCase__  (self					:		Optional[int]	)		->     int:




							"""simple docstring"""


							(
							    (
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			
							)      =	self.prepare_config_and_inputs()

							lowercase__      =	True
							lowercase__      =	floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
							lowercase__      =	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					:		Any   ,      _UpperCAmelCase					:		Dict   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		Dict   ,      _UpperCAmelCase					:		Union[str, Any]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		List[str]   ,      _UpperCAmelCase					:		Dict	)		->     Dict:




							"""simple docstring"""


							lowercase__      =	RemBertModel(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase	)
							lowercase__      =	model(_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase	)
							lowercase__      =	model(_UpperCAmelCase	)
							self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size)	)

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




							"""simple docstring"""


							lowercase__      =	True
							lowercase__      =	RemBertModel(_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      encoder_hidden_states=_UpperCAmelCase   ,      encoder_attention_mask=_UpperCAmelCase   ,      )
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      encoder_hidden_states=_UpperCAmelCase   ,      )
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase	)
							self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size)	)

					def 						lowerCamelCase__  (self					:		List[str]   ,      _UpperCAmelCase					:		str   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		Any   ,      _UpperCAmelCase					:		Any   ,      _UpperCAmelCase					:		Any   ,      )		->     Optional[Any]:




							"""simple docstring"""


							lowercase__      =	RemBertForCausalLM(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      labels=_UpperCAmelCase	)
							self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.vocab_size)	)

					def 						lowerCamelCase__  (self					:		str   ,      _UpperCAmelCase					:		str   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		str   ,      _UpperCAmelCase					:		Dict   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Any	)		->     int:




							"""simple docstring"""


							lowercase__      =	RemBertForMaskedLM(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      labels=_UpperCAmelCase	)
							self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.vocab_size)	)

					def 						lowerCamelCase__  (self					:		List[str]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Dict   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		Tuple   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Optional[int]   ,      )		->     str:




							"""simple docstring"""


							lowercase__      =	True
							lowercase__      =	True
							lowercase__      =	RemBertForCausalLM(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()

							# first forward pass
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      encoder_hidden_states=_UpperCAmelCase   ,      encoder_attention_mask=_UpperCAmelCase   ,      use_cache=_UpperCAmelCase   ,      )
							lowercase__      =	outputs.past_key_values

							# create hypothetical multiple next token and extent to next_input_ids
							lowercase__      =	ids_tensor((self.batch_size, 3)   ,      config.vocab_size	)
							lowercase__      =	ids_tensor((self.batch_size, 3)   ,      vocab_size=2	)

							# append to next input_ids and
							lowercase__      =	torch.cat([input_ids, next_tokens]   ,      dim=-1	)
							lowercase__      =	torch.cat([input_mask, next_mask]   ,      dim=-1	)

							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      encoder_hidden_states=_UpperCAmelCase   ,      encoder_attention_mask=_UpperCAmelCase   ,      output_hidden_states=_UpperCAmelCase   ,      )["""hidden_states"""][0]
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      encoder_hidden_states=_UpperCAmelCase   ,      encoder_attention_mask=_UpperCAmelCase   ,      past_key_values=_UpperCAmelCase   ,      output_hidden_states=_UpperCAmelCase   ,      )["""hidden_states"""][0]

							# select random slice
							lowercase__      =	ids_tensor((1,)   ,      output_from_past.shape[-1]	).item()
							lowercase__      =	output_from_no_past[:, -3:, random_slice_idx].detach()
							lowercase__      =	output_from_past[:, :, random_slice_idx].detach()

							self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

							# test that outputs are equal for slice
							self.parent.assertTrue(torch.allclose(_UpperCAmelCase   ,      _UpperCAmelCase   ,      atol=1E-3	)	)

					def 						lowerCamelCase__  (self					:		Any   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		List[str]   ,      _UpperCAmelCase					:		Dict   ,      _UpperCAmelCase					:		Union[str, Any]   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		List[str]   ,      _UpperCAmelCase					:		Optional[int]	)		->     int:




							"""simple docstring"""


							lowercase__      =	RemBertForQuestionAnswering(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      start_positions=_UpperCAmelCase   ,      end_positions=_UpperCAmelCase   ,      )
							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					:		Tuple   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		Any   ,      _UpperCAmelCase					:		Tuple   ,      _UpperCAmelCase					:		List[str]   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		List[Any]	)		->     Tuple:




							"""simple docstring"""


							lowercase__      =	self.num_labels
							lowercase__      =	RemBertForSequenceClassification(_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      labels=_UpperCAmelCase	)
							self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.num_labels)	)

					def 						lowerCamelCase__  (self					:		Optional[Any]   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Tuple   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		int   ,      _UpperCAmelCase					:		List[Any]	)		->     Dict:




							"""simple docstring"""


							lowercase__      =	self.num_labels
							lowercase__      =	RemBertForTokenClassification(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	model(_UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      labels=_UpperCAmelCase	)
							self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.num_labels)	)

					def 						lowerCamelCase__  (self					:		List[str]   ,      _UpperCAmelCase					:		Optional[Any]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		List[Any]   ,      _UpperCAmelCase					:		List[str]   ,      _UpperCAmelCase					:		Optional[int]   ,      _UpperCAmelCase					:		List[Any]	)		->     Optional[int]:




							"""simple docstring"""


							lowercase__      =	self.num_choices
							lowercase__      =	RemBertForMultipleChoice(config=_UpperCAmelCase	)
							model.to(_UpperCAmelCase	)
							model.eval()
							lowercase__      =	input_ids.unsqueeze(1	).expand(-1   ,      self.num_choices   ,      -1	).contiguous()
							lowercase__      =	token_type_ids.unsqueeze(1	).expand(-1   ,      self.num_choices   ,      -1	).contiguous()
							lowercase__      =	input_mask.unsqueeze(1	).expand(-1   ,      self.num_choices   ,      -1	).contiguous()
							lowercase__      =	model(
							    _UpperCAmelCase   ,      attention_mask=_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      labels=_UpperCAmelCase   ,      )
							self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.num_choices)	)


					def 						lowerCamelCase__  (self					:		Any	)		->     Optional[Any]:




							"""simple docstring"""


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






@require_torch
class 							A					( UpperCAmelCase__				,						UpperCAmelCase__				,						unittest.TestCase							):
					'''simple docstring'''






					A__    =				(
					    (
					        RemBertModel,
					        RemBertForMaskedLM,
					        RemBertForCausalLM,
					        RemBertForMultipleChoice,
					        RemBertForQuestionAnswering,
					        RemBertForSequenceClassification,
					        RemBertForTokenClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					A__    =				(RemBertForCausalLM,) if is_torch_available() else ()
					A__    =				(
					    {
					        '''feature-extraction''': RemBertModel,
					        '''fill-mask''': RemBertForMaskedLM,
					        '''question-answering''': RemBertForQuestionAnswering,
					        '''text-classification''': RemBertForSequenceClassification,
					        '''text-generation''': RemBertForCausalLM,
					        '''token-classification''': RemBertForTokenClassification,
					        '''zero-shot''': RemBertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)

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




							"""simple docstring"""


							lowercase__      =	RemBertModelTester(self	)
							lowercase__      =	ConfigTester(self   ,      config_class=_UpperCAmelCase   ,      hidden_size=37	)

					def 						lowerCamelCase__  (self					:		str	)		->     Dict:




							"""simple docstring"""


							self.config_tester.run_common_tests()

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




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCAmelCase	)

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




							"""simple docstring"""


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

					def 						lowerCamelCase__  (self					:		Dict	)		->     Dict:




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase	)

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




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*_UpperCAmelCase	)

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




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs_for_decoder()
							self.model_tester.create_and_check_decoder_model_past_large_inputs(*_UpperCAmelCase	)

					def 						lowerCamelCase__  (self					:		int	)		->     Optional[int]:




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase	)

					def 						lowerCamelCase__  (self					:		Any	)		->     Dict:




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase	)

					def 						lowerCamelCase__  (self					:		int	)		->     Tuple:




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase	)

					def 						lowerCamelCase__  (self					:		List[Any]	)		->     List[Any]:




							"""simple docstring"""


							lowercase__      =	self.model_tester.prepare_config_and_inputs_for_decoder()
							self.model_tester.create_and_check_model_as_decoder(*_UpperCAmelCase	)

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




							"""simple docstring"""


							(
							    (
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			(
							    lowercase__
							)    ,			
							)      =	self.model_tester.prepare_config_and_inputs_for_decoder()

							lowercase__      =	None

							self.model_tester.create_and_check_model_as_decoder(
							    _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      _UpperCAmelCase   ,      )


					@slow
					def 						lowerCamelCase__  (self					:		str	)		->     int:




							"""simple docstring"""


							for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase__      =	RemBertModel.from_pretrained(_UpperCAmelCase	)
									self.assertIsNotNone(_UpperCAmelCase	)






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






					@slow
					def 						lowerCamelCase__  (self					:		Optional[Any]	)		->     Dict:




							"""simple docstring"""


							lowercase__      =	RemBertModel.from_pretrained("""google/rembert"""	)
							lowercase__      =	torch.tensor([[312, 5_6498, 313, 2125, 313]]	)
							lowercase__      =	torch.tensor([[0, 0, 0, 1, 1]]	)
							with torch.no_grad():
									lowercase__      =	model(_UpperCAmelCase   ,      token_type_ids=_UpperCAmelCase   ,      output_hidden_states=_UpperCAmelCase	)

							lowercase__      =	1152

							lowercase__      =	torch.Size((1, 5, hidden_size)	)
							self.assertEqual(output["""last_hidden_state"""].shape   ,      _UpperCAmelCase	)

							lowercase__      =	torch.tensor(
							    [
							        [
							            [0.0_754, -0.2_022, 0.1_904],
							            [-0.3_354, -0.3_692, -0.4_791],
							            [-0.2_314, -0.6_729, -0.0_749],
							            [-0.0_396, -0.3_105, -0.4_234],
							            [-0.1_571, -0.0_525, 0.5_353],
							        ]
							    ]	)

							# Running on the original tf implementation gives slightly different results here.
							# Not clear why this variations is present
							# TODO: Find reason for discrepancy
							# expected_original_implementation = [[
							#     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
							#     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
							#     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
							#     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
							#     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
							# ]]

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





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


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

A :	Union[str, Any]												=     {
    'facebook/sam-vit-huge': 'https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json',
    'facebook/sam-vit-large': 'https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json',
    'facebook/sam-vit-base': 'https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json',
}



class 							A					( UpperCAmelCase__							):
					'''simple docstring'''






					def __init__(self					:		Dict   ,      _UpperCAmelCase					:		List[str]=256   ,      _UpperCAmelCase					:		Tuple=1024   ,      _UpperCAmelCase					:		List[str]=16   ,      _UpperCAmelCase					:		Optional[Any]=16   ,      _UpperCAmelCase					:		Union[str, Any]=4   ,      _UpperCAmelCase					:		str="gelu"   ,      _UpperCAmelCase					:		List[str]=1E-6   ,      **_UpperCAmelCase					:		List[Any]   ,      )		->     Tuple:




							"""simple docstring"""


							super().__init__(**_UpperCAmelCase	)
							lowercase__      =	hidden_size
							lowercase__      =	image_size
							lowercase__      =	patch_size
							lowercase__      =	image_size // patch_size
							lowercase__      =	mask_input_channels
							lowercase__      =	num_point_embeddings
							lowercase__      =	hidden_act
							lowercase__      =	layer_norm_eps






class 							A					( UpperCAmelCase__							):
					'''simple docstring'''






					def __init__(self					:		List[str]   ,      _UpperCAmelCase					:		Optional[int]=256   ,      _UpperCAmelCase					:		int="relu"   ,      _UpperCAmelCase					:		Union[str, Any]=2048   ,      _UpperCAmelCase					:		int=2   ,      _UpperCAmelCase					:		Optional[Any]=8   ,      _UpperCAmelCase					:		Any=2   ,      _UpperCAmelCase					:		Tuple=3   ,      _UpperCAmelCase					:		List[str]=3   ,      _UpperCAmelCase					:		List[str]=256   ,      _UpperCAmelCase					:		Tuple=1E-6   ,      **_UpperCAmelCase					:		int   ,      )		->     Tuple:




							"""simple docstring"""


							super().__init__(**_UpperCAmelCase	)
							lowercase__      =	hidden_size
							lowercase__      =	hidden_act
							lowercase__      =	mlp_dim
							lowercase__      =	num_hidden_layers
							lowercase__      =	num_attention_heads
							lowercase__      =	attention_downsample_rate
							lowercase__      =	num_multimask_outputs
							lowercase__      =	iou_head_depth
							lowercase__      =	iou_head_hidden_dim
							lowercase__      =	layer_norm_eps






class 							A					( UpperCAmelCase__							):
					'''simple docstring'''






					def __init__(self					:		Optional[int]   ,      _UpperCAmelCase					:		List[Any]=768   ,      _UpperCAmelCase					:		Union[str, Any]=256   ,      _UpperCAmelCase					:		Union[str, Any]=12   ,      _UpperCAmelCase					:		Optional[Any]=12   ,      _UpperCAmelCase					:		Tuple=3   ,      _UpperCAmelCase					:		Optional[int]=1024   ,      _UpperCAmelCase					:		str=16   ,      _UpperCAmelCase					:		Tuple="gelu"   ,      _UpperCAmelCase					:		Any=1E-0_6   ,      _UpperCAmelCase					:		Any=0.0   ,      _UpperCAmelCase					:		str=1E-1_0   ,      _UpperCAmelCase					:		Tuple=True   ,      _UpperCAmelCase					:		Tuple=4.0   ,      _UpperCAmelCase					:		Optional[Any]=True   ,      _UpperCAmelCase					:		Optional[int]=True   ,      _UpperCAmelCase					:		Optional[Any]=14   ,      _UpperCAmelCase					:		Optional[int]=[2, 5, 8, 11]   ,      _UpperCAmelCase					:		List[Any]=128   ,      _UpperCAmelCase					:		int=None   ,      **_UpperCAmelCase					:		int   ,      )		->     Dict:




							"""simple docstring"""


							super().__init__(**_UpperCAmelCase	)

							lowercase__      =	hidden_size
							lowercase__      =	output_channels
							lowercase__      =	num_hidden_layers
							lowercase__      =	num_attention_heads
							lowercase__      =	num_channels
							lowercase__      =	image_size
							lowercase__      =	patch_size
							lowercase__      =	hidden_act
							lowercase__      =	layer_norm_eps
							lowercase__      =	attention_dropout
							lowercase__      =	initializer_range
							lowercase__      =	qkv_bias
							lowercase__      =	mlp_ratio
							lowercase__      =	use_abs_pos
							lowercase__      =	use_rel_pos
							lowercase__      =	window_size
							lowercase__      =	global_attn_indexes
							lowercase__      =	num_pos_feats
							lowercase__      =	int(hidden_size * mlp_ratio	) if mlp_dim is None else mlp_dim






class 							A					( UpperCAmelCase__							):
					'''simple docstring'''






					A__    =				'''sam'''
					A__    =				True

					def __init__(self					:		List[str]   ,      _UpperCAmelCase					:		Any=None   ,      _UpperCAmelCase					:		List[Any]=None   ,      _UpperCAmelCase					:		List[Any]=None   ,      _UpperCAmelCase					:		List[Any]=0.02   ,      **_UpperCAmelCase					:		Optional[Any]   ,      )		->     Dict:




							"""simple docstring"""


							super().__init__(**_UpperCAmelCase	)
							lowercase__      =	vision_config if vision_config is not None else {}
							lowercase__      =	prompt_encoder_config if prompt_encoder_config is not None else {}
							lowercase__      =	mask_decoder_config if mask_decoder_config is not None else {}

							if isinstance(_UpperCAmelCase   ,      _UpperCAmelCase	):
									lowercase__      =	vision_config.to_dict()
							if isinstance(_UpperCAmelCase   ,      _UpperCAmelCase	):
									lowercase__      =	prompt_encoder_config.to_dict()
							if isinstance(_UpperCAmelCase   ,      _UpperCAmelCase	):
									lowercase__      =	mask_decoder_config.to_dict()

							lowercase__      =	SamVisionConfig(**_UpperCAmelCase	)
							lowercase__      =	SamPromptEncoderConfig(**_UpperCAmelCase	)
							lowercase__      =	SamMaskDecoderConfig(**_UpperCAmelCase	)
							lowercase__      =	initializer_range


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




							"""simple docstring"""


							lowercase__      =	copy.deepcopy(self.__dict__	)
							lowercase__      =	self.vision_config.to_dict()
							lowercase__      =	self.prompt_encoder_config.to_dict()
							lowercase__      =	self.mask_decoder_config.to_dict()
							lowercase__      =	self.__class__.model_type
							return output

