






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

a					:							Union[str, Any]    =						{
    """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(  lowerCamelCase__				):




						"""simple docstring"""




						__lowerCamelCase										=   "mobilenet_v2"




						def __init__(  self			,    snake_case__=3			,    snake_case__=224			,    snake_case__=1.0			,    snake_case__=8			,    snake_case__=8			,    snake_case__=6			,    snake_case__=32			,    snake_case__=True			,    snake_case__=True			,    snake_case__="relu6"			,    snake_case__=True			,    snake_case__=0.8			,    snake_case__=0.02			,    snake_case__=0.0_01			,    snake_case__=255			,    **snake_case__			,    ):
												'''simple docstring'''
												super().__init__(**SCREAMING_SNAKE_CASE__     )

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

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


class        __UpperCAmelCase(  lowerCamelCase__				):




						"""simple docstring"""




						__lowerCamelCase										=   version.parse("1.11"				)




						@property
						def 						UpperCAmelCase_			(  self     ):
												'''simple docstring'''
												return OrderedDict([("pixel_values", {0: "batch"})]     )




						@property
						def 						UpperCAmelCase_			(  self     ):
												'''simple docstring'''



												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     ):
												'''simple docstring'''
												return 1e-4










"""simple docstring"""






UpperCamelCase__				:Tuple			   =	frozenset(
    [
        """prompt""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
        """cross_attention_kwargs""",
    ]
)

UpperCamelCase__				:List[str]			   =	frozenset(["""prompt""", """negative_prompt"""])

UpperCamelCase__				:Tuple			   =	frozenset([])

UpperCamelCase__				:Union[str, Any]			   =	frozenset(["""image"""])

UpperCamelCase__				:str			   =	frozenset(
    [
        """image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

UpperCamelCase__				:Any			   =	frozenset(["""image"""])

UpperCamelCase__				:Optional[int]			   =	frozenset(
    [
        """prompt""",
        """image""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
    ]
)

UpperCamelCase__				:int			   =	frozenset(["""prompt""", """image""", """negative_prompt"""])

UpperCamelCase__				:Tuple			   =	frozenset(
    [
        # Text guided image variation with an image mask
        """prompt""",
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
    ]
)

UpperCamelCase__				:Any			   =	frozenset(["""prompt""", """image""", """mask_image""", """negative_prompt"""])

UpperCamelCase__				:Dict			   =	frozenset(
    [
        # image variation with an image mask
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

UpperCamelCase__				:Dict			   =	frozenset(["""image""", """mask_image"""])

UpperCamelCase__				:Tuple			   =	frozenset(
    [
        """example_image""",
        """image""",
        """mask_image""",
        """height""",
        """width""",
        """guidance_scale""",
    ]
)

UpperCamelCase__				:List[str]			   =	frozenset(["""example_image""", """image""", """mask_image"""])

UpperCamelCase__				:List[str]			   =	frozenset(["""class_labels"""])

UpperCamelCase__				:Union[str, Any]			   =	frozenset(["""class_labels"""])

UpperCamelCase__				:Any			   =	frozenset(["""batch_size"""])

UpperCamelCase__				:Optional[Any]			   =	frozenset([])

UpperCamelCase__				:Optional[Any]			   =	frozenset(["""batch_size"""])

UpperCamelCase__				:Optional[int]			   =	frozenset([])

UpperCamelCase__				:str			   =	frozenset(
    [
        """prompt""",
        """audio_length_in_s""",
        """guidance_scale""",
        """negative_prompt""",
        """prompt_embeds""",
        """negative_prompt_embeds""",
        """cross_attention_kwargs""",
    ]
)

UpperCamelCase__				:Union[str, Any]			   =	frozenset(["""prompt""", """negative_prompt"""])
UpperCamelCase__				:Tuple			   =	frozenset(["""input_tokens"""])

UpperCamelCase__				:int			   =	frozenset(["""input_tokens"""])

