






'''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 (       __snake_case   ,    __snake_case   ,    unittest.TestCase ):




    '''simple docstring'''







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






    def       _UpperCamelCase    (       self )							-> Optional[int]:
         torch.manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			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    ,							)
         SCREAMING_SNAKE_CASE					:			Dict    	=       DDIMScheduler(
             beta_start=0.0_0_0_8_5    ,							beta_end=0.0_1_2    ,							beta_schedule='scaled_linear'    ,							num_train_timesteps=1_000    ,							clip_sample=A_    ,							set_alpha_to_one=A_    ,							)
         torch.manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       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 )
         SCREAMING_SNAKE_CASE					:			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    ,							)
         SCREAMING_SNAKE_CASE					:			Dict    	=       CLIPTextModel(A_ )
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

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






    def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__=0 )							-> int:
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       floats_tensor((1, 3, 32, 32)    ,							rng=random.Random(A_ ) ).to(A_ )
         SCREAMING_SNAKE_CASE					:			Dict    	=       image / 2 + 0.5
         if str(A_ ).startswith('mps' ):
              SCREAMING_SNAKE_CASE					:			Dict    	=       torch.manual_seed(A_ )
         else:
              SCREAMING_SNAKE_CASE					:			List[str]    	=       torch.Generator(device=A_ ).manual_seed(A_ )
         SCREAMING_SNAKE_CASE					:			Tuple    	=       {
             "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       _UpperCamelCase    (       self )							-> str:
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       "cpu"  # ensure determinism for the device-dependent torch.Generator

         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       self.get_dummy_components()
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       CycleDiffusionPipeline(**A_ )
         SCREAMING_SNAKE_CASE					:			int    	=       pipe.to(A_ )
         pipe.set_progress_bar_config(disable=A_ )

         SCREAMING_SNAKE_CASE					:			List[str]    	=       self.get_dummy_inputs(A_ )
         SCREAMING_SNAKE_CASE					:			List[str]    	=       pipe(**A_ )
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       output.images

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

         assert images.shape == (1, 32, 32, 3)
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       np.array([0.4_4_5_9, 0.4_9_4_3, 0.4_5_4_4, 0.6_6_4_3, 0.5_4_7_4, 0.4_3_2_7, 0.5_7_0_1, 0.5_9_5_9, 0.5_1_7_9] )

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






    @unittest.skipIf(torch_device != 'cuda'    ,							'This test requires a GPU' )
    def       _UpperCamelCase    (       self )							-> Optional[Any]:
         SCREAMING_SNAKE_CASE					:			List[str]    	=       self.get_dummy_components()
         for name, module in components.items():
              if hasattr(A_    ,							'half' ):
                   SCREAMING_SNAKE_CASE					:			List[Any]    	=       module.half()
         SCREAMING_SNAKE_CASE					:			int    	=       CycleDiffusionPipeline(**A_ )
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       pipe.to(A_ )
         pipe.set_progress_bar_config(disable=A_ )

         SCREAMING_SNAKE_CASE					:			Tuple    	=       self.get_dummy_inputs(A_ )
         SCREAMING_SNAKE_CASE					:			str    	=       pipe(**A_ )
         SCREAMING_SNAKE_CASE					:			Dict    	=       output.images

         SCREAMING_SNAKE_CASE					:			Dict    	=       images[0, -3:, -3:, -1]

         assert images.shape == (1, 32, 32, 3)
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       np.array([0.3_5_0_6, 0.4_5_4_3, 0.4_4_6, 0.4_5_7_5, 0.5_1_9_5, 0.4_1_5_5, 0.5_2_7_3, 0.5_1_8, 0.4_1_1_6] )

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






    @skip_mps
    def       _UpperCamelCase    (       self )							-> Union[str, Any]:
         return super().test_save_load_local()






    @unittest.skip('non-deterministic pipeline' )
    def       _UpperCamelCase    (       self )							-> Optional[int]:
         return super().test_inference_batch_single_identical()






    @skip_mps
    def       _UpperCamelCase    (       self )							-> List[str]:
         return super().test_dict_tuple_outputs_equivalent()






    @skip_mps
    def       _UpperCamelCase    (       self )							-> Optional[Any]:
         return super().test_save_load_optional_components()






    @skip_mps
    def       _UpperCamelCase    (       self )							-> Tuple:
         return super().test_attention_slicing_forward_pass()






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




    '''simple docstring'''







    def       _UpperCamelCase    (       self )							-> Optional[Any]:
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






    def       _UpperCamelCase    (       self )							-> List[str]:
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/cycle-diffusion/black_colored_car.png' )
         SCREAMING_SNAKE_CASE					:			Any    	=       load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy' )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       init_image.resize((512, 512) )

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

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

         SCREAMING_SNAKE_CASE					:			List[str]    	=       "A black colored car"
         SCREAMING_SNAKE_CASE					:			str    	=       "A blue colored car"

         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       torch.manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			Any    	=       pipe(
             prompt=A_    ,							source_prompt=A_    ,							image=A_    ,							num_inference_steps=100    ,							eta=0.1    ,							strength=0.8_5    ,							guidance_scale=3    ,							source_guidance_scale=1    ,							generator=A_    ,							output_type='np'    ,							)
         SCREAMING_SNAKE_CASE					:			Dict    	=       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       _UpperCamelCase    (       self )							-> Optional[int]:
         SCREAMING_SNAKE_CASE					:			str    	=       load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/cycle-diffusion/black_colored_car.png' )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy' )
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       init_image.resize((512, 512) )

         SCREAMING_SNAKE_CASE					:			str    	=       "CompVis/stable-diffusion-v1-4"
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       DDIMScheduler.from_pretrained(A_    ,							subfolder='scheduler' )
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       CycleDiffusionPipeline.from_pretrained(A_    ,							scheduler=A_    ,							safety_checker=A_ )

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

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       "A black colored car"
         SCREAMING_SNAKE_CASE					:			Tuple    	=       "A blue colored car"

         SCREAMING_SNAKE_CASE					:			List[str]    	=       torch.manual_seed(0 )
         SCREAMING_SNAKE_CASE					:			List[str]    	=       pipe(
             prompt=A_    ,							source_prompt=A_    ,							image=A_    ,							num_inference_steps=100    ,							eta=0.1    ,							strength=0.8_5    ,							guidance_scale=3    ,							source_guidance_scale=1    ,							generator=A_    ,							output_type='np'    ,							)
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       output.images

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




'''simple docstring'''





import warnings
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  :str  				=    logging.get_logger(__name__)

_lowerCAmelCase  :Optional[int]  				=    {
    """nvidia/segformer-b0-finetuned-ade-512-512""": (
        """https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json"""
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}






class 				UpperCAmelCase (       _SCREAMING_SNAKE_CASE ):




    '''simple docstring'''







    snake_case__							:   Optional[int]							=						"segformer"






    def __init__(       self    ,							lowercase__=3    ,							lowercase__=4    ,							lowercase__=[2, 2, 2, 2]    ,							lowercase__=[8, 4, 2, 1]    ,							lowercase__=[32, 64, 160, 256]    ,							lowercase__=[7, 3, 3, 3]    ,							lowercase__=[4, 2, 2, 2]    ,							lowercase__=[1, 2, 5, 8]    ,							lowercase__=[4, 4, 4, 4]    ,							lowercase__="gelu"    ,							lowercase__=0.0    ,							lowercase__=0.0    ,							lowercase__=0.1    ,							lowercase__=0.0_2    ,							lowercase__=0.1    ,							lowercase__=1E-6    ,							lowercase__=256    ,							lowercase__=255    ,							**lowercase__    ,							)							-> Union[str, Any]:
         super().__init__(**lowercase__ )

         if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
              warnings.warn(
                  'Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be'
                  ' removed, as the behaviour will default to that of reshape_last_stage = True.'    ,							lowercase__    ,							)

         SCREAMING_SNAKE_CASE					:			int    	=       num_channels
         SCREAMING_SNAKE_CASE					:			int    	=       num_encoder_blocks
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       depths
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       sr_ratios
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       hidden_sizes
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       patch_sizes
         SCREAMING_SNAKE_CASE					:			int    	=       strides
         SCREAMING_SNAKE_CASE					:			Tuple    	=       mlp_ratios
         SCREAMING_SNAKE_CASE					:			List[str]    	=       num_attention_heads
         SCREAMING_SNAKE_CASE					:			List[str]    	=       hidden_act
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       hidden_dropout_prob
         SCREAMING_SNAKE_CASE					:			Tuple    	=       attention_probs_dropout_prob
         SCREAMING_SNAKE_CASE					:			Tuple    	=       classifier_dropout_prob
         SCREAMING_SNAKE_CASE					:			Any    	=       initializer_range
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       drop_path_rate
         SCREAMING_SNAKE_CASE					:			int    	=       layer_norm_eps
         SCREAMING_SNAKE_CASE					:			Any    	=       decoder_hidden_size
         SCREAMING_SNAKE_CASE					:			List[str]    	=       kwargs.get('reshape_last_stage'    ,							lowercase__ )
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       semantic_loss_ignore_index






class 				UpperCAmelCase (       _SCREAMING_SNAKE_CASE ):




    '''simple docstring'''







    snake_case__							:   Tuple							=						version.parse("1.11" )






    @property
    def       _UpperCamelCase    (       self )							-> Mapping[str, Mapping[int, str]]:
         return OrderedDict(
             [
                 ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
             ] )






    @property
    def       _UpperCamelCase    (       self )							-> float:
         return 1E-4






    @property
    def       _UpperCamelCase    (       self )							-> int:
         return 12



