






'''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


_A	:			Tuple         =logging.get_logger(__name__)

_A	:			str         ={
    '''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 _lowercase	(				_lowercase		):
							a				      =       """mobilenet_v2"""




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

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

														lowerCamelCase__					:	str         =       num_channels
														lowerCamelCase__					:	Tuple         =       image_size
														lowerCamelCase__					:	str         =       depth_multiplier
														lowerCamelCase__					:	Optional[Any]         =       depth_divisible_by
														lowerCamelCase__					:	List[str]         =       min_depth
														lowerCamelCase__					:	Tuple         =       expand_ratio
														lowerCamelCase__					:	Union[str, Any]         =       output_stride
														lowerCamelCase__					:	str         =       first_layer_is_expansion
														lowerCamelCase__					:	List[Any]         =       finegrained_output
														lowerCamelCase__					:	Tuple         =       hidden_act
														lowerCamelCase__					:	int         =       tf_padding
														lowerCamelCase__					:	List[str]         =       classifier_dropout_prob
														lowerCamelCase__					:	Optional[Any]         =       initializer_range
														lowerCamelCase__					:	Union[str, Any]         =       layer_norm_eps
														lowerCamelCase__					:	List[str]         =       semantic_loss_ignore_index



class _lowercase	(				_lowercase		):
							a				      =       version.parse("""1.11"""		)




							@property
							def 		lowerCamelCase_				(							self:				Tuple     ):
														return OrderedDict([("""pixel_values""", {0: """batch"""})]     )




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




							@property
							def 		lowerCamelCase_				(							self:				str     ):
														return 1e-4









'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


_A	:			Dict         ={'''tokenization_herbert''': ['''HerbertTokenizer''']}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A	:			Optional[int]         =['''HerbertTokenizerFast''']


if TYPE_CHECKING:
			from .tokenization_herbert import HerbertTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_herbert_fast import HerbertTokenizerFast

else:
			import sys

			_A	:			Optional[int]         =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

