





'''simple docstring'''






import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()







class 		UpperCAmelCase   (				__UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     unittest.TestCase):


		"""simple docstring"""







		lowerCAmelCase_					=				StableUnCLIPPipeline
		lowerCAmelCase_					=				TEXT_TO_IMAGE_PARAMS
		lowerCAmelCase_					=				TEXT_TO_IMAGE_BATCH_PARAMS
		lowerCAmelCase_					=				TEXT_TO_IMAGE_IMAGE_PARAMS
		lowerCAmelCase_					=				TEXT_TO_IMAGE_IMAGE_PARAMS

		# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
		lowerCAmelCase_					=				False


		def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						List[Any]:
				_UpperCamelCase       			=32
				_UpperCamelCase       			=embedder_hidden_size

				# prior components

				torch.manual_seed(0  )
				_UpperCamelCase       			=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

				torch.manual_seed(0  )
				_UpperCamelCase       			=CLIPTextModelWithProjection(
				    CLIPTextConfig(
				        bos_token_id=0							,	eos_token_id=2							,	hidden_size=UpperCAmelCase_							,	projection_dim=UpperCAmelCase_							,	intermediate_size=37							,	layer_norm_eps=1E-05							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1000							,	)  )

				torch.manual_seed(0  )
				_UpperCamelCase       			=PriorTransformer(
				    num_attention_heads=2							,	attention_head_dim=12							,	embedding_dim=UpperCAmelCase_							,	num_layers=1							,	)

				torch.manual_seed(0  )
				_UpperCamelCase       			=DDPMScheduler(
				    variance_type='''fixed_small_log'''							,	prediction_type='''sample'''							,	num_train_timesteps=1000							,	clip_sample=UpperCAmelCase_							,	clip_sample_range=5.0							,	beta_schedule='''squaredcos_cap_v2'''							,	)

				# regular denoising components

				torch.manual_seed(0  )
				_UpperCamelCase       			=StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase_  )
				_UpperCamelCase       			=DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''  )

				torch.manual_seed(0  )
				_UpperCamelCase       			=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

				torch.manual_seed(0  )
				_UpperCamelCase       			=CLIPTextModel(
				    CLIPTextConfig(
				        bos_token_id=0							,	eos_token_id=2							,	hidden_size=UpperCAmelCase_							,	projection_dim=32							,	intermediate_size=37							,	layer_norm_eps=1E-05							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1000							,	)  )

				torch.manual_seed(0  )
				_UpperCamelCase       			=UNetaDConditionModel(
				    sample_size=32							,	in_channels=4							,	out_channels=4							,	down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''')							,	up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''')							,	block_out_channels=(32, 64)							,	attention_head_dim=(2, 4)							,	class_embed_type='''projection'''							,	projection_class_embeddings_input_dim=embedder_projection_dim * 2							,	cross_attention_dim=UpperCAmelCase_							,	layers_per_block=1							,	upcast_attention=UpperCAmelCase_							,	use_linear_projection=UpperCAmelCase_							,	)

				torch.manual_seed(0  )
				_UpperCamelCase       			=DDIMScheduler(
				    beta_schedule='''scaled_linear'''							,	beta_start=0.00085							,	beta_end=0.012							,	prediction_type='''v_prediction'''							,	set_alpha_to_one=UpperCAmelCase_							,	steps_offset=1							,	)

				torch.manual_seed(0  )
				_UpperCamelCase       			=AutoencoderKL()

				_UpperCamelCase       			={
				    # prior components
				    '''prior_tokenizer''': prior_tokenizer,
				    '''prior_text_encoder''': prior_text_encoder,
				    '''prior''': prior,
				    '''prior_scheduler''': prior_scheduler,
				    # image noising components
				    '''image_normalizer''': image_normalizer,
				    '''image_noising_scheduler''': image_noising_scheduler,
				    # regular denoising components
				    '''tokenizer''': tokenizer,
				    '''text_encoder''': text_encoder,
				    '''unet''': unet,
				    '''scheduler''': scheduler,
				    '''vae''': vae,
				}

				return components


		def   UpperCamelCase__      (				self    :					Optional[int]							,	UpperCamelCase__    :					Any							,	UpperCamelCase__    :					Dict=0  )     ->						int:
				if str(UpperCAmelCase_  ).startswith('''mps'''  ):
						_UpperCamelCase       			=torch.manual_seed(UpperCAmelCase_  )
				else:
						_UpperCamelCase       			=torch.Generator(device=UpperCAmelCase_  ).manual_seed(UpperCAmelCase_  )
				_UpperCamelCase       			={
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''generator''': generator,
				    '''num_inference_steps''': 2,
				    '''prior_num_inference_steps''': 2,
				    '''output_type''': '''numpy''',
				}
				return inputs


		def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						int:
				_UpperCamelCase       			=torch_device == '''cpu'''

				self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase_  )




		def   UpperCamelCase__      (				self    :					List[str]  )     ->						List[Any]:
				_UpperCamelCase       			=torch_device in ['''cpu''', '''mps''']

				self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase_  )







@slow
@require_torch_gpu
class 		UpperCAmelCase   (				unittest.TestCase):


		"""simple docstring"""







		def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						Any:
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()


		def   UpperCamelCase__      (				self    :					Optional[int]  )     ->						str:
				_UpperCamelCase       			=load_numpy(
				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''  )

				_UpperCamelCase       			=StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''							,	torch_dtype=torch.floataa  )
				pipe.to(UpperCAmelCase_  )
				pipe.set_progress_bar_config(disable=UpperCAmelCase_  )
				# stable unclip will oom when integration tests are run on a V100,
				# so turn on memory savings
				pipe.enable_attention_slicing()
				pipe.enable_sequential_cpu_offload()

				_UpperCamelCase       			=torch.Generator(device='''cpu'''  ).manual_seed(0  )
				_UpperCamelCase       			=pipe('''anime turle'''							,	generator=UpperCAmelCase_							,	output_type='''np'''  )

				_UpperCamelCase       			=output.images[0]

				assert image.shape == (768, 768, 3)

				assert_mean_pixel_difference(UpperCAmelCase_							,	UpperCAmelCase_  )




		def   UpperCamelCase__      (				self    :					Tuple  )     ->						List[str]:
				torch.cuda.empty_cache()
				torch.cuda.reset_max_memory_allocated()
				torch.cuda.reset_peak_memory_stats()

				_UpperCamelCase       			=StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''							,	torch_dtype=torch.floataa  )
				_UpperCamelCase       			=pipe.to(UpperCAmelCase_  )
				pipe.set_progress_bar_config(disable=UpperCAmelCase_  )
				pipe.enable_attention_slicing()
				pipe.enable_sequential_cpu_offload()

				_UpperCamelCase       			=pipe(
				    '''anime turtle'''							,	prior_num_inference_steps=2							,	num_inference_steps=2							,	output_type='''np'''							,	)

				_UpperCamelCase       			=torch.cuda.max_memory_allocated()
				# make sure that less than 7 GB is allocated
				assert mem_bytes < 7 * 10**9













'''simple docstring'''






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


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

__lowerCamelCase						: int		=   {
    'google/mobilenet_v2_1.4_224': 'https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json',
    'google/mobilenet_v2_1.0_224': 'https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json',
    'google/mobilenet_v2_0.75_160': 'https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json',
    'google/mobilenet_v2_0.35_96': 'https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json',
    # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2
}







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				"""mobilenet_v2"""


  def __init__(				self    :					Tuple							,	UpperCamelCase__    :					Union[str, Any]=3							,	UpperCamelCase__    :					Dict=224							,	UpperCamelCase__    :					str=1.0							,	UpperCamelCase__    :					List[Any]=8							,	UpperCamelCase__    :					Union[str, Any]=8							,	UpperCamelCase__    :					str=6							,	UpperCamelCase__    :					str=32							,	UpperCamelCase__    :					str=True							,	UpperCamelCase__    :					int=True							,	UpperCamelCase__    :					str="relu6"							,	UpperCamelCase__    :					Tuple=True							,	UpperCamelCase__    :					List[str]=0.8							,	UpperCamelCase__    :					List[str]=0.02							,	UpperCamelCase__    :					str=0.001							,	UpperCamelCase__    :					Dict=255							,	**UpperCamelCase__    :					Tuple							,	)     ->						List[Any]:
    super().__init__(**UpperCamelCase__  )

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

    _UpperCamelCase       			=num_channels
    _UpperCamelCase       			=image_size
    _UpperCamelCase       			=depth_multiplier
    _UpperCamelCase       			=depth_divisible_by
    _UpperCamelCase       			=min_depth
    _UpperCamelCase       			=expand_ratio
    _UpperCamelCase       			=output_stride
    _UpperCamelCase       			=first_layer_is_expansion
    _UpperCamelCase       			=finegrained_output
    _UpperCamelCase       			=hidden_act
    _UpperCamelCase       			=tf_padding
    _UpperCamelCase       			=classifier_dropout_prob
    _UpperCamelCase       			=initializer_range
    _UpperCamelCase       			=layer_norm_eps
    _UpperCamelCase       			=semantic_loss_ignore_index







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				version.parse("""1.11""")


  @property
  def   UpperCamelCase__      (				self    :					str  )     ->						Mapping[str, Mapping[int, str]]:
    return OrderedDict([('''pixel_values''', {0: '''batch'''})]  )


  @property
  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Mapping[str, Mapping[int, str]]:
    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    :					List[Any]  )     ->						float:
    return 1E-4






