

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


UpperCamelCase_							=					logging.get_logger(__name__)

UpperCamelCase_							=					{
    """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 		__SCREAMING_SNAKE_CASE       ( lowercase__			):
				lowerCamelCase_							=						'owlvit_text_model'







				def __init__(					self    :		Optional[Any]		,				UpperCAmelCase__    :		Optional[int]=49408		,				UpperCAmelCase__    :		int=512		,				UpperCAmelCase__    :		Dict=2048		,				UpperCAmelCase__    :		int=12		,				UpperCAmelCase__    :		Dict=8		,				UpperCAmelCase__    :		Any=16		,				UpperCAmelCase__    :		List[Any]="quick_gelu"		,				UpperCAmelCase__    :		Union[str, Any]=1E-5		,				UpperCAmelCase__    :		List[Any]=0.0		,				UpperCAmelCase__    :		Optional[Any]=0.02		,				UpperCAmelCase__    :		Union[str, Any]=1.0		,				UpperCAmelCase__    :		Any=0		,				UpperCAmelCase__    :		Dict=49406		,				UpperCAmelCase__    :		str=49407		,				**UpperCAmelCase__    :		Tuple		,				):
										'''simple docstring'''
										super().__init__(pad_token_id=UpperCAmelCase__		,				bos_token_id=UpperCAmelCase__		,				eos_token_id=UpperCAmelCase__		,				**UpperCAmelCase__      )

										lowercase   :       Tuple								=vocab_size
										lowercase   :       Optional[Any]								=hidden_size
										lowercase   :       Dict								=intermediate_size
										lowercase   :       Optional[Any]								=num_hidden_layers
										lowercase   :       Union[str, Any]								=num_attention_heads
										lowercase   :       Tuple								=max_position_embeddings
										lowercase   :       Optional[int]								=hidden_act
										lowercase   :       Tuple								=layer_norm_eps
										lowercase   :       List[Any]								=attention_dropout
										lowercase   :       Dict								=initializer_range
										lowercase   :       Tuple								=initializer_factor







				@classmethod
				def    lowerCamelCase_  (					cls    :		Optional[int]		,				UpperCAmelCase__    :		Union[str, os.PathLike]		,				**UpperCAmelCase__    :		List[str]      ):
										'''simple docstring'''
										cls._set_token_in_kwargs(UpperCAmelCase__      )

										lowercase   :       List[Any]								=cls.get_config_dict(UpperCAmelCase__		,				**UpperCAmelCase__      )

										# get the text config dict if we are loading from OwlViTConfig
										if config_dict.get('''model_type'''      ) == "owlvit":
																lowercase   :       Optional[Any]								=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 		__SCREAMING_SNAKE_CASE       ( lowercase__			):
				lowerCamelCase_							=						'owlvit_vision_model'







				def __init__(					self    :		Tuple		,				UpperCAmelCase__    :		int=768		,				UpperCAmelCase__    :		Tuple=3072		,				UpperCAmelCase__    :		Dict=12		,				UpperCAmelCase__    :		Optional[Any]=12		,				UpperCAmelCase__    :		Any=3		,				UpperCAmelCase__    :		Union[str, Any]=768		,				UpperCAmelCase__    :		int=32		,				UpperCAmelCase__    :		int="quick_gelu"		,				UpperCAmelCase__    :		str=1E-5		,				UpperCAmelCase__    :		Optional[Any]=0.0		,				UpperCAmelCase__    :		Union[str, Any]=0.02		,				UpperCAmelCase__    :		Dict=1.0		,				**UpperCAmelCase__    :		Union[str, Any]		,				):
										'''simple docstring'''
										super().__init__(**UpperCAmelCase__      )

										lowercase   :       Dict								=hidden_size
										lowercase   :       List[Any]								=intermediate_size
										lowercase   :       Optional[int]								=num_hidden_layers
										lowercase   :       Tuple								=num_attention_heads
										lowercase   :       str								=num_channels
										lowercase   :       Tuple								=image_size
										lowercase   :       Optional[Any]								=patch_size
										lowercase   :       List[str]								=hidden_act
										lowercase   :       Any								=layer_norm_eps
										lowercase   :       List[str]								=attention_dropout
										lowercase   :       Union[str, Any]								=initializer_range
										lowercase   :       List[str]								=initializer_factor







				@classmethod
				def    lowerCamelCase_  (					cls    :		Tuple		,				UpperCAmelCase__    :		Union[str, os.PathLike]		,				**UpperCAmelCase__    :		Union[str, Any]      ):
										'''simple docstring'''
										cls._set_token_in_kwargs(UpperCAmelCase__      )

										lowercase   :       str								=cls.get_config_dict(UpperCAmelCase__		,				**UpperCAmelCase__      )

										# get the vision config dict if we are loading from OwlViTConfig
										if config_dict.get('''model_type'''      ) == "owlvit":
																lowercase   :       Optional[Any]								=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 		__SCREAMING_SNAKE_CASE       ( lowercase__			):
				lowerCamelCase_							=						'owlvit'
				lowerCamelCase_							=						True







				def __init__(					self    :		str		,				UpperCAmelCase__    :		str=None		,				UpperCAmelCase__    :		Any=None		,				UpperCAmelCase__    :		Union[str, Any]=512		,				UpperCAmelCase__    :		List[Any]=2.65_92		,				UpperCAmelCase__    :		Tuple=True		,				**UpperCAmelCase__    :		Optional[int]		,				):
										'''simple docstring'''
										super().__init__(**UpperCAmelCase__      )

										if text_config is None:
																lowercase   :       Any								={}
																logger.info('''text_config is None. Initializing the OwlViTTextConfig with default values.'''      )

										if vision_config is None:
																lowercase   :       Dict								={}
																logger.info('''vision_config is None. initializing the OwlViTVisionConfig with default values.'''      )

										lowercase   :       Tuple								=OwlViTTextConfig(**UpperCAmelCase__      )
										lowercase   :       Any								=OwlViTVisionConfig(**UpperCAmelCase__      )

										lowercase   :       int								=projection_dim
										lowercase   :       List[str]								=logit_scale_init_value
										lowercase   :       Union[str, Any]								=return_dict
										lowercase   :       int								=1.0







				@classmethod
				def    lowerCamelCase_  (					cls    :		Tuple		,				UpperCAmelCase__    :		Union[str, os.PathLike]		,				**UpperCAmelCase__    :		Tuple      ):
										'''simple docstring'''
										cls._set_token_in_kwargs(UpperCAmelCase__      )

										lowercase   :       int								=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    lowerCamelCase_  (					cls    :		str		,				UpperCAmelCase__    :		Dict		,				UpperCAmelCase__    :		Dict		,				**UpperCAmelCase__    :		Tuple      ):
										'''simple docstring'''
										lowercase   :       Dict								={}
										lowercase   :       Tuple								=text_config
										lowercase   :       Optional[Any]								=vision_config

										return cls.from_dict(UpperCAmelCase__		,				**UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		int      ):
										'''simple docstring'''
										lowercase   :       Optional[int]								=copy.deepcopy(self.__dict__      )
										lowercase   :       List[str]								=self.text_config.to_dict()
										lowercase   :       Optional[Any]								=self.vision_config.to_dict()
										lowercase   :       Tuple								=self.__class__.model_type
										return output





class 		__SCREAMING_SNAKE_CASE       ( lowercase__			):







				@property
				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''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    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										return OrderedDict(
										    [
										        ('''logits_per_image''', {0: '''batch'''}),
										        ('''logits_per_text''', {0: '''batch'''}),
										        ('''text_embeds''', {0: '''batch'''}),
										        ('''image_embeds''', {0: '''batch'''}),
										    ]      )







				@property
				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										return 1E-4







				def    lowerCamelCase_  (					self    :		str		,				UpperCAmelCase__    :		"ProcessorMixin"		,				UpperCAmelCase__    :		int = -1		,				UpperCAmelCase__    :		int = -1		,				UpperCAmelCase__    :		Optional["TensorType"] = None		,				):
										'''simple docstring'''
										lowercase   :       Dict								=super().generate_dummy_inputs(
										    processor.tokenizer		,				batch_size=UpperCAmelCase__		,				seq_length=UpperCAmelCase__		,				framework=UpperCAmelCase__      )
										lowercase   :       List[str]								=super().generate_dummy_inputs(
										    processor.image_processor		,				batch_size=UpperCAmelCase__		,				framework=UpperCAmelCase__      )
										return {**text_input_dict, **image_input_dict}







				@property
				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										return 14








'''simple docstring'''





# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


UpperCamelCase_							=					"""3"""

print("""Python version:""", sys.version)

print("""OS platform:""", platform.platform())
print("""OS architecture:""", platform.machine())

try:
							import torch

							print("""Torch version:""", torch.__version__)
							print("""Cuda available:""", torch.cuda.is_available())
							print("""Cuda version:""", torch.version.cuda)
							print("""CuDNN version:""", torch.backends.cudnn.version())
							print("""Number of GPUs available:""", torch.cuda.device_count())
except ImportError:
							print("""Torch version:""", None)

try:
							import transformers

							print("""transformers version:""", transformers.__version__)
except ImportError:
							print("""transformers version:""", None)





