





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


_SCREAMING_SNAKE_CASE 		=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE 		=						{
    """google/mobilenet_v1_1.0_224""": """https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json""",
    """google/mobilenet_v1_0.75_192""": """https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json""",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}
class SCREAMING_SNAKE_CASE_  (   _a   ):
						__magic_name__:     Any	 =    "mobilenet_v1"






						def __init__( self : int						,				_A : Tuple=3						,				_A : str=224						,				_A : Dict=1.0						,				_A : List[Any]=8						,				_A : Tuple="relu6"						,				_A : Dict=True						,				_A : Optional[int]=0.9_9_9						,				_A : List[Any]=0.0_2						,				_A : Optional[Any]=0.0_0_1						,				**_A : Optional[int]						,				)							->      Dict:







							"""simple docstring"""


							super().__init__(**_a		)

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

							snake_case_						:     str     =		num_channels
							snake_case_						:     Union[str, Any]     =		image_size
							snake_case_						:     Dict     =		depth_multiplier
							snake_case_						:     Union[str, Any]     =		min_depth
							snake_case_						:     Any     =		hidden_act
							snake_case_						:     int     =		tf_padding
							snake_case_						:     Dict     =		classifier_dropout_prob
							snake_case_						:     Any     =		initializer_range
							snake_case_						:     List[str]     =		layer_norm_eps
class SCREAMING_SNAKE_CASE_  (   _a   ):
						__magic_name__:     Any	 =    version.parse("1.11"   )






						@property
						def UpperCAmelCase_			( self : int		)							->      Union[str, Any]:







							"""simple docstring"""


							return OrderedDict([('pixel_values', {0: 'batch'})]		)






						@property
						def UpperCAmelCase_			( self : Tuple		)							->      Optional[int]:







							"""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 : Dict		)							->      Any:







							"""simple docstring"""


							return 1E-4








import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class SCREAMING_SNAKE_CASE_  (   snake_case_    ,			snake_case_   ):






						@register_to_config
						def __init__( self : Optional[Any]						,				*,
						    _A : int = 4						,				_A : int = 768						,				_A : int						,				_A : Tuple						,				)							->      Dict:







							"""simple docstring"""


							super().__init__()

							snake_case_						:     int     =		nn.Parameter(torch.zeros(_A		)		)

							# parameters for additional clip time embeddings
							snake_case_						:     Tuple     =		nn.Linear(_A						,				_A		)
							snake_case_						:     List[Any]     =		nn.Linear(_A						,				_A		)

							# parameters for encoder hidden states
							snake_case_						:     Union[str, Any]     =		clip_extra_context_tokens
							snake_case_						:     str     =		nn.Linear(
							    _A						,				self.clip_extra_context_tokens * cross_attention_dim		)
							snake_case_						:     Any     =		nn.Linear(_A						,				_A		)
							snake_case_						:     Tuple     =		nn.LayerNorm(_A		)






						def UpperCAmelCase_			( self : List[str]						,				*, _A : Tuple						,				_A : List[Any]						,				_A : str						,				_A : Optional[Any]		)							->      List[Any]:







							"""simple docstring"""


							if do_classifier_free_guidance:
								# Add the classifier free guidance embeddings to the image embeddings
								snake_case_						:     Optional[int]     =		image_embeddings.shape[0]
								snake_case_						:     Optional[Any]     =		self.learned_classifier_free_guidance_embeddings.unsqueeze(0		)
								snake_case_						:     Optional[Any]     =		classifier_free_guidance_embeddings.expand(
								    _A						,				-1		)
								snake_case_						:     Any     =		torch.cat([classifier_free_guidance_embeddings, image_embeddings]						,				dim=0		)

							# The image embeddings batch size and the text embeddings batch size are equal
							assert image_embeddings.shape[0] == prompt_embeds.shape[0]

							snake_case_						:     str     =		prompt_embeds.shape[0]

							# "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
							# adding CLIP embeddings to the existing timestep embedding, ...
							snake_case_						:     str     =		self.embedding_proj(_A		)
							snake_case_						:     Dict     =		self.clip_image_embeddings_project_to_time_embeddings(_A		)
							snake_case_						:     Tuple     =		time_projected_image_embeddings + time_projected_prompt_embeds

							# ... and by projecting CLIP embeddings into four
							# extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
							snake_case_						:     List[str]     =		self.clip_extra_context_tokens_proj(_A		)
							snake_case_						:     Optional[Any]     =		clip_extra_context_tokens.reshape(_A						,				-1						,				self.clip_extra_context_tokens		)
							snake_case_						:     int     =		clip_extra_context_tokens.permute(0						,				2						,				1		)

							snake_case_						:     Optional[int]     =		self.encoder_hidden_states_proj(_A		)
							snake_case_						:     Any     =		self.text_encoder_hidden_states_norm(_A		)
							snake_case_						:     Dict     =		torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]						,				dim=1		)

							return text_encoder_hidden_states, additive_clip_time_embeddings

