






'''simple docstring'''




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__          =						logging.get_logger(__name__)


# General docstring
lowerCAmelCase__          =						'MobileNetV1Config'

# Base docstring
lowerCAmelCase__          =						'google/mobilenet_v1_1.0_224'
lowerCAmelCase__          =						[1, 1024, 7, 7]

# Image classification docstring
lowerCAmelCase__          =						'google/mobilenet_v1_1.0_224'
lowerCAmelCase__          =						'tabby, tabby cat'


lowerCAmelCase__          =						[
    '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       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_=None)							->     Optional[Any]:
		UpperCamelCase__				:					int					=					{}

		if isinstance(lowerCamelCase_     ,      lowerCamelCase_):
				UpperCamelCase__				:					Tuple					=					model.mobilenet_va
		else:
				UpperCamelCase__				:					str					=					model

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

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

				UpperCamelCase__				:					List[Any]					=					backbone.layer[pt_index]
				UpperCamelCase__				:					List[Any]					=					f'MobilenetV1/Conv2d_{tf_index}_depthwise/'
				UpperCamelCase__				:					Union[str, Any]					=					pointer.convolution.weight
				UpperCamelCase__				:					Dict					=					pointer.normalization.bias
				UpperCamelCase__				:					Tuple					=					pointer.normalization.weight
				UpperCamelCase__				:					int					=					pointer.normalization.running_mean
				UpperCamelCase__				:					List[Any]					=					pointer.normalization.running_var

				UpperCamelCase__				:					Optional[Any]					=					backbone.layer[pt_index + 1]
				UpperCamelCase__				:					Dict					=					f'MobilenetV1/Conv2d_{tf_index}_pointwise/'
				UpperCamelCase__				:					Any					=					pointer.convolution.weight
				UpperCamelCase__				:					Dict					=					pointer.normalization.bias
				UpperCamelCase__				:					Optional[int]					=					pointer.normalization.weight
				UpperCamelCase__				:					int					=					pointer.normalization.running_mean
				UpperCamelCase__				:					Dict					=					pointer.normalization.running_var

		if isinstance(lowerCamelCase_     ,      lowerCamelCase_):
				UpperCamelCase__				:					Optional[Any]					=					'''MobilenetV1/Logits/Conv2d_1c_1x1/'''
				UpperCamelCase__				:					Optional[int]					=					model.classifier.weight
				UpperCamelCase__				:					Optional[int]					=					model.classifier.bias

		return tf_to_pt_map







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

		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
		UpperCamelCase__				:					str					=					tf.train.list_variables(lowerCamelCase_)
		UpperCamelCase__				:					Union[str, Any]					=					{}
		for name, shape in init_vars:
				logger.info(f'Loading TF weight {name} with shape {shape}')
				UpperCamelCase__				:					Optional[Any]					=					tf.train.load_variable(lowerCamelCase_     ,      lowerCamelCase_)
				UpperCamelCase__				:					Union[str, Any]					=					array

		# Build TF to PyTorch weights loading map
		UpperCamelCase__				:					List[str]					=					_build_tf_to_pytorch_map(lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_)

		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

				UpperCamelCase__				:					Dict					=					tf_weights[name]

				if "depthwise_weights" in name:
						logger.info('Transposing depthwise')
						UpperCamelCase__				:					List[str]					=					np.transpose(lowerCamelCase_     ,      (2, 3, 0, 1))
				elif "weights" in name:
						logger.info('Transposing')
						if len(pointer.shape) == 2:  # copying into linear layer
								UpperCamelCase__				:					Any					=					array.squeeze().transpose()
						else:
								UpperCamelCase__				:					Optional[Any]					=					np.transpose(lowerCamelCase_     ,      (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}')
				UpperCamelCase__				:					Optional[int]					=					torch.from_numpy(lowerCamelCase_)

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

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







def       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_)							->     Tuple:
		UpperCamelCase__				:					List[str]					=					features.shape[-2:]
		UpperCamelCase__				:					List[str]					=					conv_layer.stride
		UpperCamelCase__				:					Tuple					=					conv_layer.kernel_size

		if in_height % stride_height == 0:
				UpperCamelCase__				:					List[Any]					=					max(kernel_height - stride_height     ,      0)
		else:
				UpperCamelCase__				:					List[Any]					=					max(kernel_height - (in_height % stride_height)     ,      0)

		if in_width % stride_width == 0:
				UpperCamelCase__				:					str					=					max(kernel_width - stride_width     ,      0)
		else:
				UpperCamelCase__				:					Dict					=					max(kernel_width - (in_width % stride_width)     ,      0)

		UpperCamelCase__				:					Union[str, Any]					=					pad_along_width // 2
		UpperCamelCase__				:					List[str]					=					pad_along_width - pad_left
		UpperCamelCase__				:					Union[str, Any]					=					pad_along_height // 2
		UpperCamelCase__				:					Tuple					=					pad_along_height - pad_top

		UpperCamelCase__				:					str					=					(pad_left, pad_right, pad_top, pad_bottom)
		return nn.functional.pad(lowerCamelCase_     ,      lowerCamelCase_     ,      'constant'     ,      0.0)







class       __lowercase					(nn.Module    ):

	def __init__(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						Dict  ,					UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						Any  ,					UpperCAmelCase_   :						Dict  ,					UpperCAmelCase_   :						List[str] = 1  ,					UpperCAmelCase_   :						Optional[Any] = 1  ,					UpperCAmelCase_   :						List[str] = False  ,					UpperCAmelCase_   :						str = True  ,					UpperCAmelCase_   :						Tuple = True  ,					):
			super().__init__()
			UpperCamelCase__				:					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.')

			UpperCamelCase__				:					Union[str, Any]					=					0 if config.tf_padding else int((kernel_size - 1) / 2)

			UpperCamelCase__				:					List[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:
					UpperCamelCase__				:					Optional[int]					=					nn.BatchNormad(
					    num_features=__lowerCamelCase  ,					eps=config.layer_norm_eps  ,					momentum=0.99_97  ,					affine=__lowerCamelCase  ,					track_running_stats=__lowerCamelCase  ,					)
			else:
					UpperCamelCase__				:					List[str]					=					None

			if use_activation:
					if isinstance(__lowerCamelCase  ,					__lowerCamelCase):
							UpperCamelCase__				:					Any					=					ACTaFN[use_activation]
					elif isinstance(config.hidden_act  ,					__lowerCamelCase):
							UpperCamelCase__				:					Dict					=					ACTaFN[config.hidden_act]
					else:
							UpperCamelCase__				:					Optional[int]					=					config.hidden_act
			else:
					UpperCamelCase__				:					Union[str, Any]					=					None





	def      __UpperCamelCase							(      self   :						Dict  ,					UpperCAmelCase_   :						List[str]):






			if self.config.tf_padding:
					UpperCamelCase__				:					int					=					apply_tf_padding(__lowerCamelCase  ,					self.convolution)
			UpperCamelCase__				:					List[Any]					=					self.convolution(__lowerCamelCase)
			if self.normalization is not None:
					UpperCamelCase__				:					Optional[int]					=					self.normalization(__lowerCamelCase)
			if self.activation is not None:
					UpperCamelCase__				:					Any					=					self.activation(__lowerCamelCase)
			return features







class       __lowercase					(lowerCamelCase__    ):
	_lowerCamelCase              =  MobileNetVaConfig
	_lowerCamelCase              =  load_tf_weights_in_mobilenet_va
	_lowerCamelCase              =  '''mobilenet_v1'''
	_lowerCamelCase              =  '''pixel_values'''
	_lowerCamelCase              =  False

	def      __UpperCamelCase							(      self   :						Optional[Any]  ,					UpperCAmelCase_   :						List[Any]):






			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__          =						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__          =						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.'''   ,				lowerCamelCase__   ,				)
class       __lowercase					(lowerCamelCase__    ):

	def __init__(      self   :						Optional[Any]  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						Optional[int] = True):
			super().__init__(__lowerCamelCase)
			UpperCamelCase__				:					str					=					config

			UpperCamelCase__				:					List[Any]					=					32
			UpperCamelCase__				:					Dict					=					max(int(depth * config.depth_multiplier)  ,					config.min_depth)

			UpperCamelCase__				:					List[Any]					=					MobileNetVaConvLayer(
			    __lowerCamelCase  ,					in_channels=config.num_channels  ,					out_channels=__lowerCamelCase  ,					kernel_size=3  ,					stride=2  ,					)

			UpperCamelCase__				:					Tuple					=					[1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1]

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

					if strides[i] == 2 or i == 0:
							depth *= 2
							UpperCamelCase__				:					Optional[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  ,					))

			UpperCamelCase__				:					Optional[int]					=					nn.AdaptiveAvgPoolad((1, 1)) if add_pooling_layer else None

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

	def      __UpperCamelCase							(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						Optional[Any]):
			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      __UpperCamelCase							(      self   :						int  ,					UpperCAmelCase_   :						Tuple = None  ,					UpperCAmelCase_   :						Union[str, Any] = None  ,					UpperCAmelCase_   :						List[str] = None  ,					):
			UpperCamelCase__				:					str					=					(
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			UpperCamelCase__				:					Any					=					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')

			UpperCamelCase__				:					Any					=					self.conv_stem(__lowerCamelCase)

			UpperCamelCase__				:					int					=					() if output_hidden_states else None

			for i, layer_module in enumerate(self.layer):
					UpperCamelCase__				:					Any					=					layer_module(__lowerCamelCase)

					if output_hidden_states:
							UpperCamelCase__				:					Union[str, Any]					=					all_hidden_states + (hidden_states,)

			UpperCamelCase__				:					List[str]					=					hidden_states

			if self.pooler is not None:
					UpperCamelCase__				:					List[Any]					=					torch.flatten(self.pooler(__lowerCamelCase)  ,					start_dim=1)
			else:
					UpperCamelCase__				:					int					=					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.
    '''   ,				lowerCamelCase__   ,				)
class       __lowercase					(lowerCamelCase__    ):

	def __init__(      self   :						Optional[Any]  ,					UpperCAmelCase_   :						str):
			super().__init__(__lowerCamelCase)

			UpperCamelCase__				:					List[str]					=					config.num_labels
			UpperCamelCase__				:					Optional[Any]					=					MobileNetVaModel(__lowerCamelCase)

			UpperCamelCase__				:					Tuple					=					self.mobilenet_va.layer[-1].convolution.out_channels

			# Classifier head
			UpperCamelCase__				:					Any					=					nn.Dropout(config.classifier_dropout_prob  ,					inplace=__lowerCamelCase)
			UpperCamelCase__				:					Dict					=					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      __UpperCamelCase							(      self   :						List[str]  ,					UpperCAmelCase_   :						Optional[int] = None  ,					UpperCAmelCase_   :						Optional[Any] = None  ,					UpperCAmelCase_   :						Optional[Any] = None  ,					UpperCAmelCase_   :						Dict = None  ,					):
			UpperCamelCase__				:					Union[str, Any]					=					return_dict if return_dict is not None else self.config.use_return_dict

			UpperCamelCase__				:					Dict					=					self.mobilenet_va(__lowerCamelCase  ,					output_hidden_states=__lowerCamelCase  ,					return_dict=__lowerCamelCase)

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

			UpperCamelCase__				:					Optional[int]					=					self.classifier(self.dropout(__lowerCamelCase))

			UpperCamelCase__				:					Tuple					=					None
			if labels is not None:
					if self.config.problem_type is None:
							if self.num_labels == 1:
									UpperCamelCase__				:					Union[str, Any]					=					'''regression'''
							elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
									UpperCamelCase__				:					Optional[int]					=					'''single_label_classification'''
							else:
									UpperCamelCase__				:					Dict					=					'''multi_label_classification'''

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

			if not return_dict:
					UpperCamelCase__				:					str					=					(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'''




import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

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


lowerCAmelCase__          =						logging.get_logger(__name__)

lowerCAmelCase__          =						{
    'nvidia/segformer-b0-finetuned-ade-512-512': (
        'https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json'
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}







class       __lowercase					(__lowerCamelCase    ):
	_lowerCamelCase              =  '''segformer'''

	def __init__(      self   :						Tuple  ,					UpperCAmelCase_   :						Optional[Any]=3  ,					UpperCAmelCase_   :						Optional[int]=4  ,					UpperCAmelCase_   :						Tuple=[2, 2, 2, 2]  ,					UpperCAmelCase_   :						List[str]=[8, 4, 2, 1]  ,					UpperCAmelCase_   :						Union[str, Any]=[32, 64, 160, 256]  ,					UpperCAmelCase_   :						Any=[7, 3, 3, 3]  ,					UpperCAmelCase_   :						Any=[4, 2, 2, 2]  ,					UpperCAmelCase_   :						Union[str, Any]=[1, 2, 5, 8]  ,					UpperCAmelCase_   :						Tuple=[4, 4, 4, 4]  ,					UpperCAmelCase_   :						str="gelu"  ,					UpperCAmelCase_   :						List[Any]=0.0  ,					UpperCAmelCase_   :						int=0.0  ,					UpperCAmelCase_   :						int=0.1  ,					UpperCAmelCase_   :						List[str]=0.02  ,					UpperCAmelCase_   :						Dict=0.1  ,					UpperCAmelCase_   :						Dict=1e-6  ,					UpperCAmelCase_   :						int=256  ,					UpperCAmelCase_   :						Optional[int]=255  ,					**UpperCAmelCase_   :						Tuple  ,					):
			super().__init__(**UpperCAmelCase_)

			if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
					warnings.warn(
					    'Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be'
					    ' removed, as the behaviour will default to that of reshape_last_stage = True.'  ,					UpperCAmelCase_  ,					)

			UpperCamelCase__				:					List[Any]					=					num_channels
			UpperCamelCase__				:					Any					=					num_encoder_blocks
			UpperCamelCase__				:					Dict					=					depths
			UpperCamelCase__				:					int					=					sr_ratios
			UpperCamelCase__				:					str					=					hidden_sizes
			UpperCamelCase__				:					List[str]					=					patch_sizes
			UpperCamelCase__				:					Optional[int]					=					strides
			UpperCamelCase__				:					Dict					=					mlp_ratios
			UpperCamelCase__				:					List[str]					=					num_attention_heads
			UpperCamelCase__				:					int					=					hidden_act
			UpperCamelCase__				:					Any					=					hidden_dropout_prob
			UpperCamelCase__				:					str					=					attention_probs_dropout_prob
			UpperCamelCase__				:					List[str]					=					classifier_dropout_prob
			UpperCamelCase__				:					List[Any]					=					initializer_range
			UpperCamelCase__				:					Union[str, Any]					=					drop_path_rate
			UpperCamelCase__				:					int					=					layer_norm_eps
			UpperCamelCase__				:					Dict					=					decoder_hidden_size
			UpperCamelCase__				:					List[Any]					=					kwargs.get('reshape_last_stage'  ,					UpperCAmelCase_)
			UpperCamelCase__				:					List[str]					=					semantic_loss_ignore_index







class       __lowercase					(__lowerCamelCase    ):
	_lowerCamelCase              =  version.parse('''1.11'''    )

	@property
	def      __UpperCamelCase							(      self   :						Optional[Any]):
			return OrderedDict(
			    [
			        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
			    ])

	@property
	def      __UpperCamelCase							(      self   :						Optional[Any]):
			return 1e-4





	@property
	def      __UpperCamelCase							(      self   :						Any):
			return 12




