



"""simple docstring"""
from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__a           =							logging.get_logger(__name__)

__a           =							{
    "google/rembert": "https://huggingface.co/google/rembert/resolve/main/config.json",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}
class 							lowerCamelCase    (     _lowerCAmelCase							):






					'''simple docstring'''





					_A						:     Tuple		=	"""rembert"""






					def __init__(			self:				Tuple		,	snake_case:				int=250_300		,	snake_case:				Optional[Any]=1_152		,	snake_case:				Any=32		,	snake_case:				Tuple=18		,	snake_case:				List[Any]=256		,	snake_case:				Tuple=1_664		,	snake_case:				Any=4_608		,	snake_case:				Optional[Any]="gelu"		,	snake_case:				Any=0.0		,	snake_case:				Dict=0.0		,	snake_case:				Dict=0.1		,	snake_case:				Optional[int]=512		,	snake_case:				Tuple=2		,	snake_case:				Tuple=0.0_2		,	snake_case:				Optional[Any]=1E-12		,	snake_case:				List[str]=True		,	snake_case:				Tuple=0		,	snake_case:				Optional[int]=312		,	snake_case:				str=313		,	**snake_case:				Optional[Any]		,	)  ->      int:
											super().__init__(pad_token_id=snake_case		,	bos_token_id=snake_case		,	eos_token_id=snake_case		,	**snake_case		)

											snake_case_					:Dict		=     vocab_size
											snake_case_					:List[Any]		=     input_embedding_size
											snake_case_					:Dict		=     output_embedding_size
											snake_case_					:Optional[int]		=     max_position_embeddings
											snake_case_					:Union[str, Any]		=     hidden_size
											snake_case_					:List[Any]		=     num_hidden_layers
											snake_case_					:str		=     num_attention_heads
											snake_case_					:List[str]		=     intermediate_size
											snake_case_					:Tuple		=     hidden_act
											snake_case_					:List[Any]		=     hidden_dropout_prob
											snake_case_					:Dict		=     attention_probs_dropout_prob
											snake_case_					:Any		=     classifier_dropout_prob
											snake_case_					:Optional[int]		=     initializer_range
											snake_case_					:Optional[int]		=     type_vocab_size
											snake_case_					:Any		=     layer_norm_eps
											snake_case_					:Dict		=     use_cache
											snake_case_					:List[str]		=     False

class 							lowerCamelCase    (     _lowerCAmelCase							):






					'''simple docstring'''





					@property
					def   lowerCAmelCase_							(			self:				Optional[Any]		)  ->      Mapping[str, Mapping[int, str]]:
											if self.task == "multiple-choice":
																	snake_case_					:Optional[int]		=     {0: """batch""", 1: """choice""", 2: """sequence"""}
											else:
																	snake_case_					:str		=     {0: """batch""", 1: """sequence"""}
											return OrderedDict(
											    [
											        ("""input_ids""", dynamic_axis),
											        ("""attention_mask""", dynamic_axis),
											        ("""token_type_ids""", dynamic_axis),
											    ]		)






					@property
					def   lowerCAmelCase_							(			self:				Union[str, Any]		)  ->      float:
											return 1E-4







"""simple docstring"""






import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType



@require_torch
class 						lowerCAmelCase       :
       lowerCAmelCase__    			=	()
       lowerCAmelCase__    			=	True






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.config_class

              # test default config
              _UpperCAmelCase			     =  config_class()
              self.assertIsNotNone(a__  )
              _UpperCAmelCase			     =  ['stem'] + [f"""stage{idx}""" for idx in range(1     ,	len(config.depths  ) + 1  )]
              self.assertEqual(config.stage_names     ,	a__  )
              self.assertTrue(set(config.out_features  ).issubset(set(config.stage_names  )  )  )

              # Test out_features and out_indices are correctly set
              # out_features and out_indices both None
              _UpperCAmelCase			     =  config_class(out_features=a__     ,	out_indices=a__  )
              self.assertEqual(config.out_features     ,	[config.stage_names[-1]]  )
              self.assertEqual(config.out_indices     ,	[len(config.stage_names  ) - 1]  )

              # out_features and out_indices both set
              _UpperCAmelCase			     =  config_class(out_features=['stem', 'stage1']     ,	out_indices=[0, 1]  )
              self.assertEqual(config.out_features     ,	['stem', 'stage1']  )
              self.assertEqual(config.out_indices     ,	[0, 1]  )

              # Only out_features set
              _UpperCAmelCase			     =  config_class(out_features=['stage1', 'stage3']  )
              self.assertEqual(config.out_features     ,	['stage1', 'stage3']  )
              self.assertEqual(config.out_indices     ,	[1, 3]  )

              # Only out_indices set
              _UpperCAmelCase			     =  config_class(out_indices=[0, 2]  )
              self.assertEqual(config.out_features     ,	[config.stage_names[0], config.stage_names[2]]  )
              self.assertEqual(config.out_indices     ,	[0, 2]  )

              # Error raised when out_indices do not correspond to out_features
              with self.assertRaises(a__  ):
                     _UpperCAmelCase			     =  config_class(out_features=['stage1', 'stage2']     ,	out_indices=[0, 2]  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     _UpperCAmelCase			     =  inspect.signature(model.forward  )
                     # signature.parameters is an OrderedDict => so arg_names order is deterministic
                     _UpperCAmelCase			     =  [*signature.parameters.keys()]
                     _UpperCAmelCase			     =  ['pixel_values']
                     self.assertListEqual(arg_names[:1]     ,	a__  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	len(config.out_features  )  )
                     _UpperCAmelCase			     =  model.num_features
                     _UpperCAmelCase			     =  [config.stage_names.index(a__  ) for feat in config.out_features]
                     _UpperCAmelCase			     =  [num_features[idx] for idx in out_indices]
                     self.assertListEqual(model.channels     ,	a__  )

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	1  )
                     self.assertListEqual(model.channels     ,	[num_features[-1]]  )

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	1  )
                     self.assertListEqual(model.channels     ,	[num_features[-1]]  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

                     self.assertEqual(len(result.feature_maps  )     ,	len(config.out_features  )  )
                     self.assertEqual(len(model.channels  )     ,	len(config.out_features  )  )
                     self.assertEqual(len(result.feature_maps  )     ,	len(config.out_indices  )  )
                     self.assertEqual(len(model.channels  )     ,	len(config.out_indices  )  )

                     # Check output of last stage is taken if out_features=None, out_indices=None
                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

                     self.assertEqual(len(result.feature_maps  )     ,	1  )
                     self.assertEqual(len(model.channels  )     ,	1  )

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

                     self.assertEqual(len(result.feature_maps  )     ,	1  )
                     self.assertEqual(len(model.channels  )     ,	1  )

                     # Check backbone can be initialized with fresh weights
                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  False
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for backbone_class in self.all_model_classes:
                     _UpperCAmelCase			     =  backbone_class(a__  )

                     self.assertTrue(hasattr(a__     ,	'backbone_type'  )  )
                     self.assertTrue(hasattr(a__     ,	'stage_names'  )  )
                     self.assertTrue(hasattr(a__     ,	'num_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_indices'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_feature_channels'  )  )
                     self.assertTrue(hasattr(a__     ,	'channels'  )  )

                     self.assertIsInstance(backbone.backbone_type     ,	a__  )
                     # Verify num_features has been initialized in the backbone init
                     self.assertIsNotNone(backbone.num_features  )
                     self.assertTrue(len(backbone.channels  ) == len(backbone.out_indices  )  )
                     self.assertTrue(len(backbone.stage_names  ) == len(backbone.num_features  )  )
                     self.assertTrue(len(backbone.channels  ) <= len(backbone.num_features  )  )
                     self.assertTrue(len(backbone.out_feature_channels  ) == len(backbone.stage_names  )  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()
              _UpperCAmelCase			     =  inputs_dict['pixel_values'].shape[0]

              for backbone_class in self.all_model_classes:
                     _UpperCAmelCase			     =  backbone_class(a__  )
                     backbone.to(a__  )
                     backbone.eval()

                     _UpperCAmelCase			     =  backbone(**a__  )

                     # Test default outputs and verify feature maps
                     self.assertIsInstance(outputs.feature_maps     ,	a__  )
                     self.assertTrue(len(outputs.feature_maps  ) == len(backbone.channels  )  )
                     for feature_map, n_channels in zip(outputs.feature_maps     ,	backbone.channels  ):
                            self.assertTrue(feature_map.shape[:2]     ,	(batch_size, n_channels)  )
                     self.assertIsNone(outputs.hidden_states  )
                     self.assertIsNone(outputs.attentions  )

                     # Test output_hidden_states=True
                     _UpperCAmelCase			     =  backbone(**a__     ,	output_hidden_states=a__  )
                     self.assertIsNotNone(outputs.hidden_states  )
                     self.assertTrue(len(outputs.hidden_states  )     ,	len(backbone.stage_names  )  )
                     for hidden_state, n_channels in zip(outputs.hidden_states     ,	backbone.channels  ):
                            self.assertTrue(hidden_state.shape[:2]     ,	(batch_size, n_channels)  )

                     # Test output_attentions=True
                     if self.has_attentions:
                            _UpperCAmelCase			     =  backbone(**a__     ,	output_attentions=a__  )
                            self.assertIsNotNone(outputs.attentions  )






