


import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


if is_flax_available():
	import jax
	import jax.numpy as jnp
@slow
@require_flax
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			Optional[int]:







								'''simple docstring'''

								return F'gaussian_noise_s={seed}_shape={"_".join([str(__lowerCamelCase						) for s in shape]						)}.npy'






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







								'''simple docstring'''

								super().tearDown()
								gc.collect()






					def A      (				self ,       snake_case_=0 ,       snake_case_=(4, 4, 6_4, 6_4) ,       snake_case_=False						)   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   jnp.bfloataa if fpaa else jnp.floataa
								__lowercase 					=   jnp.array(load_hf_numpy(self.get_file_format(__lowerCamelCase ,       __lowerCamelCase						)						) ,       dtype=__lowerCamelCase						)
								return image






					def A      (				self ,       snake_case_=False ,       snake_case_="CompVis/stable-diffusion-v1-4"						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   jnp.bfloataa if fpaa else jnp.floataa
								__lowercase 					=   "bf16" if fpaa else None

								__lowercase 					=   FlaxUNetaDConditionModel.from_pretrained(
								    __lowerCamelCase ,       subfolder='''unet''' ,       dtype=__lowerCamelCase ,       revision=__lowerCamelCase						)
								return model, params






					def A      (				self ,       snake_case_=0 ,       snake_case_=(4, 7_7, 7_6_8) ,       snake_case_=False						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   jnp.bfloataa if fpaa else jnp.floataa
								__lowercase 					=   jnp.array(load_hf_numpy(self.get_file_format(__lowerCamelCase ,       __lowerCamelCase						)						) ,       dtype=__lowerCamelCase						)
								return hidden_states






					@parameterized.expand(
					    [
					        # fmt: off
					        [8_3, 4, [-0.2_3_2_3, -0.1_3_0_4, 0.0_8_1_3, -0.3_0_9_3, -0.0_9_1_9, -0.1_5_7_1, -0.1_1_2_5, -0.5_8_0_6]],
					        [1_7, 0.5_5, [-0.0_8_3_1, -0.2_4_4_3, 0.0_9_0_1, -0.0_9_1_9, 0.3_3_9_6, 0.0_1_0_3, -0.3_7_4_3, 0.0_7_0_1]],
					        [8, 0.8_9, [-0.4_8_6_3, 0.0_8_5_9, 0.0_8_7_5, -0.1_6_5_8, 0.9_1_9_9, -0.0_1_1_4, 0.4_8_3_9, 0.4_6_3_9]],
					        [3, 1_0_0_0, [-0.5_6_4_9, 0.2_4_0_2, -0.5_5_1_8, 0.1_2_4_8, 1.1_3_2_8, -0.2_4_4_3, -0.0_3_2_5, -1.0_0_7_8]],
					        # fmt: on
					    ]						)
					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   self.get_unet_model(model_id='''CompVis/stable-diffusion-v1-4''' ,       fpaa=__lowerCamelCase						)
								__lowercase 					=   self.get_latents(__lowerCamelCase ,       fpaa=__lowerCamelCase						)
								__lowercase 					=   self.get_encoder_hidden_states(__lowerCamelCase ,       fpaa=__lowerCamelCase						)

								__lowercase 					=   model.apply(
								    {'''params''': params} ,       __lowerCamelCase ,       jnp.array(__lowerCamelCase ,       dtype=jnp.intaa						) ,       encoder_hidden_states=__lowerCamelCase ,       ).sample

								assert sample.shape == latents.shape

								__lowercase 					=   jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())						) ,       dtype=jnp.floataa						)
								__lowercase 					=   jnp.array(__lowerCamelCase ,       dtype=jnp.floataa						)

								# Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
								assert jnp.allclose(__lowerCamelCase ,       __lowerCamelCase ,       atol=1e-2						)






					@parameterized.expand(
					    [
					        # fmt: off
					        [8_3, 4, [0.1_5_1_4, 0.0_8_0_7, 0.1_6_2_4, 0.1_0_1_6, -0.1_8_9_6, 0.0_2_6_3, 0.0_6_7_7, 0.2_3_1_0]],
					        [1_7, 0.5_5, [0.1_1_6_4, -0.0_2_1_6, 0.0_1_7_0, 0.1_5_8_9, -0.3_1_2_0, 0.1_0_0_5, -0.0_5_8_1, -0.1_4_5_8]],
					        [8, 0.8_9, [-0.1_7_5_8, -0.0_1_6_9, 0.1_0_0_4, -0.1_4_1_1, 0.1_3_1_2, 0.1_1_0_3, -0.1_9_9_6, 0.2_1_3_9]],
					        [3, 1_0_0_0, [0.1_2_1_4, 0.0_3_5_2, -0.0_7_3_1, -0.1_5_6_2, -0.0_9_9_4, -0.0_9_0_6, -0.2_3_4_0, -0.0_5_3_9]],
					        # fmt: on
					    ]						)
					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   self.get_unet_model(model_id='''stabilityai/stable-diffusion-2''' ,       fpaa=__lowerCamelCase						)
								__lowercase 					=   self.get_latents(__lowerCamelCase ,       shape=(4, 4, 9_6, 9_6) ,       fpaa=__lowerCamelCase						)
								__lowercase 					=   self.get_encoder_hidden_states(__lowerCamelCase ,       shape=(4, 7_7, 1_0_2_4) ,       fpaa=__lowerCamelCase						)

								__lowercase 					=   model.apply(
								    {'''params''': params} ,       __lowerCamelCase ,       jnp.array(__lowerCamelCase ,       dtype=jnp.intaa						) ,       encoder_hidden_states=__lowerCamelCase ,       ).sample

								assert sample.shape == latents.shape

								__lowercase 					=   jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())						) ,       dtype=jnp.floataa						)
								__lowercase 					=   jnp.array(__lowerCamelCase ,       dtype=jnp.floataa						)

								# Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
								assert jnp.allclose(__lowerCamelCase ,       __lowerCamelCase ,       atol=1e-2						)



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


a : Union[str, Any]		=				logging.get_logger(__name__)

a : Any		=				{
    '''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 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				"owlvit_text_model"






					def __init__(				self ,       snake_case_=4_9_4_0_8 ,       snake_case_=5_1_2 ,       snake_case_=2_0_4_8 ,       snake_case_=1_2 ,       snake_case_=8 ,       snake_case_=1_6 ,       snake_case_="quick_gelu" ,       snake_case_=1e-5 ,       snake_case_=0.0 ,       snake_case_=0.0_2 ,       snake_case_=1.0 ,       snake_case_=0 ,       snake_case_=4_9_4_0_6 ,       snake_case_=4_9_4_0_7 ,       **snake_case_ ,       )   ->			int:







								'''simple docstring'''

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

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






					@classmethod
					def A      (				cls ,       snake_case_ ,       **snake_case_						)   ->			"PretrainedConfig":







								'''simple docstring'''

								cls._set_token_in_kwargs(snake_case_						)

								__lowercase					, __lowercase 					=   cls.get_config_dict(snake_case_ ,       **snake_case_						)

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




class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				"owlvit_vision_model"






					def __init__(				self ,       snake_case_=7_6_8 ,       snake_case_=3_0_7_2 ,       snake_case_=1_2 ,       snake_case_=1_2 ,       snake_case_=3 ,       snake_case_=7_6_8 ,       snake_case_=3_2 ,       snake_case_="quick_gelu" ,       snake_case_=1e-5 ,       snake_case_=0.0 ,       snake_case_=0.0_2 ,       snake_case_=1.0 ,       **snake_case_ ,       )   ->			Any:







								'''simple docstring'''

								super().__init__(**snake_case_						)

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






					@classmethod
					def A      (				cls ,       snake_case_ ,       **snake_case_						)   ->			"PretrainedConfig":







								'''simple docstring'''

								cls._set_token_in_kwargs(snake_case_						)

								__lowercase					, __lowercase 					=   cls.get_config_dict(snake_case_ ,       **snake_case_						)

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




class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				"owlvit"
					__UpperCAmelCase            =				True






					def __init__(				self ,       snake_case_=None ,       snake_case_=None ,       snake_case_=5_1_2 ,       snake_case_=2.6_5_9_2 ,       snake_case_=True ,       **snake_case_ ,       )   ->			Optional[Any]:







								'''simple docstring'''

								super().__init__(**snake_case_						)

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

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

								__lowercase 					=   OwlViTTextConfig(**snake_case_						)
								__lowercase 					=   OwlViTVisionConfig(**snake_case_						)

								__lowercase 					=   projection_dim
								__lowercase 					=   logit_scale_init_value
								__lowercase 					=   return_dict
								__lowercase 					=   1.0






					@classmethod
					def A      (				cls ,       snake_case_ ,       **snake_case_						)   ->			"PretrainedConfig":







								'''simple docstring'''

								cls._set_token_in_kwargs(snake_case_						)

								__lowercase					, __lowercase 					=   cls.get_config_dict(snake_case_ ,       **snake_case_						)

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






					@classmethod
					def A      (				cls ,       snake_case_ ,       snake_case_ ,       **snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   {}
								__lowercase 					=   text_config
								__lowercase 					=   vision_config

								return cls.from_dict(snake_case_ ,       **snake_case_						)






					def A      (				self						)   ->			Any:







								'''simple docstring'''

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




class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					@property
					def A      (				self						)   ->			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 A      (				self						)   ->			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 A      (				self						)   ->			float:







								'''simple docstring'''

								return 1e-4






					def A      (				self ,       snake_case_ ,       snake_case_ = -1 ,       snake_case_ = -1 ,       snake_case_ = None ,       )   ->			Mapping[str, Any]:







								'''simple docstring'''

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






					@property
					def A      (				self						)   ->			int:







								'''simple docstring'''

								return 1_4


