"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class 						__UpperCAmelCase    (__A							,   __A							,   unittest.TestCase     ):







			'''simple docstring'''
			_UpperCamelCase  :						str					     =				CycleDiffusionPipeline
			_UpperCamelCase  :						Dict					     =				TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
			    'negative_prompt',
			    'height',
			    'width',
			    'negative_prompt_embeds',
			}
			_UpperCamelCase  :						int					     =				PipelineTesterMixin.required_optional_params - {'latents'}
			_UpperCamelCase  :						Optional[Any]					     =				TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'source_prompt'}     )
			_UpperCamelCase  :						Optional[int]					     =				IMAGE_TO_IMAGE_IMAGE_PARAMS
			_UpperCamelCase  :						str					     =				IMAGE_TO_IMAGE_IMAGE_PARAMS





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										torch.manual_seed(0							)
										A__       :     Optional[Any]								=			UNetaDConditionModel(
										    block_out_channels=(32, 64)   ,      layers_per_block=2   ,      sample_size=32   ,      in_channels=4   ,      out_channels=4   ,      down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   ,      up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   ,      cross_attention_dim=32   ,      )
										A__       :     Optional[Any]								=			DDIMScheduler(
										    beta_start=0.0_00_85   ,      beta_end=0.0_12   ,      beta_schedule="""scaled_linear"""   ,      num_train_timesteps=1_000   ,      clip_sample=snake_case_   ,      set_alpha_to_one=snake_case_   ,      )
										torch.manual_seed(0							)
										A__       :     int								=			AutoencoderKL(
										    block_out_channels=[32, 64]   ,      in_channels=3   ,      out_channels=3   ,      down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   ,      up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   ,      latent_channels=4   ,      )
										torch.manual_seed(0							)
										A__       :     List[Any]								=			CLIPTextConfig(
										    bos_token_id=0   ,      eos_token_id=2   ,      hidden_size=32   ,      intermediate_size=37   ,      layer_norm_eps=1E-05   ,      num_attention_heads=4   ,      num_hidden_layers=5   ,      pad_token_id=1   ,      vocab_size=1_000   ,      )
										A__       :     Union[str, Any]								=			CLIPTextModel(snake_case_							)
										A__       :     Dict								=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

										A__       :     Tuple								=			{
										    """unet""": unet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """safety_checker""": None,
										    """feature_extractor""": None,
										}
										return components





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_=0							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			floats_tensor((1, 3, 32, 32)   ,      rng=random.Random(snake_case_							)							).to(snake_case_							)
										A__       :     str								=			image / 2 + 0.5
										if str(snake_case_							).startswith("""mps"""							):
																	A__       :     Union[str, Any]								=			torch.manual_seed(snake_case_							)
										else:
																	A__       :     int								=			torch.Generator(device=snake_case_							).manual_seed(snake_case_							)
										A__       :     int								=			{
										    """prompt""": """An astronaut riding an elephant""",
										    """source_prompt""": """An astronaut riding a horse""",
										    """image""": image,
										    """generator""": generator,
										    """num_inference_steps""": 2,
										    """eta""": 0.1,
										    """strength""": 0.8,
										    """guidance_scale""": 3,
										    """source_guidance_scale""": 1,
										    """output_type""": """numpy""",
										}
										return inputs





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			"""cpu"""  # ensure determinism for the device-dependent torch.Generator

										A__       :     List[Any]								=			self.get_dummy_components()
										A__       :     Tuple								=			CycleDiffusionPipeline(**snake_case_							)
										A__       :     Union[str, Any]								=			pipe.to(snake_case_							)
										pipe.set_progress_bar_config(disable=snake_case_							)

										A__       :     str								=			self.get_dummy_inputs(snake_case_							)
										A__       :     List[str]								=			pipe(**snake_case_							)
										A__       :     Any								=			output.images

										A__       :     Any								=			images[0, -3:, -3:, -1]

										assert images.shape == (1, 32, 32, 3)
										A__       :     List[Any]								=			np.array([0.44_59, 0.49_43, 0.45_44, 0.66_43, 0.54_74, 0.43_27, 0.57_01, 0.59_59, 0.51_79]							)

										assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2





			@unittest.skipIf(torch_device != """cuda"""   ,      """This test requires a GPU"""							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			self.get_dummy_components()
										for name, module in components.items():
																	if hasattr(snake_case_   ,      """half"""							):
																								A__       :     Dict								=			module.half()
										A__       :     Any								=			CycleDiffusionPipeline(**snake_case_							)
										A__       :     Dict								=			pipe.to(snake_case_							)
										pipe.set_progress_bar_config(disable=snake_case_							)

										A__       :     Tuple								=			self.get_dummy_inputs(snake_case_							)
										A__       :     Tuple								=			pipe(**snake_case_							)
										A__       :     List[str]								=			output.images

										A__       :     str								=			images[0, -3:, -3:, -1]

										assert images.shape == (1, 32, 32, 3)
										A__       :     Optional[int]								=			np.array([0.35_06, 0.45_43, 0.4_46, 0.45_75, 0.51_95, 0.41_55, 0.52_73, 0.5_18, 0.41_16]							)

										assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2





			@skip_mps
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return super().test_save_load_local()





			@unittest.skip("""non-deterministic pipeline"""							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return super().test_inference_batch_single_identical()





			@skip_mps
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return super().test_dict_tuple_outputs_equivalent()





			@skip_mps
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return super().test_save_load_optional_components()





			@skip_mps
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return super().test_attention_slicing_forward_pass()





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







			'''simple docstring'''





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     str								=			load_image(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
										    """/cycle-diffusion/black_colored_car.png"""							)
										A__       :     List[Any]								=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"""							)
										A__       :     List[str]								=			init_image.resize((512, 512)							)

										A__       :     str								=			"""CompVis/stable-diffusion-v1-4"""
										A__       :     Optional[Any]								=			DDIMScheduler.from_pretrained(snake_case_   ,      subfolder="""scheduler"""							)
										A__       :     Dict								=			CycleDiffusionPipeline.from_pretrained(
										    snake_case_   ,      scheduler=snake_case_   ,      safety_checker=snake_case_   ,      torch_dtype=torch.floataa   ,      revision="""fp16"""							)

										pipe.to(snake_case_							)
										pipe.set_progress_bar_config(disable=snake_case_							)
										pipe.enable_attention_slicing()

										A__       :     Union[str, Any]								=			"""A black colored car"""
										A__       :     int								=			"""A blue colored car"""

										A__       :     Union[str, Any]								=			torch.manual_seed(0							)
										A__       :     Tuple								=			pipe(
										    prompt=snake_case_   ,      source_prompt=snake_case_   ,      image=snake_case_   ,      num_inference_steps=100   ,      eta=0.1   ,      strength=0.85   ,      guidance_scale=3   ,      source_guidance_scale=1   ,      generator=snake_case_   ,      output_type="""np"""   ,      )
										A__       :     List[str]								=			output.images

										# the values aren't exactly equal, but the images look the same visually
										assert np.abs(image - expected_image							).max() < 5E-1





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Dict								=			load_image(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
										    """/cycle-diffusion/black_colored_car.png"""							)
										A__       :     Optional[Any]								=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"""							)
										A__       :     Optional[Any]								=			init_image.resize((512, 512)							)

										A__       :     Optional[Any]								=			"""CompVis/stable-diffusion-v1-4"""
										A__       :     int								=			DDIMScheduler.from_pretrained(snake_case_   ,      subfolder="""scheduler"""							)
										A__       :     Union[str, Any]								=			CycleDiffusionPipeline.from_pretrained(snake_case_   ,      scheduler=snake_case_   ,      safety_checker=snake_case_							)

										pipe.to(snake_case_							)
										pipe.set_progress_bar_config(disable=snake_case_							)
										pipe.enable_attention_slicing()

										A__       :     Union[str, Any]								=			"""A black colored car"""
										A__       :     Any								=			"""A blue colored car"""

										A__       :     str								=			torch.manual_seed(0							)
										A__       :     Tuple								=			pipe(
										    prompt=snake_case_   ,      source_prompt=snake_case_   ,      image=snake_case_   ,      num_inference_steps=100   ,      eta=0.1   ,      strength=0.85   ,      guidance_scale=3   ,      source_guidance_scale=1   ,      generator=snake_case_   ,      output_type="""np"""   ,      )
										A__       :     List[Any]								=			output.images

										assert np.abs(image - expected_image							).max() < 2E-2






"""simple docstring"""



from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor
class 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self   ,      snake_case_   ,      snake_case_=3   ,      snake_case_=32   ,      snake_case_=3   ,      snake_case_=10   ,      snake_case_=[10, 20, 30, 40]   ,      snake_case_=[1, 1, 2, 1]   ,      snake_case_=True   ,      snake_case_=True   ,      snake_case_="relu"   ,      snake_case_=3   ,      snake_case_=None   ,      ):







										'''simple docstring'''


										A__       :     Tuple								=			parent
										A__       :     int								=			batch_size
										A__       :     List[Any]								=			image_size
										A__       :     Any								=			num_channels
										A__       :     Tuple								=			embeddings_size
										A__       :     Union[str, Any]								=			hidden_sizes
										A__       :     Tuple								=			depths
										A__       :     Union[str, Any]								=			is_training
										A__       :     Any								=			use_labels
										A__       :     Optional[Any]								=			hidden_act
										A__       :     str								=			num_labels
										A__       :     Optional[Any]								=			scope
										A__       :     List[Any]								=			len(snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										A__       :     str								=			None
										if self.use_labels:
																	A__       :     Tuple								=			ids_tensor([self.batch_size]   ,      self.num_labels							)

										A__       :     Dict								=			self.get_config()
										return config, pixel_values, labels





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return RegNetConfig(
										    num_channels=self.num_channels   ,      embeddings_size=self.embeddings_size   ,      hidden_sizes=self.hidden_sizes   ,      depths=self.depths   ,      hidden_act=self.hidden_act   ,      num_labels=self.num_labels   ,      )





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			TFRegNetModel(config=snake_case_							)
										A__       :     Optional[int]								=			model(snake_case_   ,      training=snake_case_							)
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape   ,      (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   ,      )





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Optional[int]								=			self.num_labels
										A__       :     Tuple								=			TFRegNetForImageClassification(snake_case_							)
										A__       :     Optional[int]								=			model(snake_case_   ,      labels=snake_case_   ,      training=snake_case_							)
										self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.num_labels)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[str]								=			self.prepare_config_and_inputs()
										A__				,							A__				,							A__       :     Optional[Any]								=			config_and_inputs
										A__       :     str								=			{"""pixel_values""": pixel_values}
										return config, inputs_dict





@require_tf
class 						__UpperCAmelCase    (__A							,   __A							,   unittest.TestCase     ):







			'''simple docstring'''
			_UpperCamelCase  :						str					     =				(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
			_UpperCamelCase  :						Tuple					     =				(
			    {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
			    if is_tf_available()
			    else {}
			)

			_UpperCamelCase  :						str					     =				False
			_UpperCamelCase  :						int					     =				False
			_UpperCamelCase  :						Tuple					     =				False
			_UpperCamelCase  :						Any					     =				False
			_UpperCamelCase  :						Union[str, Any]					     =				False





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Dict								=			TFRegNetModelTester(self							)
										A__       :     str								=			ConfigTester(self   ,      config_class=snake_case_   ,      has_text_modality=snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return





			@unittest.skip(reason="""RegNet does not use inputs_embeds"""							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										pass





			@unittest.skipIf(
			    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""							)							) == 0   ,      reason="""TF does not support backprop for grouped convolutions on CPU."""   ,      )
			@slow
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										super().test_keras_fit()





			@unittest.skip(reason="""RegNet does not support input and output embeddings"""							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										pass





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__				,							A__       :     int								=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	A__       :     int								=			model_class(snake_case_							)
																	A__       :     Optional[int]								=			inspect.signature(model.call							)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	A__       :     Union[str, Any]								=			[*signature.parameters.keys()]

																	A__       :     Tuple								=			["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]   ,      snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										def check_hidden_states_output(snake_case_   ,      snake_case_   ,      snake_case_							):
																	A__       :     str								=			model_class(snake_case_							)
																	A__       :     Union[str, Any]								=			model(**self._prepare_for_class(snake_case_   ,      snake_case_							)   ,      training=snake_case_							)

																	A__       :     Optional[int]								=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																	A__       :     Union[str, Any]								=			self.model_tester.num_stages
																	self.assertEqual(len(snake_case_							)   ,      expected_num_stages + 1							)

																	# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
																	self.assertListEqual(
																	    list(hidden_states[0].shape[-2:]							)   ,      [self.model_tester.image_size // 2, self.model_tester.image_size // 2]   ,      )

										A__				,							A__       :     int								=			self.model_tester.prepare_config_and_inputs_for_common()
										A__       :     Optional[int]								=			["""basic""", """bottleneck"""]
										for model_class in self.all_model_classes:
																	for layer_type in layers_type:
																								A__       :     Optional[Any]								=			layer_type
																								A__       :     Dict								=			True
																								check_hidden_states_output(snake_case_   ,      snake_case_   ,      snake_case_							)

																								# check that output_hidden_states also work using config
																								del inputs_dict["output_hidden_states"]
																								A__       :     List[Any]								=			True

																								check_hidden_states_output(snake_case_   ,      snake_case_   ,      snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__				,							A__       :     Optional[Any]								=			self.model_tester.prepare_config_and_inputs_for_common()

										def check_equivalence(snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_={}							):
																	A__       :     List[str]								=			model(snake_case_   ,      return_dict=snake_case_   ,      **snake_case_							)
																	A__       :     Union[str, Any]								=			model(snake_case_   ,      return_dict=snake_case_   ,      **snake_case_							).to_tuple()

																	def recursive_check(snake_case_   ,      snake_case_							):
																								if isinstance(snake_case_   ,      (List, Tuple)							):
																															for tuple_iterable_value, dict_iterable_value in zip(snake_case_   ,      snake_case_							):
																																						recursive_check(snake_case_   ,      snake_case_							)
																								elif tuple_object is None:
																															return
																								else:
																															self.assertTrue(
																															    all(tf.equal(snake_case_   ,      snake_case_							)							)   ,      msg=(
																															        """Tuple and dict output are not equal. Difference:"""
																															        F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object							)							)}'''
																															    )   ,      )

																								recursive_check(snake_case_   ,      snake_case_							)

										for model_class in self.all_model_classes:
																	A__       :     Any								=			model_class(snake_case_							)

																	A__       :     Dict								=			self._prepare_for_class(snake_case_   ,      snake_case_							)
																	A__       :     List[Any]								=			self._prepare_for_class(snake_case_   ,      snake_case_							)
																	check_equivalence(snake_case_   ,      snake_case_   ,      snake_case_							)

																	A__       :     Tuple								=			self._prepare_for_class(snake_case_   ,      snake_case_   ,      return_labels=snake_case_							)
																	A__       :     List[str]								=			self._prepare_for_class(snake_case_   ,      snake_case_   ,      return_labels=snake_case_							)
																	check_equivalence(snake_case_   ,      snake_case_   ,      snake_case_							)

																	A__       :     Optional[int]								=			self._prepare_for_class(snake_case_   ,      snake_case_							)
																	A__       :     List[str]								=			self._prepare_for_class(snake_case_   ,      snake_case_							)
																	check_equivalence(snake_case_   ,      snake_case_   ,      snake_case_   ,      {"""output_hidden_states""": True}							)

																	A__       :     Dict								=			self._prepare_for_class(snake_case_   ,      snake_case_   ,      return_labels=snake_case_							)
																	A__       :     Union[str, Any]								=			self._prepare_for_class(snake_case_   ,      snake_case_   ,      return_labels=snake_case_							)
																	check_equivalence(snake_case_   ,      snake_case_   ,      snake_case_   ,      {"""output_hidden_states""": True}							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Tuple								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*snake_case_							)





			@slow
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	A__       :     Any								=			TFRegNetModel.from_pretrained(snake_case_							)
																	self.assertIsNotNone(snake_case_							)





def  _A(		):
							A__       :     Optional[int]								=			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
							return image



@require_tf
@require_vision
class 						__UpperCAmelCase    (unittest.TestCase     ):







			'''simple docstring'''





			@cached_property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return (
										    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
										    if is_vision_available()
										    else None
										)





			@slow
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     int								=			TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)

										A__       :     str								=			self.default_image_processor
										A__       :     Any								=			prepare_img()
										A__       :     Tuple								=			image_processor(images=snake_case_   ,      return_tensors="""tf"""							)

										# forward pass
										A__       :     List[Any]								=			model(**snake_case_   ,      training=snake_case_							)

										# verify the logits
										A__       :     Tuple								=			tf.TensorShape((1, 1_000)							)
										self.assertEqual(outputs.logits.shape   ,      snake_case_							)

										A__       :     Tuple								=			tf.constant([-0.41_80, -1.50_51, -3.48_36]							)

										tf.debugging.assert_near(outputs.logits[0, :3]   ,      snake_case_   ,      atol=1E-4							)





