




import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
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 torch import nn

					from transformers import SwiftFormerForImageClassification, SwiftFormerModel
					from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import ViTImageProcessor







class     __lowerCAmelCase :

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__			,						lowerCamelCase__=13			,						lowerCamelCase__=3			,						lowerCamelCase__=True			,						lowerCamelCase__=True			,						lowerCamelCase__=0.1			,						lowerCamelCase__=0.1			,						lowerCamelCase__=224			,						lowerCamelCase__=1_000			,						lowerCamelCase__=[3, 3, 6, 4]			,						lowerCamelCase__=[48, 56, 112, 220]			,						)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    parent
							__lowerCamelCase		       =    batch_size
							__lowerCamelCase		       =    num_channels
							__lowerCamelCase		       =    is_training
							__lowerCamelCase		       =    use_labels
							__lowerCamelCase		       =    hidden_dropout_prob
							__lowerCamelCase		       =    attention_probs_dropout_prob
							__lowerCamelCase		       =    num_labels
							__lowerCamelCase		       =    image_size
							__lowerCamelCase		       =    layer_depths
							__lowerCamelCase		       =    embed_dims


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



							'''simple docstring'''
							__lowerCamelCase		       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

							__lowerCamelCase		       =    self.get_config()

							return config, pixel_values, labels


			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							return SwiftFormerConfig(
							    depths=self.layer_depths			,						embed_dims=self.embed_dims			,						mlp_ratio=4			,						downsamples=[True, True, True, True]			,						hidden_act='gelu'			,						num_labels=self.num_labels			,						down_patch_size=3			,						down_stride=2			,						down_pad=1			,						drop_rate=0.0			,						drop_path_rate=0.0			,						use_layer_scale=lowerCamelCase__			,						layer_scale_init_value=1e-5			,						)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerModel(config=lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()
							__lowerCamelCase		       =    model(lowerCamelCase__							)
							self.parent.assertEqual(result.last_hidden_state.shape			,						(self.batch_size, self.embed_dims[-1], 7, 7)							)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      Dict:



							'''simple docstring'''
							__lowerCamelCase		       =    self.num_labels
							__lowerCamelCase		       =    SwiftFormerForImageClassification(lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()
							__lowerCamelCase		       =    model(lowerCamelCase__			,						labels=lowerCamelCase__							)
							self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)							)

							__lowerCamelCase		       =    SwiftFormerForImageClassification(lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()

							__lowerCamelCase		       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
							__lowerCamelCase		       =    model(lowerCamelCase__							)
							self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)							)






			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							((__lowerCamelCase)       ,						(__lowerCamelCase)       ,						(__lowerCamelCase))		       =    self.prepare_config_and_inputs()
							__lowerCamelCase		       =    {'pixel_values': pixel_values}
							return config, inputs_dict







@require_torch
class     __lowerCAmelCase (       __magic_name__			,				__magic_name__			,				unittest.TestCase ):

			"""simple docstring"""







			snake_case_   		=       (SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
			snake_case_   		=       (
			    {'''feature-extraction''': SwiftFormerModel, '''image-classification''': SwiftFormerForImageClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False


			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerModelTester(self							)
							__lowerCamelCase		       =    ConfigTester(
							    self			,						config_class=lowerCamelCase__			,						has_text_modality=lowerCamelCase__			,						hidden_size=37			,						num_attention_heads=12			,						num_hidden_layers=12			,						)


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



							'''simple docstring'''
							self.config_tester.run_common_tests()


			@unittest.skip(reason='SwiftFormer does not use inputs_embeds'							)
			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							pass


			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											__lowerCamelCase		       =    model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(lowerCamelCase__			,						nn.Linear							)							)


			def       lowercase_    (      self							)    ->      Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowerCamelCase		       =    ['pixel_values']
											self.assertListEqual(arg_names[:1]			,						lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__							)


			@slow
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCamelCase		       =    SwiftFormerModel.from_pretrained(lowerCamelCase__							)
											self.assertIsNotNone(lowerCamelCase__							)


			@unittest.skip(reason='SwiftFormer does not output attentions'							)
			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							pass


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



							'''simple docstring'''
							def check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							):
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											model.to(lowerCamelCase__							)
											model.eval()

											with torch.no_grad():
															__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)

											__lowerCamelCase		       =    outputs.hidden_states

											__lowerCamelCase		       =    8
											self.assertEqual(len(lowerCamelCase__							)			,						lowerCamelCase__							)  # TODO

											# SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
											# with the width and height being successively divided by 2, after every 2 blocks
											for i in range(len(lowerCamelCase__							)							):
															self.assertEqual(
															    hidden_states[i].shape			,						torch.Size(
															        [
															            self.model_tester.batch_size,
															            self.model_tester.embed_dims[i // 2],
															            (self.model_tester.image_size // 4) // 2 ** (i // 2),
															            (self.model_tester.image_size // 4) // 2 ** (i // 2),
															        ]							)			,						)

							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    True
											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)

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

											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)


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



							'''simple docstring'''
							def _config_zero_init(lowerCamelCase__							):
											__lowerCamelCase		       =    copy.deepcopy(lowerCamelCase__							)
											for key in configs_no_init.__dict__.keys():
															if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
																			setattr(lowerCamelCase__			,						lowerCamelCase__			,						1e-10							)
															if isinstance(getattr(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)			,						lowerCamelCase__							):
																			__lowerCamelCase		       =    _config_zero_init(getattr(lowerCamelCase__			,						lowerCamelCase__							)							)
																			setattr(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)
											return configs_no_init

							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							__lowerCamelCase		       =    _config_zero_init(lowerCamelCase__							)
							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    model_class(config=lowerCamelCase__							)
											for name, param in model.named_parameters():
															if param.requires_grad:
																			self.assertIn(
																			    ((param.data.mean() * 1e9) / 1e9).round().item()			,						[0.0, 1.0]			,						msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""			,						)






			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'							)
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							pass







def 			lowerCamelCase_		(       )     ->       Tuple:





				"""simple docstring"""


				__lowerCamelCase		       =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
				return image







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

			"""simple docstring"""







			@cached_property
			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							return ViTImageProcessor.from_pretrained('MBZUAI/swiftformer-xs'							) if is_vision_available() else None






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



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerForImageClassification.from_pretrained('MBZUAI/swiftformer-xs'							).to(lowerCamelCase__							)

							__lowerCamelCase		       =    self.default_image_processor
							__lowerCamelCase		       =    prepare_img()
							__lowerCamelCase		       =    image_processor(images=lowerCamelCase__			,						return_tensors='pt'							).to(lowerCamelCase__							)

							# forward pass
							with torch.no_grad():
											__lowerCamelCase		       =    model(**lowerCamelCase__							)

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

							__lowerCamelCase		       =    torch.tensor([[-2.17_03e00, 2.11_07e00, -2.08_11e00]]							).to(lowerCamelCase__							)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]			,						lowerCamelCase__			,						atol=1e-4							)							)



"""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 				a (						lowerCAmelCase_		,							lowerCAmelCase_		,							lowerCAmelCase_		,							unittest.TestCase      ):
    _snake_case   :     int   							=							StableUnCLIPPipeline
    _snake_case   :     str   							=							TEXT_TO_IMAGE_PARAMS
    _snake_case   :     Any   							=							TEXT_TO_IMAGE_BATCH_PARAMS
    _snake_case   :     Optional[Any]   							=							TEXT_TO_IMAGE_IMAGE_PARAMS
    _snake_case   :     str   							=							TEXT_TO_IMAGE_IMAGE_PARAMS

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


    def    lowerCAmelCase_     (    self		:     Optional[int]    ):
      _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=__lowerCAmelCase      , projection_dim=__lowerCAmelCase      , intermediate_size=37      , layer_norm_eps=1e-0_5      , 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=__lowerCAmelCase      , num_layers=1      , )

      torch.manual_seed(0    )
      _UpperCAmelCase         =					DDPMScheduler(
          variance_type="""fixed_small_log"""      , prediction_type="""sample"""      , num_train_timesteps=1000      , clip_sample=__lowerCAmelCase      , clip_sample_range=5.0      , beta_schedule="""squaredcos_cap_v2"""      , )

      # regular denoising components

      torch.manual_seed(0    )
      _UpperCAmelCase         =					StableUnCLIPImageNormalizer(embedding_dim=__lowerCAmelCase    )
      _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=__lowerCAmelCase      , projection_dim=32      , intermediate_size=37      , layer_norm_eps=1e-0_5      , 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=__lowerCAmelCase      , layers_per_block=1      , upcast_attention=__lowerCAmelCase      , use_linear_projection=__lowerCAmelCase      , )

      torch.manual_seed(0    )
      _UpperCAmelCase         =					DDIMScheduler(
          beta_schedule="""scaled_linear"""      , beta_start=0.00_085      , beta_end=0.012      , prediction_type="""v_prediction"""      , set_alpha_to_one=__lowerCAmelCase      , 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    lowerCAmelCase_     (    self		:     Optional[int]      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     str=0    ):
      if str(__lowerCAmelCase    ).startswith("""mps"""    ):
        _UpperCAmelCase         =					torch.manual_seed(__lowerCAmelCase    )
      else:
        _UpperCAmelCase         =					torch.Generator(device=__lowerCAmelCase    ).manual_seed(__lowerCAmelCase    )
      _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    lowerCAmelCase_     (    self		:     Optional[int]    ):
      _UpperCAmelCase         =					torch_device == """cpu"""

      self._test_attention_slicing_forward_pass(test_max_difference=__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     List[str]    ):
      _UpperCAmelCase         =					torch_device in ["""cpu""", """mps"""]

      self._test_inference_batch_single_identical(test_max_difference=__lowerCAmelCase    )



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


    def    lowerCAmelCase_     (    self		:     str    ):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()


    def    lowerCAmelCase_     (    self		:     List[Any]    ):
      _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(__lowerCAmelCase    )
      pipe.set_progress_bar_config(disable=__lowerCAmelCase    )
      # 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=__lowerCAmelCase      , output_type="""np"""    )

      _UpperCAmelCase         =					output.images[0]

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

      assert_mean_pixel_difference(__lowerCAmelCase      , __lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     Any    ):
      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(__lowerCAmelCase    )
      pipe.set_progress_bar_config(disable=__lowerCAmelCase    )
      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
