



"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase      =		{
    """configuration_swinv2""": ["""SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Swinv2Config"""],
}


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase      =		[
      """SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """Swinv2ForImageClassification""",
      """Swinv2ForMaskedImageModeling""",
      """Swinv2Model""",
      """Swinv2PreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_swinva import (
        SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
        SwinvaForImageClassification,
        SwinvaForMaskedImageModeling,
        SwinvaModel,
        SwinvaPreTrainedModel,
    )


else:
  import sys

  lowerCamelCase      =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)









"""simple docstring"""





import copy
import os
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union


if TYPE_CHECKING:
  from ...processing_utils import ProcessorMixin
  from ...utils import TensorType

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


lowerCamelCase      =		logging.get_logger(__name__)

lowerCamelCase      =		{
    """google/owlvit-base-patch32""": """https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json""",
    """google/owlvit-base-patch16""": """https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json""",
    """google/owlvit-large-patch14""": """https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json""",
}
class    lowercase__     (					SCREAMING_SNAKE_CASE   ):







       '''simple docstring'''


       UpperCamelCase		=  '''owlvit_text_model'''



       def __init__(							self    :						List[Any]	,       _UpperCAmelCase    :						str=49408	,       _UpperCAmelCase    :						str=512	,       _UpperCAmelCase    :						Optional[Any]=2048	,       _UpperCAmelCase    :						Optional[int]=12	,       _UpperCAmelCase    :						Tuple=8	,       _UpperCAmelCase    :						List[str]=16	,       _UpperCAmelCase    :						List[str]="quick_gelu"	,       _UpperCAmelCase    :						Dict=1e-5	,       _UpperCAmelCase    :						Union[str, Any]=0.0	,       _UpperCAmelCase    :						List[Any]=0.02	,       _UpperCAmelCase    :						Optional[int]=1.0	,       _UpperCAmelCase    :						Dict=0	,       _UpperCAmelCase    :						Dict=49406	,       _UpperCAmelCase    :						Union[str, Any]=49407	,       **_UpperCAmelCase    :						List[str]	,       )				->		List[str]:


             '''simple docstring'''




             super().__init__(pad_token_id=_UpperCAmelCase	,       bos_token_id=_UpperCAmelCase	,       eos_token_id=_UpperCAmelCase	,       **_UpperCAmelCase					)

             UpperCAmelCase_    				=							vocab_size
             UpperCAmelCase_    				=							hidden_size
             UpperCAmelCase_    				=							intermediate_size
             UpperCAmelCase_    				=							num_hidden_layers
             UpperCAmelCase_    				=							num_attention_heads
             UpperCAmelCase_    				=							max_position_embeddings
             UpperCAmelCase_    				=							hidden_act
             UpperCAmelCase_    				=							layer_norm_eps
             UpperCAmelCase_    				=							attention_dropout
             UpperCAmelCase_    				=							initializer_range
             UpperCAmelCase_    				=							initializer_factor







       @classmethod
       def   lowercase__       (							cls    :						int	,       _UpperCAmelCase    :						Union[str, os.PathLike]	,       **_UpperCAmelCase    :						List[str]					)				->		"PretrainedConfig":


             '''simple docstring'''




             cls._set_token_in_kwargs(_UpperCAmelCase					)

             UpperCAmelCase_				,					UpperCAmelCase_    				=							cls.get_config_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)

             # get the text config dict if we are loading from OwlViTConfig
             if config_dict.get("model_type"					) == "owlvit":
                   UpperCAmelCase_    				=							config_dict["text_config"]

             if "model_type" in config_dict and hasattr(cls	,       "model_type"					) and config_dict["model_type"] != cls.model_type:
                   logger.warning(
                       F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
                       F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""					)

             return cls.from_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)



class    lowercase__     (					SCREAMING_SNAKE_CASE   ):







       '''simple docstring'''


       UpperCamelCase		=  '''owlvit_vision_model'''



       def __init__(							self    :						str	,       _UpperCAmelCase    :						List[str]=768	,       _UpperCAmelCase    :						Optional[Any]=3072	,       _UpperCAmelCase    :						Tuple=12	,       _UpperCAmelCase    :						Optional[Any]=12	,       _UpperCAmelCase    :						List[Any]=3	,       _UpperCAmelCase    :						List[str]=768	,       _UpperCAmelCase    :						int=32	,       _UpperCAmelCase    :						Dict="quick_gelu"	,       _UpperCAmelCase    :						Optional[Any]=1e-5	,       _UpperCAmelCase    :						Optional[int]=0.0	,       _UpperCAmelCase    :						List[Any]=0.02	,       _UpperCAmelCase    :						List[str]=1.0	,       **_UpperCAmelCase    :						List[str]	,       )				->		Dict:


             '''simple docstring'''




             super().__init__(**_UpperCAmelCase					)

             UpperCAmelCase_    				=							hidden_size
             UpperCAmelCase_    				=							intermediate_size
             UpperCAmelCase_    				=							num_hidden_layers
             UpperCAmelCase_    				=							num_attention_heads
             UpperCAmelCase_    				=							num_channels
             UpperCAmelCase_    				=							image_size
             UpperCAmelCase_    				=							patch_size
             UpperCAmelCase_    				=							hidden_act
             UpperCAmelCase_    				=							layer_norm_eps
             UpperCAmelCase_    				=							attention_dropout
             UpperCAmelCase_    				=							initializer_range
             UpperCAmelCase_    				=							initializer_factor







       @classmethod
       def   lowercase__       (							cls    :						Any	,       _UpperCAmelCase    :						Union[str, os.PathLike]	,       **_UpperCAmelCase    :						Union[str, Any]					)				->		"PretrainedConfig":


             '''simple docstring'''




             cls._set_token_in_kwargs(_UpperCAmelCase					)

             UpperCAmelCase_				,					UpperCAmelCase_    				=							cls.get_config_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)

             # get the vision config dict if we are loading from OwlViTConfig
             if config_dict.get("model_type"					) == "owlvit":
                   UpperCAmelCase_    				=							config_dict["vision_config"]

             if "model_type" in config_dict and hasattr(cls	,       "model_type"					) and config_dict["model_type"] != cls.model_type:
                   logger.warning(
                       F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
                       F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""					)

             return cls.from_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)



class    lowercase__     (					SCREAMING_SNAKE_CASE   ):







       '''simple docstring'''


       UpperCamelCase		=  '''owlvit'''
       UpperCamelCase		=  True



       def __init__(							self    :						Tuple	,       _UpperCAmelCase    :						Any=None	,       _UpperCAmelCase    :						Dict=None	,       _UpperCAmelCase    :						Tuple=512	,       _UpperCAmelCase    :						Any=2.6592	,       _UpperCAmelCase    :						Union[str, Any]=True	,       **_UpperCAmelCase    :						Union[str, Any]	,       )				->		Tuple:


             '''simple docstring'''




             super().__init__(**_UpperCAmelCase					)

             if text_config is None:
                   UpperCAmelCase_    				=							{}
                   logger.info("text_config is None. Initializing the OwlViTTextConfig with default values."					)

             if vision_config is None:
                   UpperCAmelCase_    				=							{}
                   logger.info("vision_config is None. initializing the OwlViTVisionConfig with default values."					)

             UpperCAmelCase_    				=							OwlViTTextConfig(**_UpperCAmelCase					)
             UpperCAmelCase_    				=							OwlViTVisionConfig(**_UpperCAmelCase					)

             UpperCAmelCase_    				=							projection_dim
             UpperCAmelCase_    				=							logit_scale_init_value
             UpperCAmelCase_    				=							return_dict
             UpperCAmelCase_    				=							1.0



       @classmethod
       def   lowercase__       (							cls    :						Dict	,       _UpperCAmelCase    :						Union[str, os.PathLike]	,       **_UpperCAmelCase    :						Tuple					)				->		"PretrainedConfig":


             '''simple docstring'''




             cls._set_token_in_kwargs(_UpperCAmelCase					)

             UpperCAmelCase_				,					UpperCAmelCase_    				=							cls.get_config_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)

             if "model_type" in config_dict and hasattr(cls	,       "model_type"					) and config_dict["model_type"] != cls.model_type:
                   logger.warning(
                       F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
                       F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""					)

             return cls.from_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)



       @classmethod
       def   lowercase__       (							cls    :						List[str]	,       _UpperCAmelCase    :						Dict	,       _UpperCAmelCase    :						Dict	,       **_UpperCAmelCase    :						Any					)				->		Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_    				=							{}
             UpperCAmelCase_    				=							text_config
             UpperCAmelCase_    				=							vision_config

             return cls.from_dict(_UpperCAmelCase	,       **_UpperCAmelCase					)







       def   lowercase__       (							self    :						str					)				->		List[str]:


             '''simple docstring'''




             UpperCAmelCase_    				=							copy.deepcopy(self.__dict__					)
             UpperCAmelCase_    				=							self.text_config.to_dict()
             UpperCAmelCase_    				=							self.vision_config.to_dict()
             UpperCAmelCase_    				=							self.__class__.model_type
             return output



class    lowercase__     (					SCREAMING_SNAKE_CASE   ):







       '''simple docstring'''


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


             '''simple docstring'''




             return OrderedDict(
                 [
                     ("input_ids", {0: "batch", 1: "sequence"}),
                     ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
                     ("attention_mask", {0: "batch", 1: "sequence"}),
                 ]					)



       @property
       def   lowercase__       (							self    :						Tuple					)				->		Mapping[str, Mapping[int, str]]:


             '''simple docstring'''




             return OrderedDict(
                 [
                     ("logits_per_image", {0: "batch"}),
                     ("logits_per_text", {0: "batch"}),
                     ("text_embeds", {0: "batch"}),
                     ("image_embeds", {0: "batch"}),
                 ]					)



       @property
       def   lowercase__       (							self    :						Any					)				->		float:


             '''simple docstring'''




             return 1e-4



       def   lowercase__       (							self    :						List[str]	,       _UpperCAmelCase    :						"ProcessorMixin"	,       _UpperCAmelCase    :						int = -1	,       _UpperCAmelCase    :						int = -1	,       _UpperCAmelCase    :						Optional["TensorType"] = None	,       )				->		Mapping[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_    				=							super().generate_dummy_inputs(
                 processor.tokenizer	,       batch_size=_UpperCAmelCase	,       seq_length=_UpperCAmelCase	,       framework=_UpperCAmelCase					)
             UpperCAmelCase_    				=							super().generate_dummy_inputs(
                 processor.image_processor	,       batch_size=_UpperCAmelCase	,       framework=_UpperCAmelCase					)
             return {**text_input_dict, **image_input_dict}







       @property
       def   lowercase__       (							self    :						Dict					)				->		int:


             '''simple docstring'''




             return 14




