




import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)







def 		_A(       UpperCamelCase__							:			List[Any]				,       UpperCamelCase__							:			List[str]=False				)    -> str:
							'''simple docstring'''


							__lowercase      =    []
							for i in range(config.num_hidden_layers				):
														# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
														rename_keys.append((F'module.blocks.{i}.norm1.weight', F'vit.encoder.layer.{i}.layernorm_before.weight')				)
														rename_keys.append((F'module.blocks.{i}.norm1.bias', F'vit.encoder.layer.{i}.layernorm_before.bias')				)
														rename_keys.append(
														    (F'module.blocks.{i}.attn.proj.weight', F'vit.encoder.layer.{i}.attention.output.dense.weight')				)
														rename_keys.append((F'module.blocks.{i}.attn.proj.bias', F'vit.encoder.layer.{i}.attention.output.dense.bias')				)
														rename_keys.append((F'module.blocks.{i}.norm2.weight', F'vit.encoder.layer.{i}.layernorm_after.weight')				)
														rename_keys.append((F'module.blocks.{i}.norm2.bias', F'vit.encoder.layer.{i}.layernorm_after.bias')				)
														rename_keys.append((F'module.blocks.{i}.mlp.fc1.weight', F'vit.encoder.layer.{i}.intermediate.dense.weight')				)
														rename_keys.append((F'module.blocks.{i}.mlp.fc1.bias', F'vit.encoder.layer.{i}.intermediate.dense.bias')				)
														rename_keys.append((F'module.blocks.{i}.mlp.fc2.weight', F'vit.encoder.layer.{i}.output.dense.weight')				)
														rename_keys.append((F'module.blocks.{i}.mlp.fc2.bias', F'vit.encoder.layer.{i}.output.dense.bias')				)

							# projection layer + position embeddings
							rename_keys.extend(
							    [
							        ('''module.cls_token''', '''vit.embeddings.cls_token'''),
							        ('''module.patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight'''),
							        ('''module.patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias'''),
							        ('''module.pos_embed''', '''vit.embeddings.position_embeddings'''),
							    ]				)

							if base_model:
														# layernorm + pooler
														rename_keys.extend(
														    [
														        ('''module.norm.weight''', '''layernorm.weight'''),
														        ('''module.norm.bias''', '''layernorm.bias'''),
														    ]				)

														# if just the base model, we should remove "vit" from all keys that start with "vit"
														__lowercase      =    [(pair[0], pair[1][4:]) if pair[1].startswith('''vit'''				) else pair for pair in rename_keys]
							else:
														# layernorm + classification head
														rename_keys.extend(
														    [
														        ('''norm.weight''', '''vit.layernorm.weight'''),
														        ('''norm.bias''', '''vit.layernorm.bias'''),
														        ('''head.weight''', '''classifier.weight'''),
														        ('''head.bias''', '''classifier.bias'''),
														    ]				)

							return rename_keys







def 		_A(       UpperCamelCase__							:			Dict				,       UpperCamelCase__							:			Dict				,       UpperCamelCase__							:			List[Any]=False				)    -> Dict:
							'''simple docstring'''


							for i in range(config.num_hidden_layers				):
														if base_model:
																					__lowercase      =    ''''''
														else:
																					__lowercase      =    '''vit.'''
														# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
														__lowercase      =    state_dict.pop(F'module.blocks.{i}.attn.qkv.weight'				)
														__lowercase      =    state_dict.pop(F'module.blocks.{i}.attn.qkv.bias'				)
														# next, add query, keys and values (in that order) to the state dict
														__lowercase      =    in_proj_weight[
														    : config.hidden_size, :
														]
														__lowercase      =    in_proj_bias[: config.hidden_size]
														__lowercase      =    in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														__lowercase      =    in_proj_bias[
														    config.hidden_size : config.hidden_size * 2
														]
														__lowercase      =    in_proj_weight[
														    -config.hidden_size :, :
														]
														__lowercase      =    in_proj_bias[-config.hidden_size :]







def 		_A(       UpperCamelCase__							:			Optional[Any]				)    -> int:
							'''simple docstring'''


							__lowercase      =    ['''head.weight''', '''head.bias''']
							for k in ignore_keys:
														state_dict.pop(__UpperCAmelCase				,       __UpperCAmelCase				)







def 		_A(       UpperCamelCase__							:			Tuple				)    -> int:
							'''simple docstring'''


							__lowercase      =    [
							    '''module.fc.fc1.weight''',
							    '''module.fc.fc1.bias''',
							    '''module.fc.bn1.weight''',
							    '''module.fc.bn1.bias''',
							    '''module.fc.bn1.running_mean''',
							    '''module.fc.bn1.running_var''',
							    '''module.fc.bn1.num_batches_tracked''',
							    '''module.fc.fc2.weight''',
							    '''module.fc.fc2.bias''',
							    '''module.fc.bn2.weight''',
							    '''module.fc.bn2.bias''',
							    '''module.fc.bn2.running_mean''',
							    '''module.fc.bn2.running_var''',
							    '''module.fc.bn2.num_batches_tracked''',
							    '''module.fc.fc3.weight''',
							    '''module.fc.fc3.bias''',
							]
							for k in ignore_keys:
														state_dict.pop(__UpperCAmelCase				,       __UpperCAmelCase				)







def 		_A(       UpperCamelCase__							:			Any				,       UpperCamelCase__							:			Any				,       UpperCamelCase__							:			Any				)    -> Dict:
							'''simple docstring'''


							__lowercase      =    dct.pop(__UpperCAmelCase				)
							__lowercase      =    val







def 		_A(       UpperCamelCase__							:			str				,       UpperCamelCase__							:			List[str]				)    -> Dict:
							'''simple docstring'''


							__lowercase      =    ViTMSNConfig()
							__lowercase      =    1000

							__lowercase      =    '''datasets/huggingface/label-files'''
							__lowercase      =    '''imagenet-1k-id2label.json'''
							__lowercase      =    json.load(open(hf_hub_download(__UpperCAmelCase				,       __UpperCAmelCase				)				,       '''r'''				)				)
							__lowercase      =    {int(__UpperCAmelCase				): v for k, v in idalabel.items()}
							__lowercase      =    idalabel
							__lowercase      =    {v: k for k, v in idalabel.items()}

							if "s16" in checkpoint_url:
														__lowercase      =    384
														__lowercase      =    1536
														__lowercase      =    6
							elif "l16" in checkpoint_url:
														__lowercase      =    1024
														__lowercase      =    4096
														__lowercase      =    24
														__lowercase      =    16
														__lowercase      =    0.1
							elif "b4" in checkpoint_url:
														__lowercase      =    4
							elif "l7" in checkpoint_url:
														__lowercase      =    7
														__lowercase      =    1024
														__lowercase      =    4096
														__lowercase      =    24
														__lowercase      =    16
														__lowercase      =    0.1

							__lowercase      =    ViTMSNModel(__UpperCAmelCase				)

							__lowercase      =    torch.hub.load_state_dict_from_url(__UpperCAmelCase				,       map_location='''cpu'''				)['''target_encoder''']

							__lowercase      =    ViTImageProcessor(size=config.image_size				)

							remove_projection_head(__UpperCAmelCase				)
							__lowercase      =    create_rename_keys(__UpperCAmelCase				,       base_model=__UpperCAmelCase				)

							for src, dest in rename_keys:
														rename_key(__UpperCAmelCase				,       __UpperCAmelCase				,       __UpperCAmelCase				)
							read_in_q_k_v(__UpperCAmelCase				,       __UpperCAmelCase				,       base_model=__UpperCAmelCase				)

							model.load_state_dict(__UpperCAmelCase				)
							model.eval()

							__lowercase      =    '''http://images.cocodataset.org/val2017/000000039769.jpg'''

							__lowercase      =    Image.open(requests.get(__UpperCAmelCase				,       stream=__UpperCAmelCase				).raw				)
							__lowercase      =    ViTImageProcessor(
							    size=config.image_size				,       image_mean=__UpperCAmelCase				,       image_std=__UpperCAmelCase				)
							__lowercase      =    image_processor(images=__UpperCAmelCase				,       return_tensors='''pt'''				)

							# forward pass
							torch.manual_seed(2				)
							__lowercase      =    model(**__UpperCAmelCase				)
							__lowercase      =    outputs.last_hidden_state

							# The following Colab Notebook was used to generate these outputs:
							# https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
							if "s16" in checkpoint_url:
														__lowercase      =    torch.tensor([[-1.0915, -1.4876, -1.1809]]				)
							elif "b16" in checkpoint_url:
														__lowercase      =    torch.tensor([[14.2889, -18.9045, 11.7281]]				)
							elif "l16" in checkpoint_url:
														__lowercase      =    torch.tensor([[41.5028, -22.8681, 45.6475]]				)
							elif "b4" in checkpoint_url:
														__lowercase      =    torch.tensor([[-4.3868, 5.2932, -0.4137]]				)
							else:
														__lowercase      =    torch.tensor([[-0.1792, -0.6465, 2.4263]]				)

							# verify logits
							assert torch.allclose(last_hidden_state[:, 0, :3]				,       __UpperCAmelCase				,       atol=1e-4				)

							print(F'Saving model to {pytorch_dump_folder_path}'				)
							model.save_pretrained(__UpperCAmelCase				)

							print(F'Saving image processor to {pytorch_dump_folder_path}'				)
							image_processor.save_pretrained(__UpperCAmelCase				)


if __name__ == "__main__":
			UpperCAmelCase__				     = argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--checkpoint_url",
			    default="https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar",
			    type=str,
			    help="URL of the checkpoint you'd like to convert.",
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
			)

			UpperCAmelCase__				     = parser.parse_args()
			convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












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 (     __SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						unittest.TestCase  ):
						"""simple docstring"""

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






						def     UpperCAmelCase_      ( self :     int				)    ->						Dict:
													"""simple docstring"""


													torch.manual_seed(0				)
													__lowercase      =    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				,							)
													__lowercase      =    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=lowerCamelCase__				,							set_alpha_to_one=lowerCamelCase__				,							)
													torch.manual_seed(0				)
													__lowercase      =    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				)
													__lowercase      =    CLIPTextConfig(
													    bos_token_id=0				,							eos_token_id=2				,							hidden_size=32				,							intermediate_size=37				,							layer_norm_eps=1e-0_5				,							num_attention_heads=4				,							num_hidden_layers=5				,							pad_token_id=1				,							vocab_size=1_000				,							)
													__lowercase      =    CLIPTextModel(lowerCamelCase__				)
													__lowercase      =    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

													__lowercase      =    {
													    '''unet''': unet,
													    '''scheduler''': scheduler,
													    '''vae''': vae,
													    '''text_encoder''': text_encoder,
													    '''tokenizer''': tokenizer,
													    '''safety_checker''': None,
													    '''feature_extractor''': None,
													}
													return components






						def     UpperCAmelCase_      ( self :     Any				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     List[str]=0				)    ->						Any:
													"""simple docstring"""


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


													__lowercase      =    '''cpu'''  # ensure determinism for the device-dependent torch.Generator

													__lowercase      =    self.get_dummy_components()
													__lowercase      =    CycleDiffusionPipeline(**lowerCamelCase__				)
													__lowercase      =    pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)

													__lowercase      =    self.get_dummy_inputs(lowerCamelCase__				)
													__lowercase      =    pipe(**lowerCamelCase__				)
													__lowercase      =    output.images

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

													assert images.shape == (1, 32, 32, 3)
													__lowercase      =    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 :     str				)    ->						Optional[Any]:
													"""simple docstring"""


													__lowercase      =    self.get_dummy_components()
													for name, module in components.items():
																				if hasattr(lowerCamelCase__				,							'''half'''				):
																											__lowercase      =    module.half()
													__lowercase      =    CycleDiffusionPipeline(**lowerCamelCase__				)
													__lowercase      =    pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)

													__lowercase      =    self.get_dummy_inputs(lowerCamelCase__				)
													__lowercase      =    pipe(**lowerCamelCase__				)
													__lowercase      =    output.images

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

													assert images.shape == (1, 32, 32, 3)
													__lowercase      =    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 :     str				)    ->						int:
													"""simple docstring"""


													return super().test_save_load_local()






						@unittest.skip('''non-deterministic pipeline'''				)
						def     UpperCAmelCase_      ( self :     int				)    ->						Union[str, Any]:
													"""simple docstring"""


													return super().test_inference_batch_single_identical()






						@skip_mps
						def     UpperCAmelCase_      ( self :     int				)    ->						Optional[int]:
													"""simple docstring"""


													return super().test_dict_tuple_outputs_equivalent()






						@skip_mps
						def     UpperCAmelCase_      ( self :     List[Any]				)    ->						List[str]:
													"""simple docstring"""


													return super().test_save_load_optional_components()






						@skip_mps
						def     UpperCAmelCase_      ( self :     Union[str, Any]				)    ->						Tuple:
													"""simple docstring"""


													return super().test_attention_slicing_forward_pass()







@slow
@require_torch_gpu
class a (     unittest.TestCase  ):
						"""simple docstring"""

						def     UpperCAmelCase_      ( self :     Optional[Any]				)    ->						Union[str, Any]:
													"""simple docstring"""


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






						def     UpperCAmelCase_      ( self :     Optional[int]				)    ->						List[str]:
													"""simple docstring"""


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

													__lowercase      =    '''CompVis/stable-diffusion-v1-4'''
													__lowercase      =    DDIMScheduler.from_pretrained(lowerCamelCase__				,							subfolder='''scheduler'''				)
													__lowercase      =    CycleDiffusionPipeline.from_pretrained(
													    lowerCamelCase__				,							scheduler=lowerCamelCase__				,							safety_checker=lowerCamelCase__				,							torch_dtype=torch.floataa				,							revision='''fp16'''				)

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

													__lowercase      =    '''A black colored car'''
													__lowercase      =    '''A blue colored car'''

													__lowercase      =    torch.manual_seed(0				)
													__lowercase      =    pipe(
													    prompt=lowerCamelCase__				,							source_prompt=lowerCamelCase__				,							image=lowerCamelCase__				,							num_inference_steps=100				,							eta=0.1				,							strength=0.8_5				,							guidance_scale=3				,							source_guidance_scale=1				,							generator=lowerCamelCase__				,							output_type='''np'''				,							)
													__lowercase      =    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 :     Tuple				)    ->						List[str]:
													"""simple docstring"""


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

													__lowercase      =    '''CompVis/stable-diffusion-v1-4'''
													__lowercase      =    DDIMScheduler.from_pretrained(lowerCamelCase__				,							subfolder='''scheduler'''				)
													__lowercase      =    CycleDiffusionPipeline.from_pretrained(lowerCamelCase__				,							scheduler=lowerCamelCase__				,							safety_checker=lowerCamelCase__				)

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

													__lowercase      =    '''A black colored car'''
													__lowercase      =    '''A blue colored car'''

													__lowercase      =    torch.manual_seed(0				)
													__lowercase      =    pipe(
													    prompt=lowerCamelCase__				,							source_prompt=lowerCamelCase__				,							image=lowerCamelCase__				,							num_inference_steps=100				,							eta=0.1				,							strength=0.8_5				,							guidance_scale=3				,							source_guidance_scale=1				,							generator=lowerCamelCase__				,							output_type='''np'''				,							)
													__lowercase      =    output.images

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






