
from typing import Optional, Union

import torch
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_mobilenet_va import MobileNetVaConfig


lowerCamelCase__ :       Dict						     =			logging.get_logger(__name__)


# General docstring
lowerCamelCase__ :       str						     =			"MobileNetV1Config"

# Base docstring
lowerCamelCase__ :       Dict						     =			"google/mobilenet_v1_1.0_224"
lowerCamelCase__ :       Union[str, Any]						     =			[1, 1024, 7, 7]

# Image classification docstring
lowerCamelCase__ :       str						     =			"google/mobilenet_v1_1.0_224"
lowerCamelCase__ :       List[str]						     =			"tabby, tabby cat"


lowerCamelCase__ :       List[str]						     =			[
    "google/mobilenet_v1_1.0_224",
    "google/mobilenet_v1_0.75_192",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
]





def __A						(   a_ :							int		,		a_ :							Optional[int]		,		a_ :							str=None     )->							Dict:




		'''simple docstring'''






		SCREAMING_SNAKE_CASE       :     Any				= {}

		if isinstance(__lowercase		,		__lowercase     ):
				SCREAMING_SNAKE_CASE       :     Optional[Any]				= model.mobilenet_va
		else:
				SCREAMING_SNAKE_CASE       :     str				= model

		SCREAMING_SNAKE_CASE       :     List[Any]				= 'MobilenetV1/Conv2d_0/'
		SCREAMING_SNAKE_CASE       :     Optional[Any]				= backbone.conv_stem.convolution.weight
		SCREAMING_SNAKE_CASE       :     Optional[int]				= backbone.conv_stem.normalization.bias
		SCREAMING_SNAKE_CASE       :     int				= backbone.conv_stem.normalization.weight
		SCREAMING_SNAKE_CASE       :     int				= backbone.conv_stem.normalization.running_mean
		SCREAMING_SNAKE_CASE       :     int				= backbone.conv_stem.normalization.running_var

		for i in range(13     ):
				SCREAMING_SNAKE_CASE       :     Optional[Any]				= i + 1
				SCREAMING_SNAKE_CASE       :     Union[str, Any]				= i * 2

				SCREAMING_SNAKE_CASE       :     Optional[Any]				= backbone.layer[pt_index]
				SCREAMING_SNAKE_CASE       :     Union[str, Any]				= F"MobilenetV1/Conv2d_{tf_index}_depthwise/"
				SCREAMING_SNAKE_CASE       :     int				= pointer.convolution.weight
				SCREAMING_SNAKE_CASE       :     List[Any]				= pointer.normalization.bias
				SCREAMING_SNAKE_CASE       :     Any				= pointer.normalization.weight
				SCREAMING_SNAKE_CASE       :     Tuple				= pointer.normalization.running_mean
				SCREAMING_SNAKE_CASE       :     Union[str, Any]				= pointer.normalization.running_var

				SCREAMING_SNAKE_CASE       :     str				= backbone.layer[pt_index + 1]
				SCREAMING_SNAKE_CASE       :     str				= F"MobilenetV1/Conv2d_{tf_index}_pointwise/"
				SCREAMING_SNAKE_CASE       :     Dict				= pointer.convolution.weight
				SCREAMING_SNAKE_CASE       :     List[str]				= pointer.normalization.bias
				SCREAMING_SNAKE_CASE       :     Optional[int]				= pointer.normalization.weight
				SCREAMING_SNAKE_CASE       :     Dict				= pointer.normalization.running_mean
				SCREAMING_SNAKE_CASE       :     str				= pointer.normalization.running_var

		if isinstance(__lowercase		,		__lowercase     ):
				SCREAMING_SNAKE_CASE       :     List[str]				= 'MobilenetV1/Logits/Conv2d_1c_1x1/'
				SCREAMING_SNAKE_CASE       :     Tuple				= model.classifier.weight
				SCREAMING_SNAKE_CASE       :     Dict				= model.classifier.bias

		return tf_to_pt_map





def __A						(   a_ :							Tuple		,		a_ :							Tuple		,		a_ :							Dict     )->							List[Any]:




		'''simple docstring'''






		try:
				import numpy as np
				import tensorflow as tf
		except ImportError:
				logger.error(
				    '''Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see '''
				    '''https://www.tensorflow.org/install/ for installation instructions.'''     )
				raise

		# Load weights from TF model
		SCREAMING_SNAKE_CASE       :     int				= tf.train.list_variables(__lowercase     )
		SCREAMING_SNAKE_CASE       :     Any				= {}
		for name, shape in init_vars:
				logger.info(F"Loading TF weight {name} with shape {shape}"     )
				SCREAMING_SNAKE_CASE       :     Optional[int]				= tf.train.load_variable(__lowercase		,		__lowercase     )
				SCREAMING_SNAKE_CASE       :     int				= array

		# Build TF to PyTorch weights loading map
		SCREAMING_SNAKE_CASE       :     Optional[int]				= _build_tf_to_pytorch_map(__lowercase		,		__lowercase		,		__lowercase     )

		for name, pointer in tf_to_pt_map.items():
				logger.info(F"Importing {name}"     )
				if name not in tf_weights:
						logger.info(F"{name} not in tf pre-trained weights, skipping"     )
						continue

				SCREAMING_SNAKE_CASE       :     Tuple				= tf_weights[name]

				if "depthwise_weights" in name:
						logger.info('''Transposing depthwise'''     )
						SCREAMING_SNAKE_CASE       :     Union[str, Any]				= np.transpose(__lowercase		,		(2, 3, 0, 1)     )
				elif "weights" in name:
						logger.info('''Transposing'''     )
						if len(pointer.shape     ) == 2:  # copying into linear layer
								SCREAMING_SNAKE_CASE       :     str				= array.squeeze().transpose()
						else:
								SCREAMING_SNAKE_CASE       :     Dict				= np.transpose(__lowercase		,		(3, 2, 0, 1)     )

				if pointer.shape != array.shape:
						raise ValueError(F"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"     )

				logger.info(F"Initialize PyTorch weight {name} {array.shape}"     )
				SCREAMING_SNAKE_CASE       :     Dict				= torch.from_numpy(__lowercase     )

				tf_weights.pop(__lowercase		,		__lowercase     )
				tf_weights.pop(name + '''/RMSProp'''		,		__lowercase     )
				tf_weights.pop(name + '''/RMSProp_1'''		,		__lowercase     )
				tf_weights.pop(name + '''/ExponentialMovingAverage'''		,		__lowercase     )

		logger.info(F"Weights not copied to PyTorch model: {', '.join(tf_weights.keys()     )}"     )
		return model





def __A						(   a_ :							torch.Tensor		,		a_ :							nn.Convad     )->							Optional[int]:




		'''simple docstring'''






		SCREAMING_SNAKE_CASE       :     str				= features.shape[-2:]
		SCREAMING_SNAKE_CASE       :     str				= conv_layer.stride
		SCREAMING_SNAKE_CASE       :     Tuple				= conv_layer.kernel_size

		if in_height % stride_height == 0:
				SCREAMING_SNAKE_CASE       :     Tuple				= max(kernel_height - stride_height		,		0     )
		else:
				SCREAMING_SNAKE_CASE       :     Union[str, Any]				= max(kernel_height - (in_height % stride_height)		,		0     )

		if in_width % stride_width == 0:
				SCREAMING_SNAKE_CASE       :     Any				= max(kernel_width - stride_width		,		0     )
		else:
				SCREAMING_SNAKE_CASE       :     Union[str, Any]				= max(kernel_width - (in_width % stride_width)		,		0     )

		SCREAMING_SNAKE_CASE       :     List[Any]				= pad_along_width // 2
		SCREAMING_SNAKE_CASE       :     List[str]				= pad_along_width - pad_left
		SCREAMING_SNAKE_CASE       :     Optional[int]				= pad_along_height // 2
		SCREAMING_SNAKE_CASE       :     Union[str, Any]				= pad_along_height - pad_top

		SCREAMING_SNAKE_CASE       :     int				= (pad_left, pad_right, pad_top, pad_bottom)
		return nn.functional.pad(__lowercase		,		__lowercase		,		'''constant'''		,		0.0     )




class 				lowercase__(				nn.Module   ):
	'''simple docstring'''

	def __init__(						self    :int		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Any		, lowerCamelCase_    :Any = 1		, lowerCamelCase_    :int = 1		, lowerCamelCase_    :List[str] = False		, lowerCamelCase_    :Dict = True		, lowerCamelCase_    :Union[str, Any] = True		, )							->			Dict:







			'''simple docstring'''




			super().__init__()
			SCREAMING_SNAKE_CASE       :     Optional[int]				= config

			if in_channels % groups != 0:
					raise ValueError(f"Input channels ({in_channels}) are not divisible by {groups} groups."					)
			if out_channels % groups != 0:
					raise ValueError(f"Output channels ({out_channels}) are not divisible by {groups} groups."					)

			SCREAMING_SNAKE_CASE       :     Tuple				= 0 if config.tf_padding else int((kernel_size - 1) / 2					)

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= nn.Convad(
			    in_channels=lowerCamelCase_		, out_channels=lowerCamelCase_		, kernel_size=lowerCamelCase_		, stride=lowerCamelCase_		, padding=lowerCamelCase_		, groups=lowerCamelCase_		, bias=lowerCamelCase_		, padding_mode='''zeros'''		, )

			if use_normalization:
					SCREAMING_SNAKE_CASE       :     Any				= nn.BatchNormad(
					    num_features=lowerCamelCase_		, eps=config.layer_norm_eps		, momentum=0.9_9_9_7		, affine=lowerCamelCase_		, track_running_stats=lowerCamelCase_		, )
			else:
					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= None

			if use_activation:
					if isinstance(lowerCamelCase_		, lowerCamelCase_					):
							SCREAMING_SNAKE_CASE       :     List[Any]				= ACTaFN[use_activation]
					elif isinstance(config.hidden_act		, lowerCamelCase_					):
							SCREAMING_SNAKE_CASE       :     Optional[int]				= ACTaFN[config.hidden_act]
					else:
							SCREAMING_SNAKE_CASE       :     Optional[int]				= config.hidden_act
			else:
					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= None







	def   __lowerCAmelCase (						self    :Optional[Any]		, lowerCamelCase_    :Tuple					)							->			Dict:







			'''simple docstring'''




			if self.config.tf_padding:
					SCREAMING_SNAKE_CASE       :     List[str]				= apply_tf_padding(lowerCamelCase_		, self.convolution					)
			SCREAMING_SNAKE_CASE       :     List[Any]				= self.convolution(lowerCamelCase_					)
			if self.normalization is not None:
					SCREAMING_SNAKE_CASE       :     List[Any]				= self.normalization(lowerCamelCase_					)
			if self.activation is not None:
					SCREAMING_SNAKE_CASE       :     List[Any]				= self.activation(lowerCamelCase_					)
			return features





class 				lowercase__(				__A   ):
	'''simple docstring'''

	UpperCamelCase				=  MobileNetVaConfig
	UpperCamelCase				=  load_tf_weights_in_mobilenet_va
	UpperCamelCase				=  """mobilenet_v1"""
	UpperCamelCase				=  """pixel_values"""
	UpperCamelCase				=  False





	def   __lowerCAmelCase (						self    :Union[str, Any]		, lowerCamelCase_    :Optional[Any]					)							->			Any:







			'''simple docstring'''




			if isinstance(lowerCamelCase_		, (nn.Linear, nn.Convad)					):
					module.weight.data.normal_(mean=0.0		, std=self.config.initializer_range					)
					if module.bias is not None:
							module.bias.data.zero_()
			elif isinstance(lowerCamelCase_		, nn.BatchNormad					):
					module.bias.data.zero_()
					module.weight.data.fill_(1.0					)





lowerCamelCase__ :       Tuple						     =			r"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`MobileNetV1Config`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"

lowerCamelCase__ :       Optional[int]						     =			r"\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`MobileNetV1ImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"




@add_start_docstrings(
    """The bare MobileNetV1 model outputting raw hidden-states without any specific head on top."""		,						__A		,						)
class 				lowercase__(				__A   ):
	'''simple docstring'''

	def __init__(						self    :Dict		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Union[str, Any] = True					)							->			Any:







			'''simple docstring'''




			super().__init__(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     int				= config

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= 32
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= max(int(depth * config.depth_multiplier					)		, config.min_depth					)

			SCREAMING_SNAKE_CASE       :     int				= MobileNetVaConvLayer(
			    lowerCamelCase_		, in_channels=config.num_channels		, out_channels=lowerCamelCase_		, kernel_size=3		, stride=2		, )

			SCREAMING_SNAKE_CASE       :     Any				= [1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1]

			SCREAMING_SNAKE_CASE       :     Optional[int]				= nn.ModuleList()
			for i in range(13					):
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= out_channels

					if strides[i] == 2 or i == 0:
							depth *= 2
							SCREAMING_SNAKE_CASE       :     Union[str, Any]				= max(int(depth * config.depth_multiplier					)		, config.min_depth					)

					self.layer.append(
					    MobileNetVaConvLayer(
					        lowerCamelCase_		, in_channels=lowerCamelCase_		, out_channels=lowerCamelCase_		, kernel_size=3		, stride=strides[i]		, groups=lowerCamelCase_		, )					)

					self.layer.append(
					    MobileNetVaConvLayer(
					        lowerCamelCase_		, in_channels=lowerCamelCase_		, out_channels=lowerCamelCase_		, kernel_size=1		, )					)

			SCREAMING_SNAKE_CASE       :     Dict				= nn.AdaptiveAvgPoolad((1, 1)					) if add_pooling_layer else None

			# Initialize weights and apply final processing
			self.post_init()





	def   __lowerCAmelCase (						self    :Tuple		, lowerCamelCase_    :Optional[int]					)							->			Tuple:







			'''simple docstring'''




			raise NotImplementedError







	@add_start_docstrings_to_model_forward(lowerCamelCase_					)
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC		, output_type=lowerCamelCase_		, config_class=_CONFIG_FOR_DOC		, modality='''vision'''		, expected_output=_EXPECTED_OUTPUT_SHAPE		, )
	def   __lowerCAmelCase (						self    :Optional[int]		, lowerCamelCase_    :str = None		, lowerCamelCase_    :Tuple = None		, lowerCamelCase_    :Any = None		, )							->			Tuple:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= (
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			SCREAMING_SNAKE_CASE       :     Tuple				= return_dict if return_dict is not None else self.config.use_return_dict

			if pixel_values is None:
					raise ValueError('''You have to specify pixel_values'''					)

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= self.conv_stem(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Tuple				= () if output_hidden_states else None

			for i, layer_module in enumerate(self.layer					):
					SCREAMING_SNAKE_CASE       :     int				= layer_module(lowerCamelCase_					)

					if output_hidden_states:
							SCREAMING_SNAKE_CASE       :     str				= all_hidden_states + (hidden_states,)

			SCREAMING_SNAKE_CASE       :     List[Any]				= hidden_states

			if self.pooler is not None:
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= torch.flatten(self.pooler(lowerCamelCase_					)		, start_dim=1					)
			else:
					SCREAMING_SNAKE_CASE       :     Any				= None

			if not return_dict:
					return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None					)

			return BaseModelOutputWithPoolingAndNoAttention(
			    last_hidden_state=lowerCamelCase_		, pooler_output=lowerCamelCase_		, hidden_states=lowerCamelCase_		, )





@add_start_docstrings(
    """
    MobileNetV1 model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """		,						__A		,						)
class 				lowercase__(				__A   ):
	'''simple docstring'''

	def __init__(						self    :Any		, lowerCamelCase_    :Optional[int]					)							->			List[Any]:







			'''simple docstring'''




			super().__init__(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     int				= config.num_labels
			SCREAMING_SNAKE_CASE       :     Tuple				= MobileNetVaModel(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Optional[int]				= self.mobilenet_va.layer[-1].convolution.out_channels

			# Classifier head
			SCREAMING_SNAKE_CASE       :     Tuple				= nn.Dropout(config.classifier_dropout_prob		, inplace=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Optional[int]				= nn.Linear(lowerCamelCase_		, config.num_labels					) if config.num_labels > 0 else nn.Identity()

			# Initialize weights and apply final processing
			self.post_init()







	@add_start_docstrings_to_model_forward(lowerCamelCase_					)
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT		, output_type=lowerCamelCase_		, config_class=_CONFIG_FOR_DOC		, expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		, )
	def   __lowerCAmelCase (						self    :Tuple		, lowerCamelCase_    :List[Any] = None		, lowerCamelCase_    :Dict = None		, lowerCamelCase_    :Any = None		, lowerCamelCase_    :Dict = None		, )							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= return_dict if return_dict is not None else self.config.use_return_dict

			SCREAMING_SNAKE_CASE       :     Any				= self.mobilenet_va(lowerCamelCase_		, output_hidden_states=lowerCamelCase_		, return_dict=lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Any				= outputs.pooler_output if return_dict else outputs[1]

			SCREAMING_SNAKE_CASE       :     Any				= self.classifier(self.dropout(lowerCamelCase_					)					)

			SCREAMING_SNAKE_CASE       :     List[Any]				= None
			if labels is not None:
					if self.config.problem_type is None:
							if self.num_labels == 1:
									SCREAMING_SNAKE_CASE       :     int				= 'regression'
							elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
									SCREAMING_SNAKE_CASE       :     Any				= 'single_label_classification'
							else:
									SCREAMING_SNAKE_CASE       :     Any				= 'multi_label_classification'

					if self.config.problem_type == "regression":
							SCREAMING_SNAKE_CASE       :     Tuple				= MSELoss()
							if self.num_labels == 1:
									SCREAMING_SNAKE_CASE       :     Dict				= loss_fct(logits.squeeze()		, labels.squeeze()					)
							else:
									SCREAMING_SNAKE_CASE       :     List[str]				= loss_fct(lowerCamelCase_		, lowerCamelCase_					)
					elif self.config.problem_type == "single_label_classification":
							SCREAMING_SNAKE_CASE       :     Any				= CrossEntropyLoss()
							SCREAMING_SNAKE_CASE       :     Optional[Any]				= loss_fct(logits.view(-1		, self.num_labels					)		, labels.view(-1					)					)
					elif self.config.problem_type == "multi_label_classification":
							SCREAMING_SNAKE_CASE       :     Dict				= BCEWithLogitsLoss()
							SCREAMING_SNAKE_CASE       :     List[str]				= loss_fct(lowerCamelCase_		, lowerCamelCase_					)

			if not return_dict:
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= (logits,) + outputs[2:]
					return ((loss,) + output) if loss is not None else output

			return ImageClassifierOutputWithNoAttention(
			    loss=lowerCamelCase_		, logits=lowerCamelCase_		, hidden_states=outputs.hidden_states		, )







"""simple docstring"""






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


lowerCamelCase__ :       Tuple						     =			logging.get_logger(__name__)

lowerCamelCase__ :       str						     =			{
    "studio-ousia/luke-base": "https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json",
    "studio-ousia/luke-large": "https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json",
}




class 				lowercase__(				_UpperCAmelCase   ):
	'''simple docstring'''

	UpperCamelCase				=  """luke"""





	def __init__(						self    :Optional[int]		, lowerCamelCase_    :Union[str, Any]=5_02_67		, lowerCamelCase_    :int=50_00_00		, lowerCamelCase_    :Tuple=7_68		, lowerCamelCase_    :List[str]=2_56		, lowerCamelCase_    :Dict=12		, lowerCamelCase_    :Optional[int]=12		, lowerCamelCase_    :Optional[Any]=30_72		, lowerCamelCase_    :List[Any]="gelu"		, lowerCamelCase_    :Any=0.1		, lowerCamelCase_    :Union[str, Any]=0.1		, lowerCamelCase_    :List[str]=5_12		, lowerCamelCase_    :Optional[int]=2		, lowerCamelCase_    :Tuple=0.0_2		, lowerCamelCase_    :Optional[int]=1E-12		, lowerCamelCase_    :List[Any]=True		, lowerCamelCase_    :List[str]=None		, lowerCamelCase_    :str=1		, lowerCamelCase_    :Any=0		, lowerCamelCase_    :str=2		, **lowerCamelCase_    :List[Any]		, )							->			Optional[int]:







			'''simple docstring'''




			super().__init__(pad_token_id=lowerCamelCase_		, bos_token_id=lowerCamelCase_		, eos_token_id=lowerCamelCase_		, **lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Dict				= vocab_size
			SCREAMING_SNAKE_CASE       :     List[str]				= entity_vocab_size
			SCREAMING_SNAKE_CASE       :     str				= hidden_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= entity_emb_size
			SCREAMING_SNAKE_CASE       :     List[Any]				= num_hidden_layers
			SCREAMING_SNAKE_CASE       :     Optional[int]				= num_attention_heads
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= hidden_act
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= intermediate_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= hidden_dropout_prob
			SCREAMING_SNAKE_CASE       :     Dict				= attention_probs_dropout_prob
			SCREAMING_SNAKE_CASE       :     Dict				= max_position_embeddings
			SCREAMING_SNAKE_CASE       :     Tuple				= type_vocab_size
			SCREAMING_SNAKE_CASE       :     str				= initializer_range
			SCREAMING_SNAKE_CASE       :     Dict				= layer_norm_eps
			SCREAMING_SNAKE_CASE       :     Optional[int]				= use_entity_aware_attention
			SCREAMING_SNAKE_CASE       :     List[str]				= classifier_dropout





