





'''simple docstring'''






from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
						from PIL import Image

						from transformers import ViTImageProcessor







class 		UpperCAmelCase   :


		"""simple docstring"""







		def __init__(				self    :					Optional[Any]							,	UpperCamelCase__    :					Dict							,	UpperCamelCase__    :					List[Any]=13							,	UpperCamelCase__    :					Tuple=30							,	UpperCamelCase__    :					List[str]=2							,	UpperCamelCase__    :					Optional[Any]=3							,	UpperCamelCase__    :					Optional[int]=True							,	UpperCamelCase__    :					Any=True							,	UpperCamelCase__    :					Union[str, Any]=32							,	UpperCamelCase__    :					Union[str, Any]=2							,	UpperCamelCase__    :					Dict=4							,	UpperCamelCase__    :					Optional[int]=37							,	UpperCamelCase__    :					Tuple="gelu"							,	UpperCamelCase__    :					Tuple=0.1							,	UpperCamelCase__    :					Union[str, Any]=0.1							,	UpperCamelCase__    :					List[Any]=10							,	UpperCamelCase__    :					str=0.02							,	UpperCamelCase__    :					Union[str, Any]=3							,	UpperCamelCase__    :					Optional[Any]=0.6							,	UpperCamelCase__    :					Union[str, Any]=None							,	)     ->						List[Any]:
				_UpperCamelCase       			=parent
				_UpperCamelCase       			=batch_size
				_UpperCamelCase       			=image_size
				_UpperCamelCase       			=patch_size
				_UpperCamelCase       			=num_channels
				_UpperCamelCase       			=is_training
				_UpperCamelCase       			=use_labels
				_UpperCamelCase       			=hidden_size
				_UpperCamelCase       			=num_hidden_layers
				_UpperCamelCase       			=num_attention_heads
				_UpperCamelCase       			=intermediate_size
				_UpperCamelCase       			=hidden_act
				_UpperCamelCase       			=hidden_dropout_prob
				_UpperCamelCase       			=attention_probs_dropout_prob
				_UpperCamelCase       			=type_sequence_label_size
				_UpperCamelCase       			=initializer_range
				_UpperCamelCase       			=mask_ratio
				_UpperCamelCase       			=scope

				# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
				# (we add 1 for the [CLS] token)
				_UpperCamelCase       			=(image_size // patch_size) ** 2
				_UpperCamelCase       			=int(math.ceil((1 - mask_ratio) * (num_patches + 1)  )  )


		def   UpperCamelCase__      (				self    :					Any  )     ->						int:
				_UpperCamelCase       			=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

				_UpperCamelCase       			=None
				if self.use_labels:
						_UpperCamelCase       			=ids_tensor([self.batch_size]							,	self.type_sequence_label_size  )

				_UpperCamelCase       			=self.get_config()

				return config, pixel_values, labels


		def   UpperCamelCase__      (				self    :					Dict  )     ->						Optional[Any]:
				return ViTMAEConfig(
				    image_size=self.image_size							,	patch_size=self.patch_size							,	num_channels=self.num_channels							,	hidden_size=self.hidden_size							,	num_hidden_layers=self.num_hidden_layers							,	num_attention_heads=self.num_attention_heads							,	intermediate_size=self.intermediate_size							,	decoder_hidden_size=self.hidden_size							,	decoder_num_hidden_layers=self.num_hidden_layers							,	decoder_num_attention_heads=self.num_attention_heads							,	decoder_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							,	is_decoder=UpperCamelCase__							,	initializer_range=self.initializer_range							,	mask_ratio=self.mask_ratio							,	)


		def   UpperCamelCase__      (				self    :					Optional[int]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					Tuple							,	UpperCamelCase__    :					Dict  )     ->						Optional[Any]:
				_UpperCamelCase       			=TFViTMAEModel(config=UpperCamelCase__  )
				_UpperCamelCase       			=model(UpperCamelCase__							,	training=UpperCamelCase__  )
				self.parent.assertEqual(result.last_hidden_state.shape							,	(self.batch_size, self.seq_length, self.hidden_size)  )


		def   UpperCamelCase__      (				self    :					Any							,	UpperCamelCase__    :					Optional[Any]							,	UpperCamelCase__    :					str							,	UpperCamelCase__    :					List[str]  )     ->						Tuple:
				_UpperCamelCase       			=TFViTMAEForPreTraining(UpperCamelCase__  )
				_UpperCamelCase       			=model(UpperCamelCase__							,	training=UpperCamelCase__  )
				# expected sequence length = num_patches
				_UpperCamelCase       			=(self.image_size // self.patch_size) ** 2
				_UpperCamelCase       			=self.patch_size**2 * self.num_channels
				self.parent.assertEqual(result.logits.shape							,	(self.batch_size, num_patches, expected_num_channels)  )

				# test greyscale images
				_UpperCamelCase       			=1
				_UpperCamelCase       			=TFViTMAEForPreTraining(UpperCamelCase__  )

				_UpperCamelCase       			=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
				_UpperCamelCase       			=model(UpperCamelCase__							,	training=UpperCamelCase__  )
				_UpperCamelCase       			=self.patch_size**2
				self.parent.assertEqual(result.logits.shape							,	(self.batch_size, num_patches, expected_num_channels)  )




		def   UpperCamelCase__      (				self    :					str  )     ->						Any:
				_UpperCamelCase       			=self.prepare_config_and_inputs()
				((_UpperCamelCase)			,     (_UpperCamelCase)			,     (_UpperCamelCase))       			=config_and_inputs
				_UpperCamelCase       			={'''pixel_values''': pixel_values}
				return config, inputs_dict







@require_tf
class 		UpperCAmelCase   (				lowercase_   ,     lowercase_   ,     unittest.TestCase):


		"""simple docstring"""







		lowerCAmelCase_					=				(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
		lowerCAmelCase_					=				{"""feature-extraction""": TFViTMAEModel} if is_tf_available() else {}

		lowerCAmelCase_					=				False
		lowerCAmelCase_					=				False
		lowerCAmelCase_					=				False
		lowerCAmelCase_					=				False


		def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Tuple:
				_UpperCamelCase       			=TFViTMAEModelTester(self  )
				_UpperCamelCase       			=ConfigTester(self							,	config_class=UpperCamelCase__							,	has_text_modality=UpperCamelCase__							,	hidden_size=37  )


		def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						int:
				self.config_tester.run_common_tests()


		@unittest.skip(reason='''ViTMAE does not use inputs_embeds'''  )
		def   UpperCamelCase__      (				self    :					Tuple  )     ->						List[str]:
				pass


		def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						Dict:
				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )
						self.assertIsInstance(model.get_input_embeddings()							,	(tf.keras.layers.Layer)  )
						_UpperCamelCase       			=model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(UpperCamelCase__							,	tf.keras.layers.Layer  )  )


		def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Optional[int]:
				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )
						_UpperCamelCase       			=inspect.signature(model.call  )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						_UpperCamelCase       			=[*signature.parameters.keys()]

						_UpperCamelCase       			=['''pixel_values''']
						self.assertListEqual(arg_names[:1]							,	UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					Any  )     ->						Optional[int]:
				_UpperCamelCase       			=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					int  )     ->						List[Any]:
				_UpperCamelCase       			=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					Tuple  )     ->						int:
				# make the mask reproducible
				np.random.seed(2  )

				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCamelCase       			=int((config.image_size // config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )
						_UpperCamelCase       			=self._prepare_for_class(UpperCamelCase__							,	UpperCamelCase__  )

						_UpperCamelCase       			=model(UpperCamelCase__							,	noise=UpperCamelCase__  )

						_UpperCamelCase       			=copy.deepcopy(self._prepare_for_class(UpperCamelCase__							,	UpperCamelCase__  )  )
						_UpperCamelCase       			=model(**UpperCamelCase__							,	noise=UpperCamelCase__  )
						_UpperCamelCase       			=outputs_dict[0].numpy()
						_UpperCamelCase       			=outputs_keywords[0].numpy()

						self.assertLess(np.sum(np.abs(output_dict - output_keywords  )  )							,	1E-6  )


		def   UpperCamelCase__      (				self    :					int  )     ->						Any:
				# make the mask reproducible
				np.random.seed(2  )

				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCamelCase       			=int((config.image_size // config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

				def prepare_numpy_arrays(UpperCamelCase__    :					int  ):
						_UpperCamelCase       			={}
						for k, v in inputs_dict.items():
								if tf.is_tensor(UpperCamelCase__  ):
										_UpperCamelCase       			=v.numpy()
								else:
										_UpperCamelCase       			=np.array(UpperCamelCase__  )

						return inputs_np_dict

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )

						_UpperCamelCase       			=self._prepare_for_class(UpperCamelCase__							,	UpperCamelCase__  )
						_UpperCamelCase       			=prepare_numpy_arrays(UpperCamelCase__  )

						_UpperCamelCase       			=model(UpperCamelCase__							,	noise=UpperCamelCase__  )
						_UpperCamelCase       			=model(**UpperCamelCase__							,	noise=UpperCamelCase__  )
						self.assert_outputs_same(UpperCamelCase__							,	UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					Union[str, Any]							,	UpperCamelCase__    :					int							,	UpperCamelCase__    :					List[str]							,	UpperCamelCase__    :					List[Any]  )     ->						str:
				# make masks reproducible
				np.random.seed(2  )

				_UpperCamelCase       			=int((tf_model.config.image_size // tf_model.config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
				_UpperCamelCase       			=tf.constant(UpperCamelCase__  )

				# Add `noise` argument.
				# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
				_UpperCamelCase       			=tf_noise

				super().check_pt_tf_models(UpperCamelCase__							,	UpperCamelCase__							,	UpperCamelCase__  )


		def   UpperCamelCase__      (				self    :					Dict  )     ->						Optional[int]:
				# make mask reproducible
				np.random.seed(2  )

				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCamelCase       			={
				    module_member
				    for model_class in self.all_model_classes
				    for module in (import_module(model_class.__module__  ),)
				    for module_member_name in dir(UpperCamelCase__  )
				    if module_member_name.endswith('''MainLayer'''  )
				    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
				    and module_member_name[: -len('''MainLayer'''  )] == model_class.__name__[: -len('''Model'''  )]
				    for module_member in (getattr(UpperCamelCase__							,	UpperCamelCase__  ),)
				    if isinstance(UpperCamelCase__							,	UpperCamelCase__  )
				    and tf.keras.layers.Layer in module_member.__bases__
				    and getattr(UpperCamelCase__							,	'''_keras_serializable'''							,	UpperCamelCase__  )
				}

				_UpperCamelCase       			=int((config.image_size // config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
				_UpperCamelCase       			=tf.convert_to_tensor(UpperCamelCase__  )
				inputs_dict.update({'''noise''': noise}  )

				for main_layer_class in tf_main_layer_classes:
						_UpperCamelCase       			=main_layer_class(UpperCamelCase__  )

						_UpperCamelCase       			={
						    name: tf.keras.Input(tensor.shape[1:]							,	dtype=tensor.dtype  ) for name, tensor in inputs_dict.items()
						}

						_UpperCamelCase       			=tf.keras.Model(UpperCamelCase__							,	outputs=main_layer(UpperCamelCase__  )  )
						_UpperCamelCase       			=model(UpperCamelCase__  )

						with tempfile.TemporaryDirectory() as tmpdirname:
								_UpperCamelCase       			=os.path.join(UpperCamelCase__							,	'''keras_model.h5'''  )
								model.save(UpperCamelCase__  )
								_UpperCamelCase       			=tf.keras.models.load_model(
								    UpperCamelCase__							,	custom_objects={main_layer_class.__name__: main_layer_class}  )
								assert isinstance(UpperCamelCase__							,	tf.keras.Model  )
								_UpperCamelCase       			=model(UpperCamelCase__  )
								self.assert_outputs_same(UpperCamelCase__							,	UpperCamelCase__  )


		@slow
		def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Tuple:
				# make mask reproducible
				np.random.seed(2  )

				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCamelCase       			=int((config.image_size // config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )
						_UpperCamelCase       			=self._prepare_for_class(UpperCamelCase__							,	UpperCamelCase__  )
						_UpperCamelCase       			=model(UpperCamelCase__							,	noise=UpperCamelCase__  )

						if model_class.__name__ == "TFViTMAEModel":
								_UpperCamelCase       			=outputs.last_hidden_state.numpy()
								_UpperCamelCase       			=0
						else:
								_UpperCamelCase       			=outputs.logits.numpy()
								_UpperCamelCase       			=0

						with tempfile.TemporaryDirectory() as tmpdirname:
								model.save_pretrained(UpperCamelCase__							,	saved_model=UpperCamelCase__  )
								_UpperCamelCase       			=model_class.from_pretrained(UpperCamelCase__  )
								_UpperCamelCase       			=model(UpperCamelCase__							,	noise=UpperCamelCase__  )

								if model_class.__name__ == "TFViTMAEModel":
										_UpperCamelCase       			=after_outputs['''last_hidden_state'''].numpy()
										_UpperCamelCase       			=0
								else:
										_UpperCamelCase       			=after_outputs['''logits'''].numpy()
										_UpperCamelCase       			=0

								_UpperCamelCase       			=np.amax(np.abs(out_a - out_a  )  )
								self.assertLessEqual(UpperCamelCase__							,	1E-5  )


		def   UpperCamelCase__      (				self    :					Tuple  )     ->						Any:
				# make mask reproducible
				np.random.seed(2  )

				_UpperCamelCase			,     _UpperCamelCase       			=self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCamelCase       			=int((config.image_size // config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )

				for model_class in self.all_model_classes:
						_UpperCamelCase       			=model_class(UpperCamelCase__  )
						_UpperCamelCase       			=self._prepare_for_class(UpperCamelCase__							,	UpperCamelCase__  )

						_UpperCamelCase       			=model(UpperCamelCase__							,	noise=UpperCamelCase__  )
						_UpperCamelCase       			=model.get_config()
						# make sure that returned config is jsonifiable, which is required by keras
						json.dumps(UpperCamelCase__  )
						_UpperCamelCase       			=model_class.from_config(model.get_config()  )
						# make sure it also accepts a normal config
						_UpperCamelCase       			=model_class.from_config(model.config  )
						_UpperCamelCase       			=new_model(UpperCamelCase__  )  # Build model
						new_model.set_weights(model.get_weights()  )
						_UpperCamelCase       			=new_model(UpperCamelCase__							,	noise=UpperCamelCase__  )

						self.assert_outputs_same(UpperCamelCase__							,	UpperCamelCase__  )


		@unittest.skip(
		    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''  )
		def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Any:
				pass


		@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''  )
		def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						Union[str, Any]:
				pass




		@slow
		def   UpperCamelCase__      (				self    :					Any  )     ->						List[str]:
				_UpperCamelCase       			=TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''  )
				self.assertIsNotNone(UpperCamelCase__  )




def 					_a   ():


		"""simple docstring"""

		_UpperCamelCase       			=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
		return image







@require_tf
@require_vision
class 		UpperCAmelCase   (				unittest.TestCase):


		"""simple docstring"""







		@cached_property
		def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						Tuple:
				return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''  ) if is_vision_available() else None




		@slow
		def   UpperCamelCase__      (				self    :					Dict  )     ->						int:
				# make random mask reproducible across the PT and TF model
				np.random.seed(2  )

				_UpperCamelCase       			=TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''  )

				_UpperCamelCase       			=self.default_image_processor
				_UpperCamelCase       			=prepare_img()
				_UpperCamelCase       			=image_processor(images=UpperCamelCase__							,	return_tensors='''tf'''  )

				# prepare a noise vector that will be also used for testing the TF model
				# (this way we can ensure that the PT and TF models operate on the same inputs)
				_UpperCamelCase       			=ViTMAEConfig()
				_UpperCamelCase       			=int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2  )
				_UpperCamelCase       			=np.random.uniform(size=(1, num_patches)  )

				# forward pass
				_UpperCamelCase       			=model(**UpperCamelCase__							,	noise=UpperCamelCase__  )

				# verify the logits
				_UpperCamelCase       			=tf.convert_to_tensor([1, 196, 768]  )
				self.assertEqual(outputs.logits.shape							,	UpperCamelCase__  )

				_UpperCamelCase       			=tf.convert_to_tensor(
				    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]  )

				tf.debugging.assert_near(outputs.logits[0, :3, :3]							,	UpperCamelCase__							,	atol=1E-4  )













'''simple docstring'''






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						: Union[str, Any]		=   logging.get_logger(__name__)

__lowerCamelCase						: int		=   {
    'google/mobilenet_v2_1.4_224': 'https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json',
    'google/mobilenet_v2_1.0_224': 'https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json',
    'google/mobilenet_v2_0.75_160': 'https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json',
    'google/mobilenet_v2_0.35_96': 'https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json',
    # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2
}







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				"""mobilenet_v2"""


  def __init__(				self    :					Tuple							,	UpperCamelCase__    :					Union[str, Any]=3							,	UpperCamelCase__    :					Dict=224							,	UpperCamelCase__    :					str=1.0							,	UpperCamelCase__    :					List[Any]=8							,	UpperCamelCase__    :					Union[str, Any]=8							,	UpperCamelCase__    :					str=6							,	UpperCamelCase__    :					str=32							,	UpperCamelCase__    :					str=True							,	UpperCamelCase__    :					int=True							,	UpperCamelCase__    :					str="relu6"							,	UpperCamelCase__    :					Tuple=True							,	UpperCamelCase__    :					List[str]=0.8							,	UpperCamelCase__    :					List[str]=0.02							,	UpperCamelCase__    :					str=0.001							,	UpperCamelCase__    :					Dict=255							,	**UpperCamelCase__    :					Tuple							,	)     ->						List[Any]:
    super().__init__(**UpperCamelCase__  )

    if depth_multiplier <= 0:
      raise ValueError('''depth_multiplier must be greater than zero.'''  )

    _UpperCamelCase       			=num_channels
    _UpperCamelCase       			=image_size
    _UpperCamelCase       			=depth_multiplier
    _UpperCamelCase       			=depth_divisible_by
    _UpperCamelCase       			=min_depth
    _UpperCamelCase       			=expand_ratio
    _UpperCamelCase       			=output_stride
    _UpperCamelCase       			=first_layer_is_expansion
    _UpperCamelCase       			=finegrained_output
    _UpperCamelCase       			=hidden_act
    _UpperCamelCase       			=tf_padding
    _UpperCamelCase       			=classifier_dropout_prob
    _UpperCamelCase       			=initializer_range
    _UpperCamelCase       			=layer_norm_eps
    _UpperCamelCase       			=semantic_loss_ignore_index







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				version.parse("""1.11""")


  @property
  def   UpperCamelCase__      (				self    :					str  )     ->						Mapping[str, Mapping[int, str]]:
    return OrderedDict([('''pixel_values''', {0: '''batch'''})]  )


  @property
  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Mapping[str, Mapping[int, str]]:
    if self.task == "image-classification":
      return OrderedDict([('''logits''', {0: '''batch'''})]  )
    else:
      return OrderedDict([('''last_hidden_state''', {0: '''batch'''}), ('''pooler_output''', {0: '''batch'''})]  )




  @property
  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						float:
    return 1E-4






