



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  :





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

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





		def 							__A       (     self				)       ->     int:

					'''simple docstring'''
					__UpperCAmelCase   :      List[Any]										=     ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size				)

					__UpperCAmelCase   :      Tuple										=     None
					if self.use_input_mask:
								__UpperCAmelCase   :      List[Any]										=     random_attention_mask([self.batch_size, self.seq_length]				)

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

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

					__UpperCAmelCase   :      Dict										=     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=__SCREAMING_SNAKE_CASE ,       initializer_range=self.initializer_range ,       )

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





		def 							__A       (     self				)       ->     int:

					'''simple docstring'''
					(
					    (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,     
					)   :      int										=     self.prepare_config_and_inputs()

					__UpperCAmelCase   :      Optional[int]										=     True
					__UpperCAmelCase   :      Optional[Any]										=     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
					__UpperCAmelCase   :      Any										=     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 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     str:

					'''simple docstring'''
					__UpperCAmelCase   :      Union[str, Any]										=     RemBertModel(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      List[str]										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE				)
					__UpperCAmelCase   :      Optional[Any]										=     model(__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE				)
					__UpperCAmelCase   :      Tuple										=     model(__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       )       ->     str:

					'''simple docstring'''
					__UpperCAmelCase   :      int										=     True
					__UpperCAmelCase   :      Optional[Any]										=     RemBertModel(__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      int										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       encoder_hidden_states=__SCREAMING_SNAKE_CASE ,       encoder_attention_mask=__SCREAMING_SNAKE_CASE ,       )
					__UpperCAmelCase   :      List[str]										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       encoder_hidden_states=__SCREAMING_SNAKE_CASE ,       )
					__UpperCAmelCase   :      Tuple										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       )       ->     int:

					'''simple docstring'''
					__UpperCAmelCase   :      str										=     RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Any										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     Optional[Any]:

					'''simple docstring'''
					__UpperCAmelCase   :      int										=     RemBertForMaskedLM(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Dict										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       )       ->     Optional[int]:

					'''simple docstring'''
					__UpperCAmelCase   :      Tuple										=     True
					__UpperCAmelCase   :      str										=     True
					__UpperCAmelCase   :      int										=     RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()

					# first forward pass
					__UpperCAmelCase   :      Any										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       encoder_hidden_states=__SCREAMING_SNAKE_CASE ,       encoder_attention_mask=__SCREAMING_SNAKE_CASE ,       use_cache=__SCREAMING_SNAKE_CASE ,       )
					__UpperCAmelCase   :      Tuple										=     outputs.past_key_values

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

					# append to next input_ids and
					__UpperCAmelCase   :      Optional[int]										=     torch.cat([input_ids, next_tokens] ,       dim=-1				)
					__UpperCAmelCase   :      Optional[Any]										=     torch.cat([input_mask, next_mask] ,       dim=-1				)

					__UpperCAmelCase   :      Union[str, Any]										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       encoder_hidden_states=__SCREAMING_SNAKE_CASE ,       encoder_attention_mask=__SCREAMING_SNAKE_CASE ,       output_hidden_states=__SCREAMING_SNAKE_CASE ,       )["""hidden_states"""][0]
					__UpperCAmelCase   :      Tuple										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       encoder_hidden_states=__SCREAMING_SNAKE_CASE ,       encoder_attention_mask=__SCREAMING_SNAKE_CASE ,       past_key_values=__SCREAMING_SNAKE_CASE ,       output_hidden_states=__SCREAMING_SNAKE_CASE ,       )["""hidden_states"""][0]

					# select random slice
					__UpperCAmelCase   :      Union[str, Any]										=     ids_tensor((1,) ,       output_from_past.shape[-1]				).item()
					__UpperCAmelCase   :      int										=     output_from_no_past[:, -3:, random_slice_idx].detach()
					__UpperCAmelCase   :      Union[str, Any]										=     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(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       atol=1E-3				)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     Optional[Any]:

					'''simple docstring'''
					__UpperCAmelCase   :      Dict										=     RemBertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Union[str, Any]										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       start_positions=__SCREAMING_SNAKE_CASE ,       end_positions=__SCREAMING_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 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     List[str]:

					'''simple docstring'''
					__UpperCAmelCase   :      Union[str, Any]										=     self.num_labels
					__UpperCAmelCase   :      Dict										=     RemBertForSequenceClassification(__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Any										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     List[Any]:

					'''simple docstring'''
					__UpperCAmelCase   :      Optional[int]										=     self.num_labels
					__UpperCAmelCase   :      List[Any]										=     RemBertForTokenClassification(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Any										=     model(__SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels)				)





		def 							__A       (     self ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase ,       __UpperCAmelCase				)       ->     Optional[Any]:

					'''simple docstring'''
					__UpperCAmelCase   :      Tuple										=     self.num_choices
					__UpperCAmelCase   :      Optional[Any]										=     RemBertForMultipleChoice(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__UpperCAmelCase   :      Dict										=     input_ids.unsqueeze(1				).expand(-1 ,       self.num_choices ,       -1				).contiguous()
					__UpperCAmelCase   :      int										=     token_type_ids.unsqueeze(1				).expand(-1 ,       self.num_choices ,       -1				).contiguous()
					__UpperCAmelCase   :      Union[str, Any]										=     input_mask.unsqueeze(1				).expand(-1 ,       self.num_choices ,       -1				).contiguous()
					__UpperCAmelCase   :      Tuple										=     model(
					    __SCREAMING_SNAKE_CASE ,       attention_mask=__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE ,       )
					self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_choices)				)





		def 							__A       (     self				)       ->     Any:

					'''simple docstring'''
					__UpperCAmelCase   :      Optional[Any]										=     self.prepare_config_and_inputs()
					(
					    (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,     
					)   :      Tuple										=     config_and_inputs
					__UpperCAmelCase   :      Union[str, Any]										=     {"""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    ):
		_SCREAMING_SNAKE_CASE					:    int						      =			(
		    (
		        RemBertModel,
		        RemBertForMaskedLM,
		        RemBertForCausalLM,
		        RemBertForMultipleChoice,
		        RemBertForQuestionAnswering,
		        RemBertForSequenceClassification,
		        RemBertForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		_SCREAMING_SNAKE_CASE					:    Dict						      =			(RemBertForCausalLM,) if is_torch_available() else ()
		_SCREAMING_SNAKE_CASE					:    List[Any]						      =			(
		    {
		        """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 							__A       (     self				)       ->     int:

					'''simple docstring'''
					__UpperCAmelCase   :      List[str]										=     RemBertModelTester(self				)
					__UpperCAmelCase   :      Union[str, Any]										=     ConfigTester(self ,       config_class=__SCREAMING_SNAKE_CASE ,       hidden_size=37				)





		def 							__A       (     self				)       ->     str:

					'''simple docstring'''
					self.config_tester.run_common_tests()





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

					'''simple docstring'''
					__UpperCAmelCase   :      Dict										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE				)





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

					'''simple docstring'''
					__UpperCAmelCase   :      Any										=     self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
								__UpperCAmelCase   :      Optional[int]										=     type
								self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     Any:

					'''simple docstring'''
					__UpperCAmelCase   :      Union[str, Any]										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     Tuple:

					'''simple docstring'''
					__UpperCAmelCase   :      List[Any]										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     Any:

					'''simple docstring'''
					__UpperCAmelCase   :      List[str]										=     self.model_tester.prepare_config_and_inputs_for_decoder()
					self.model_tester.create_and_check_decoder_model_past_large_inputs(*__SCREAMING_SNAKE_CASE				)





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

					'''simple docstring'''
					__UpperCAmelCase   :      Optional[Any]										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     Any:

					'''simple docstring'''
					__UpperCAmelCase   :      int										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     int:

					'''simple docstring'''
					__UpperCAmelCase   :      Optional[Any]										=     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE				)





		def 							__A       (     self				)       ->     int:

					'''simple docstring'''
					__UpperCAmelCase   :      Optional[Any]										=     self.model_tester.prepare_config_and_inputs_for_decoder()
					self.model_tester.create_and_check_model_as_decoder(*__SCREAMING_SNAKE_CASE				)





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

					'''simple docstring'''
					# This regression test was failing with PyTorch < 1.3
					(
					    (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,  (
					    __UpperCAmelCase   
					)				,     
					)   :      Tuple										=     self.model_tester.prepare_config_and_inputs_for_decoder()

					__UpperCAmelCase   :      Any										=     None

					self.model_tester.create_and_check_model_as_decoder(
					    __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       )





		@slow
		def 							__A       (     self				)       ->     int:

					'''simple docstring'''
					for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								__UpperCAmelCase   :      List[str]										=     RemBertModel.from_pretrained(__SCREAMING_SNAKE_CASE				)
								self.assertIsNotNone(__SCREAMING_SNAKE_CASE				)



@require_torch
class _A  (    unittest.TestCase    ):





		@slow
		def 							__A       (     self				)       ->     Optional[int]:

					'''simple docstring'''
					# Test exact values at the last hidden layer
					__UpperCAmelCase   :      List[Any]										=     RemBertModel.from_pretrained("""google/rembert"""				)
					__UpperCAmelCase   :      List[str]										=     torch.tensor([[312, 56_498, 313, 2_125, 313]]				)
					__UpperCAmelCase   :      List[Any]										=     torch.tensor([[0, 0, 0, 1, 1]]				)
					with torch.no_grad():
								__UpperCAmelCase   :      str										=     model(__SCREAMING_SNAKE_CASE ,       token_type_ids=__SCREAMING_SNAKE_CASE ,       output_hidden_states=__SCREAMING_SNAKE_CASE				)

					__UpperCAmelCase   :      List[str]										=     1_152

					__UpperCAmelCase   :      str										=     torch.Size((1, 5, hidden_size)				)
					self.assertEqual(output["""last_hidden_state"""].shape ,       __SCREAMING_SNAKE_CASE				)

					__UpperCAmelCase   :      Any										=     torch.tensor(
					    [
					        [
					            [0.0754, -0.2022, 0.1904],
					            [-0.3354, -0.3692, -0.4791],
					            [-0.2314, -0.6729, -0.0749],
					            [-0.0396, -0.3105, -0.4234],
					            [-0.1571, -0.0525, 0.5353],
					        ]
					    ]				)

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









'''simple docstring'''
import warnings

from ...utils import logging
from .image_processing_mobilenet_va import MobileNetVaImageProcessor


_UpperCamelCase											=			logging.get_logger(__name__)



class _A  (    __SCREAMING_SNAKE_CASE    ):





		def __init__(     self ,       *__UpperCAmelCase ,       **__UpperCAmelCase				)       ->     None:

					'''simple docstring'''
					warnings.warn(
					    """The class MobileNetV2FeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
					    """ Please use MobileNetV2ImageProcessor instead.""" ,       __UpperCAmelCase ,       )
					super().__init__(*__UpperCAmelCase ,       **__UpperCAmelCase				)




