


"""simple docstring"""
import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
				from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor





class        __A       :





							'''simple docstring'''

							def __init__(			self							: Optional[Any]						,    UpperCAmelCase_							: Any						,    UpperCAmelCase_							: Union[str, Any]=13						,    UpperCAmelCase_							: List[Any]=32						,    UpperCAmelCase_							: Union[str, Any]=3						,    UpperCAmelCase_							: Any=4						,    UpperCAmelCase_							: int=[10, 20, 30, 40]						,    UpperCAmelCase_							: List[str]=[2, 2, 3, 2]						,    UpperCAmelCase_							: str=True						,    UpperCAmelCase_							: Optional[int]=True						,    UpperCAmelCase_							: Tuple=37						,    UpperCAmelCase_							: Dict="gelu"						,    UpperCAmelCase_							: Tuple=10						,    UpperCAmelCase_							: str=0.02						,    UpperCAmelCase_							: Any=["stage2", "stage3", "stage4"]						,    UpperCAmelCase_							: Optional[Any]=[2, 3, 4]						,    UpperCAmelCase_							: Optional[Any]=None						,    )   ->Optional[int]:



														"""simple docstring"""



														snake_case_          =						parent
														snake_case_          =						batch_size
														snake_case_          =						image_size
														snake_case_          =						num_channels
														snake_case_          =						num_stages
														snake_case_          =						hidden_sizes
														snake_case_          =						depths
														snake_case_          =						is_training
														snake_case_          =						use_labels
														snake_case_          =						intermediate_size
														snake_case_          =						hidden_act
														snake_case_          =						num_labels
														snake_case_          =						initializer_range
														snake_case_          =						out_features
														snake_case_          =						out_indices
														snake_case_          =						scope



							def 						lowerCAmelCase    (			self							: Optional[int]    )   ->List[Any]:



														"""simple docstring"""



														snake_case_          =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

														snake_case_          =						None
														if self.use_labels:
																					snake_case_          =						ids_tensor([self.batch_size]						,    self.num_labels    )

														snake_case_          =						self.get_config()

														return config, pixel_values, labels



							def 						lowerCAmelCase    (			self							: Optional[int]    )   ->Optional[Any]:



														"""simple docstring"""



														return ConvNextVaConfig(
														    num_channels=self.num_channels						,    hidden_sizes=self.hidden_sizes						,    depths=self.depths						,    num_stages=self.num_stages						,    hidden_act=self.hidden_act						,    is_decoder=UpperCAmelCase_						,    initializer_range=self.initializer_range						,    out_features=self.out_features						,    out_indices=self.out_indices						,    num_labels=self.num_labels						,    )



							def 						lowerCAmelCase    (			self							: List[Any]						,    UpperCAmelCase_							: str						,    UpperCAmelCase_							: List[Any]						,    UpperCAmelCase_							: Tuple    )   ->str:



														"""simple docstring"""



														snake_case_          =						ConvNextVaModel(config=UpperCAmelCase_    )
														model.to(UpperCAmelCase_    )
														model.eval()
														snake_case_          =						model(UpperCAmelCase_    )
														# 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							: Optional[int]						,    UpperCAmelCase_							: Dict						,    UpperCAmelCase_							: Optional[int]						,    UpperCAmelCase_							: Optional[Any]    )   ->str:



														"""simple docstring"""



														snake_case_          =						ConvNextVaForImageClassification(UpperCAmelCase_    )
														model.to(UpperCAmelCase_    )
														model.eval()
														snake_case_          =						model(UpperCAmelCase_						,    labels=UpperCAmelCase_    )
														self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.num_labels)    )



							def 						lowerCAmelCase    (			self							: Dict						,    UpperCAmelCase_							: Dict						,    UpperCAmelCase_							: Dict						,    UpperCAmelCase_							: List[Any]    )   ->Any:



														"""simple docstring"""



														snake_case_          =						ConvNextVaBackbone(config=UpperCAmelCase_    )
														model.to(UpperCAmelCase_    )
														model.eval()
														snake_case_          =						model(UpperCAmelCase_    )

														# verify hidden states
														self.parent.assertEqual(len(result.feature_maps    )						,    len(config.out_features    )    )
														self.parent.assertListEqual(list(result.feature_maps[0].shape    )						,    [self.batch_size, self.hidden_sizes[1], 4, 4]    )

														# verify channels
														self.parent.assertEqual(len(model.channels    )						,    len(config.out_features    )    )
														self.parent.assertListEqual(model.channels						,    config.hidden_sizes[1:]    )

														# verify backbone works with out_features=None
														snake_case_          =						None
														snake_case_          =						ConvNextVaBackbone(config=UpperCAmelCase_    )
														model.to(UpperCAmelCase_    )
														model.eval()
														snake_case_          =						model(UpperCAmelCase_    )

														# verify feature maps
														self.parent.assertEqual(len(result.feature_maps    )						,    1    )
														self.parent.assertListEqual(list(result.feature_maps[0].shape    )						,    [self.batch_size, self.hidden_sizes[-1], 1, 1]    )

														# verify channels
														self.parent.assertEqual(len(model.channels    )						,    1    )
														self.parent.assertListEqual(model.channels						,    [config.hidden_sizes[-1]]    )



							def 						lowerCAmelCase    (			self							: str    )   ->Tuple:



														"""simple docstring"""



														snake_case_          =						self.prepare_config_and_inputs()
														snake_case_    ,  snake_case_    ,  snake_case_          =						config_and_inputs
														snake_case_          =						{"""pixel_values""": pixel_values}
														return config, inputs_dict



							def 						lowerCAmelCase    (			self							: Dict    )   ->Optional[int]:



														"""simple docstring"""



														snake_case_          =						self.prepare_config_and_inputs()
														snake_case_    ,  snake_case_    ,  snake_case_          =						config_and_inputs
														snake_case_          =						{"""pixel_values""": pixel_values, """labels""": labels}
														return config, inputs_dict





@require_torch
class        __A       (snake_case__  ,						snake_case__  ,						unittest.TestCase):





							'''simple docstring'''

							__lowercase:						Optional[int]							 =      (
							    (
							        ConvNextVaModel,
							        ConvNextVaForImageClassification,
							        ConvNextVaBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase:						str							 =      (
							    {"""feature-extraction""": ConvNextVaModel, """image-classification""": ConvNextVaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							__lowercase:						int							 =      False
							__lowercase:						str							 =      False
							__lowercase:						Union[str, Any]							 =      False
							__lowercase:						Dict							 =      False
							__lowercase:						Any							 =      False



							def 						lowerCAmelCase    (			self							: Union[str, Any]    )   ->int:



														"""simple docstring"""



														snake_case_          =						ConvNextVaModelTester(self    )
														snake_case_          =						ConfigTester(self						,    config_class=UpperCAmelCase_						,    has_text_modality=UpperCAmelCase_						,    hidden_size=37    )



							def 						lowerCAmelCase    (			self							: str    )   ->Optional[int]:



														"""simple docstring"""



														self.create_and_test_config_common_properties()
														self.config_tester.create_and_test_config_to_json_string()
														self.config_tester.create_and_test_config_to_json_file()
														self.config_tester.create_and_test_config_from_and_save_pretrained()
														self.config_tester.create_and_test_config_with_num_labels()
														self.config_tester.check_config_can_be_init_without_params()
														self.config_tester.check_config_arguments_init()



							def 						lowerCAmelCase    (			self							: Union[str, Any]    )   ->List[str]:



														"""simple docstring"""



														return



							@unittest.skip(reason="""ConvNextV2 does not use inputs_embeds"""    )
							def 						lowerCAmelCase    (			self							: int    )   ->int:



														"""simple docstring"""



														pass



							@unittest.skip(reason="""ConvNextV2 does not support input and output embeddings"""    )
							def 						lowerCAmelCase    (			self							: int    )   ->Optional[Any]:



														"""simple docstring"""



														pass



							@unittest.skip(reason="""ConvNextV2 does not use feedforward chunking"""    )
							def 						lowerCAmelCase    (			self							: List[str]    )   ->List[Any]:



														"""simple docstring"""



														pass



							def 						lowerCAmelCase    (			self							: List[str]    )   ->List[Any]:



														"""simple docstring"""



														if not self.model_tester.is_training:
																					return

														for model_class in self.all_model_classes:
																					snake_case_    ,  snake_case_          =						self.model_tester.prepare_config_and_inputs_with_labels()
																					snake_case_          =						True

																					if model_class.__name__ in [
																					    *get_values(UpperCAmelCase_    ),
																					    *get_values(UpperCAmelCase_    ),
																					]:
																												continue

																					snake_case_          =						model_class(UpperCAmelCase_    )
																					model.to(UpperCAmelCase_    )
																					model.train()
																					snake_case_          =						self._prepare_for_class(UpperCAmelCase_						,    UpperCAmelCase_						,    return_labels=UpperCAmelCase_    )
																					snake_case_          =						model(**UpperCAmelCase_    ).loss
																					loss.backward()



							def 						lowerCAmelCase    (			self							: List[str]    )   ->int:



														"""simple docstring"""



														if not self.model_tester.is_training:
																					return

														for model_class in self.all_model_classes:
																					snake_case_    ,  snake_case_          =						self.model_tester.prepare_config_and_inputs_with_labels()
																					snake_case_          =						False
																					snake_case_          =						True

																					if (
																					    model_class.__name__
																					    in [*get_values(UpperCAmelCase_    ), *get_values(UpperCAmelCase_    )]
																					    or not model_class.supports_gradient_checkpointing
																					):
																												continue

																					snake_case_          =						model_class(UpperCAmelCase_    )
																					model.to(UpperCAmelCase_    )
																					model.gradient_checkpointing_enable()
																					model.train()
																					snake_case_          =						self._prepare_for_class(UpperCAmelCase_						,    UpperCAmelCase_						,    return_labels=UpperCAmelCase_    )
																					snake_case_          =						model(**UpperCAmelCase_    ).loss
																					loss.backward()



							def 						lowerCAmelCase    (			self							: Dict    )   ->Optional[int]:



														"""simple docstring"""



														snake_case_    ,  snake_case_          =						self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					snake_case_          =						model_class(UpperCAmelCase_    )
																					snake_case_          =						inspect.signature(model.forward    )
																					# signature.parameters is an OrderedDict => so arg_names order is deterministic
																					snake_case_          =						[*signature.parameters.keys()]

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



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



														"""simple docstring"""



														snake_case_          =						self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*UpperCAmelCase_    )



							def 						lowerCAmelCase    (			self							: str    )   ->str:



														"""simple docstring"""



														def check_hidden_states_output(UpperCAmelCase_							: Tuple						,    UpperCAmelCase_							: Optional[int]						,    UpperCAmelCase_							: List[str]    ):
																					snake_case_          =						model_class(UpperCAmelCase_    )
																					model.to(UpperCAmelCase_    )
																					model.eval()

																					with torch.no_grad():
																												snake_case_          =						model(**self._prepare_for_class(UpperCAmelCase_						,    UpperCAmelCase_    )    )

																					snake_case_          =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																					snake_case_          =						self.model_tester.num_stages
																					self.assertEqual(len(UpperCAmelCase_    )						,    expected_num_stages + 1    )

																					# ConvNextV2'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 // 4, self.model_tester.image_size // 4]						,    )

														snake_case_    ,  snake_case_          =						self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					snake_case_          =						True
																					check_hidden_states_output(UpperCAmelCase_						,    UpperCAmelCase_						,    UpperCAmelCase_    )

																					# check that output_hidden_states also work using config
																					del inputs_dict["output_hidden_states"]
																					snake_case_          =						True

																					check_hidden_states_output(UpperCAmelCase_						,    UpperCAmelCase_						,    UpperCAmelCase_    )



							def 						lowerCAmelCase    (			self							: str    )   ->int:



														"""simple docstring"""



														snake_case_          =						self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_    )



							@slow
							def 						lowerCAmelCase    (			self							: Dict    )   ->str:



														"""simple docstring"""



														for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					snake_case_          =						ConvNextVaModel.from_pretrained(UpperCAmelCase_    )
																					self.assertIsNotNone(UpperCAmelCase_    )







def   _a			( )      ->			str:
							snake_case_          =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
							return image





@require_torch
@require_vision
class        __A       (unittest.TestCase):





							'''simple docstring'''

							@cached_property
							def 						lowerCAmelCase    (			self							: Tuple    )   ->Union[str, Any]:



														"""simple docstring"""



														return AutoImageProcessor.from_pretrained("""facebook/convnextv2-tiny-1k-224"""    ) if is_vision_available() else None



							@slow
							def 						lowerCAmelCase    (			self							: int    )   ->Optional[Any]:



														"""simple docstring"""



														snake_case_          =						ConvNextVaForImageClassification.from_pretrained("""facebook/convnextv2-tiny-1k-224"""    ).to(UpperCAmelCase_    )

														snake_case_          =						self.default_image_processor
														snake_case_          =						prepare_img()
														snake_case_          =						preprocessor(images=UpperCAmelCase_						,    return_tensors="""pt"""    ).to(UpperCAmelCase_    )

														# forward pass
														with torch.no_grad():
																					snake_case_          =						model(**UpperCAmelCase_    )

														# verify the logits
														snake_case_          =						torch.Size((1, 1_000)    )
														self.assertEqual(outputs.logits.shape						,    UpperCAmelCase_    )

														snake_case_          =						torch.tensor([0.9_996, 0.1_966, -0.4_386]    ).to(UpperCAmelCase_    )
														self.assertTrue(torch.allclose(outputs.logits[0, :3]						,    UpperCAmelCase_						,    atol=1E-4    )    )







"""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        __A       (snake_case__  ,						snake_case__  ,						unittest.TestCase):





							'''simple docstring'''

							__lowercase:						List[Any]							 =      CycleDiffusionPipeline
							__lowercase:						int							 =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
							    """negative_prompt""",
							    """height""",
							    """width""",
							    """negative_prompt_embeds""",
							}
							__lowercase:						str							 =      PipelineTesterMixin.required_optional_params - {"""latents"""}
							__lowercase:						Any							 =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""source_prompt"""})
							__lowercase:						Any							 =      IMAGE_TO_IMAGE_IMAGE_PARAMS
							__lowercase:						Any							 =      IMAGE_TO_IMAGE_IMAGE_PARAMS



							def 						lowerCAmelCase    (			self							: Dict    )   ->Any:



														"""simple docstring"""



														torch.manual_seed(0    )
														snake_case_          =						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						,    )
														snake_case_          =						DDIMScheduler(
														    beta_start=0.00_085						,    beta_end=0.012						,    beta_schedule="""scaled_linear"""						,    num_train_timesteps=1_000						,    clip_sample=UpperCAmelCase_						,    set_alpha_to_one=UpperCAmelCase_						,    )
														torch.manual_seed(0    )
														snake_case_          =						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    )
														snake_case_          =						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						,    )
														snake_case_          =						CLIPTextModel(UpperCAmelCase_    )
														snake_case_          =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

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



							def 						lowerCAmelCase    (			self							: int						,    UpperCAmelCase_							: str						,    UpperCAmelCase_							: List[str]=0    )   ->str:



														"""simple docstring"""



														snake_case_          =						floats_tensor((1, 3, 32, 32)						,    rng=random.Random(UpperCAmelCase_    )    ).to(UpperCAmelCase_    )
														snake_case_          =						image / 2 + 0.5
														if str(UpperCAmelCase_    ).startswith("""mps"""    ):
																					snake_case_          =						torch.manual_seed(UpperCAmelCase_    )
														else:
																					snake_case_          =						torch.Generator(device=UpperCAmelCase_    ).manual_seed(UpperCAmelCase_    )
														snake_case_          =						{
														    """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							: Union[str, Any]    )   ->Union[str, Any]:



														"""simple docstring"""



														snake_case_          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator

														snake_case_          =						self.get_dummy_components()
														snake_case_          =						CycleDiffusionPipeline(**UpperCAmelCase_    )
														snake_case_          =						pipe.to(UpperCAmelCase_    )
														pipe.set_progress_bar_config(disable=UpperCAmelCase_    )

														snake_case_          =						self.get_dummy_inputs(UpperCAmelCase_    )
														snake_case_          =						pipe(**UpperCAmelCase_    )
														snake_case_          =						output.images

														snake_case_          =						images[0, -3:, -3:, -1]

														assert images.shape == (1, 32, 32, 3)
														snake_case_          =						np.array([0.4_459, 0.4_943, 0.4_544, 0.6_643, 0.5_474, 0.4_327, 0.5_701, 0.5_959, 0.5_179]    )

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



							@unittest.skipIf(torch_device != """cuda"""						,    """This test requires a GPU"""    )
							def 						lowerCAmelCase    (			self							: Union[str, Any]    )   ->str:



														"""simple docstring"""



														snake_case_          =						self.get_dummy_components()
														for name, module in components.items():
																					if hasattr(UpperCAmelCase_						,    """half"""    ):
																												snake_case_          =						module.half()
														snake_case_          =						CycleDiffusionPipeline(**UpperCAmelCase_    )
														snake_case_          =						pipe.to(UpperCAmelCase_    )
														pipe.set_progress_bar_config(disable=UpperCAmelCase_    )

														snake_case_          =						self.get_dummy_inputs(UpperCAmelCase_    )
														snake_case_          =						pipe(**UpperCAmelCase_    )
														snake_case_          =						output.images

														snake_case_          =						images[0, -3:, -3:, -1]

														assert images.shape == (1, 32, 32, 3)
														snake_case_          =						np.array([0.3_506, 0.4_543, 0.446, 0.4_575, 0.5_195, 0.4_155, 0.5_273, 0.518, 0.4_116]    )

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



							@skip_mps
							def 						lowerCAmelCase    (			self							: Tuple    )   ->Optional[int]:



														"""simple docstring"""



														return super().test_save_load_local()



							@unittest.skip("""non-deterministic pipeline"""    )
							def 						lowerCAmelCase    (			self							: int    )   ->Optional[int]:



														"""simple docstring"""



														return super().test_inference_batch_single_identical()



							@skip_mps
							def 						lowerCAmelCase    (			self							: Tuple    )   ->List[Any]:



														"""simple docstring"""



														return super().test_dict_tuple_outputs_equivalent()



							@skip_mps
							def 						lowerCAmelCase    (			self							: Any    )   ->Tuple:



														"""simple docstring"""



														return super().test_save_load_optional_components()



							@skip_mps
							def 						lowerCAmelCase    (			self							: List[Any]    )   ->str:



														"""simple docstring"""



														return super().test_attention_slicing_forward_pass()





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





							'''simple docstring'''

							def 						lowerCAmelCase    (			self							: List[Any]    )   ->Optional[int]:



														"""simple docstring"""



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



							def 						lowerCAmelCase    (			self							: Optional[int]    )   ->str:



														"""simple docstring"""



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

														snake_case_          =						"""CompVis/stable-diffusion-v1-4"""
														snake_case_          =						DDIMScheduler.from_pretrained(UpperCAmelCase_						,    subfolder="""scheduler"""    )
														snake_case_          =						CycleDiffusionPipeline.from_pretrained(
														    UpperCAmelCase_						,    scheduler=UpperCAmelCase_						,    safety_checker=UpperCAmelCase_						,    torch_dtype=torch.floataa						,    revision="""fp16"""    )

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

														snake_case_          =						"""A black colored car"""
														snake_case_          =						"""A blue colored car"""

														snake_case_          =						torch.manual_seed(0    )
														snake_case_          =						pipe(
														    prompt=UpperCAmelCase_						,    source_prompt=UpperCAmelCase_						,    image=UpperCAmelCase_						,    num_inference_steps=100						,    eta=0.1						,    strength=0.85						,    guidance_scale=3						,    source_guidance_scale=1						,    generator=UpperCAmelCase_						,    output_type="""np"""						,    )
														snake_case_          =						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							: Tuple    )   ->List[str]:



														"""simple docstring"""



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

														snake_case_          =						"""CompVis/stable-diffusion-v1-4"""
														snake_case_          =						DDIMScheduler.from_pretrained(UpperCAmelCase_						,    subfolder="""scheduler"""    )
														snake_case_          =						CycleDiffusionPipeline.from_pretrained(UpperCAmelCase_						,    scheduler=UpperCAmelCase_						,    safety_checker=UpperCAmelCase_    )

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

														snake_case_          =						"""A black colored car"""
														snake_case_          =						"""A blue colored car"""

														snake_case_          =						torch.manual_seed(0    )
														snake_case_          =						pipe(
														    prompt=UpperCAmelCase_						,    source_prompt=UpperCAmelCase_						,    image=UpperCAmelCase_						,    num_inference_steps=100						,    eta=0.1						,    strength=0.85						,    guidance_scale=3						,    source_guidance_scale=1						,    generator=UpperCAmelCase_						,    output_type="""np"""						,    )
														snake_case_          =						output.images

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



