




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       a__   ( snake_case__				):
						_a							:   Dict =   """owlvit_text_model"""






						def __init__(       self		,      _A=4_9_4_0_8		,      _A=5_1_2		,      _A=2_0_4_8		,      _A=1_2		,      _A=8		,      _A=1_6		,      _A="quick_gelu"		,      _A=1E-5		,      _A=0.0		,      _A=0.02		,      _A=1.0		,      _A=0		,      _A=4_9_4_0_6		,      _A=4_9_4_0_7		,      **_A		,      ):




											"""simple docstring"""



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

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






						@classmethod
						def     __SCREAMING_SNAKE_CASE(       cls		,      _A		,      **_A      ):




											"""simple docstring"""



											cls._set_token_in_kwargs(_A      )

											__lowerCAmelCase       ,							__lowerCAmelCase           =	cls.get_config_dict(_A		,      **_A      )

											# get the text config dict if we are loading from OwlViTConfig
											if config_dict.get("model_type"      ) == "owlvit":
																__lowerCAmelCase           =	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(_A		,      **_A      )






class       a__   ( snake_case__				):
						_a							:   Optional[int] =   """owlvit_vision_model"""






						def __init__(       self		,      _A=7_6_8		,      _A=3_0_7_2		,      _A=1_2		,      _A=1_2		,      _A=3		,      _A=7_6_8		,      _A=3_2		,      _A="quick_gelu"		,      _A=1E-5		,      _A=0.0		,      _A=0.02		,      _A=1.0		,      **_A		,      ):




											"""simple docstring"""



											super().__init__(**_A      )

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






						@classmethod
						def     __SCREAMING_SNAKE_CASE(       cls		,      _A		,      **_A      ):




											"""simple docstring"""



											cls._set_token_in_kwargs(_A      )

											__lowerCAmelCase       ,							__lowerCAmelCase           =	cls.get_config_dict(_A		,      **_A      )

											# get the vision config dict if we are loading from OwlViTConfig
											if config_dict.get("model_type"      ) == "owlvit":
																__lowerCAmelCase           =	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(_A		,      **_A      )






class       a__   ( snake_case__				):
						_a							:   str =   """owlvit"""
						_a							:   Any =   True






						def __init__(       self		,      _A=None		,      _A=None		,      _A=5_1_2		,      _A=2.65_92		,      _A=True		,      **_A		,      ):




											"""simple docstring"""



											super().__init__(**_A      )

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

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

											__lowerCAmelCase           =	OwlViTTextConfig(**_A      )
											__lowerCAmelCase           =	OwlViTVisionConfig(**_A      )

											__lowerCAmelCase           =	projection_dim
											__lowerCAmelCase           =	logit_scale_init_value
											__lowerCAmelCase           =	return_dict
											__lowerCAmelCase           =	1.0






						@classmethod
						def     __SCREAMING_SNAKE_CASE(       cls		,      _A		,      **_A      ):




											"""simple docstring"""



											cls._set_token_in_kwargs(_A      )

											__lowerCAmelCase       ,							__lowerCAmelCase           =	cls.get_config_dict(_A		,      **_A      )

											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(_A		,      **_A      )






						@classmethod
						def     __SCREAMING_SNAKE_CASE(       cls		,      _A		,      _A		,      **_A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	{}
											__lowerCAmelCase           =	text_config
											__lowerCAmelCase           =	vision_config

											return cls.from_dict(_A		,      **_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






class       a__   ( snake_case__				):






						@property
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""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     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






						@property
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											return 1E-4






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A = -1		,      _A = -1		,      _A = None		,      ):




											"""simple docstring"""



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






						@property
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											return 1_4










import argparse

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_controlnet_from_original_ckpt


if __name__ == "__main__":
					UpperCamelCase__         =      argparse.ArgumentParser()

					parser.add_argument(
					    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
					)
					parser.add_argument(
					    """--original_config_file""",
					    type=str,
					    required=True,
					    help="""The YAML config file corresponding to the original architecture.""",
					)
					parser.add_argument(
					    """--num_in_channels""",
					    default=None,
					    type=int,
					    help="""The number of input channels. If `None` number of input channels will be automatically inferred.""",
					)
					parser.add_argument(
					    """--image_size""",
					    default=512,
					    type=int,
					    help=(
					        """The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2"""
					        """ Base. Use 768 for Stable Diffusion v2."""
					    ),
					)
					parser.add_argument(
					    """--extract_ema""",
					    action="""store_true""",
					    help=(
					        """Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights"""
					        """ or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield"""
					        """ higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning."""
					    ),
					)
					parser.add_argument(
					    """--upcast_attention""",
					    action="""store_true""",
					    help=(
					        """Whether the attention computation should always be upcasted. This is necessary when running stable"""
					        """ diffusion 2.1."""
					    ),
					)
					parser.add_argument(
					    """--from_safetensors""",
					    action="""store_true""",
					    help="""If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.""",
					)
					parser.add_argument(
					    """--to_safetensors""",
					    action="""store_true""",
					    help="""Whether to store pipeline in safetensors format or not.""",
					)
					parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
					parser.add_argument("""--device""", type=str, help="""Device to use (e.g. cpu, cuda:0, cuda:1, etc.)""")







					def      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]					):
										if string == "True":
															return True
										elif string == "False":
															return False
										else:
															raise ValueError(F"""could not parse string as bool {string}"""					)

					parser.add_argument(
					    """--use_linear_projection""", help="""Override for use linear projection""", required=False, type=parse_bool
					)

					parser.add_argument("""--cross_attention_dim""", help="""Override for cross attention_dim""", required=False, type=int)

					UpperCamelCase__         =      parser.parse_args()

					UpperCamelCase__         =      download_controlnet_from_original_ckpt(
					    checkpoint_path=args.checkpoint_path,
					    original_config_file=args.original_config_file,
					    image_size=args.image_size,
					    extract_ema=args.extract_ema,
					    num_in_channels=args.num_in_channels,
					    upcast_attention=args.upcast_attention,
					    from_safetensors=args.from_safetensors,
					    device=args.device,
					    use_linear_projection=args.use_linear_projection,
					    cross_attention_dim=args.cross_attention_dim,
					)


					controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)




