





import argparse
import json
from pathlib import Path

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

from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
lowercase_					     =	logging.get_logger(__name__)




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=False	)       ->     int:
  lowercase__			    =						[]
  for i in range(config.num_hidden_layers	):
    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
    rename_keys.append((F"""blocks.{i}.norm1.weight""", F"""vit.encoder.layer.{i}.layernorm_before.weight""")	)
    rename_keys.append((F"""blocks.{i}.norm1.bias""", F"""vit.encoder.layer.{i}.layernorm_before.bias""")	)
    rename_keys.append((F"""blocks.{i}.attn.proj.weight""", F"""vit.encoder.layer.{i}.attention.output.dense.weight""")	)
    rename_keys.append((F"""blocks.{i}.attn.proj.bias""", F"""vit.encoder.layer.{i}.attention.output.dense.bias""")	)
    rename_keys.append((F"""blocks.{i}.norm2.weight""", F"""vit.encoder.layer.{i}.layernorm_after.weight""")	)
    rename_keys.append((F"""blocks.{i}.norm2.bias""", F"""vit.encoder.layer.{i}.layernorm_after.bias""")	)
    rename_keys.append((F"""blocks.{i}.mlp.fc1.weight""", F"""vit.encoder.layer.{i}.intermediate.dense.weight""")	)
    rename_keys.append((F"""blocks.{i}.mlp.fc1.bias""", F"""vit.encoder.layer.{i}.intermediate.dense.bias""")	)
    rename_keys.append((F"""blocks.{i}.mlp.fc2.weight""", F"""vit.encoder.layer.{i}.output.dense.weight""")	)
    rename_keys.append((F"""blocks.{i}.mlp.fc2.bias""", F"""vit.encoder.layer.{i}.output.dense.bias""")	)

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

  if base_model:
    # layernorm + pooler
    rename_keys.extend(
        [
            ('norm.weight', 'layernorm.weight'),
            ('norm.bias', 'layernorm.bias'),
            ('pre_logits.fc.weight', 'pooler.dense.weight'),
            ('pre_logits.fc.bias', 'pooler.dense.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     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=False	)       ->     Optional[Any]:
  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"""blocks.{i}.attn.qkv.weight"""	)
    lowercase__			    =						state_dict.pop(F"""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     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     str:
  lowercase__			    =						['head.weight', 'head.bias']
  for k in ignore_keys:
    state_dict.pop(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     Dict:
  lowercase__			    =						dct.pop(_SCREAMING_SNAKE_CASE	)
  lowercase__			    =						val




def     __UpperCamelCase						()       ->     str:
  lowercase__			    =						'http://images.cocodataset.org/val2017/000000039769.jpg'
  lowercase__			    =						Image.open(requests.get(_SCREAMING_SNAKE_CASE	,		stream=_SCREAMING_SNAKE_CASE	).raw	)
  return im




@torch.no_grad()
def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     int:
  lowercase__			    =						ViTConfig()
  lowercase__			    =						False
  # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
  if vit_name[-5:] == "in21k":
    lowercase__			    =						True
    lowercase__			    =						int(vit_name[-12:-10]	)
    lowercase__			    =						int(vit_name[-9:-6]	)
  else:
    lowercase__			    =						1000
    lowercase__			    =						'huggingface/label-files'
    lowercase__			    =						'imagenet-1k-id2label.json'
    lowercase__			    =						json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		repo_type='dataset'	)	,		'r'	)	)
    lowercase__			    =						{int(_SCREAMING_SNAKE_CASE	): v for k, v in idalabel.items()}
    lowercase__			    =						idalabel
    lowercase__			    =						{v: k for k, v in idalabel.items()}
    lowercase__			    =						int(vit_name[-6:-4]	)
    lowercase__			    =						int(vit_name[-3:]	)
  # size of the architecture
  if "deit" in vit_name:
    if vit_name[9:].startswith('tiny'	):
      lowercase__			    =						192
      lowercase__			    =						768
      lowercase__			    =						12
      lowercase__			    =						3
    elif vit_name[9:].startswith('small'	):
      lowercase__			    =						384
      lowercase__			    =						1536
      lowercase__			    =						12
      lowercase__			    =						6
    else:
      pass
  else:
    if vit_name[4:].startswith('small'	):
      lowercase__			    =						768
      lowercase__			    =						2304
      lowercase__			    =						8
      lowercase__			    =						8
    elif vit_name[4:].startswith('base'	):
      pass
    elif vit_name[4:].startswith('large'	):
      lowercase__			    =						1024
      lowercase__			    =						4096
      lowercase__			    =						24
      lowercase__			    =						16
    elif vit_name[4:].startswith('huge'	):
      lowercase__			    =						1280
      lowercase__			    =						5120
      lowercase__			    =						32
      lowercase__			    =						16

    # load original model from timm
  lowercase__			    =						timm.create_model(_SCREAMING_SNAKE_CASE	,		pretrained=_SCREAMING_SNAKE_CASE	)
  timm_model.eval()

  # load state_dict of original model, remove and rename some keys
  lowercase__			    =						timm_model.state_dict()
  if base_model:
    remove_classification_head_(_SCREAMING_SNAKE_CASE	)
  lowercase__			    =						create_rename_keys(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)
  for src, dest in rename_keys:
    rename_key(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)
  read_in_q_k_v(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)

  # load HuggingFace model
  if vit_name[-5:] == "in21k":
    lowercase__			    =						ViTModel(_SCREAMING_SNAKE_CASE	).eval()
  else:
    lowercase__			    =						ViTForImageClassification(_SCREAMING_SNAKE_CASE	).eval()
  model.load_state_dict(_SCREAMING_SNAKE_CASE	)

  # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor
  if "deit" in vit_name:
    lowercase__			    =						DeiTImageProcessor(size=config.image_size	)
  else:
    lowercase__			    =						ViTImageProcessor(size=config.image_size	)
  lowercase__			    =						image_processor(images=prepare_img()	,		return_tensors='pt'	)
  lowercase__			    =						encoding['pixel_values']
  lowercase__			    =						model(_SCREAMING_SNAKE_CASE	)

  if base_model:
    lowercase__			    =						timm_model.forward_features(_SCREAMING_SNAKE_CASE	)
    assert timm_pooled_output.shape == outputs.pooler_output.shape
    assert torch.allclose(_SCREAMING_SNAKE_CASE	,		outputs.pooler_output	,		atol=1E-3	)
  else:
    lowercase__			    =						timm_model(_SCREAMING_SNAKE_CASE	)
    assert timm_logits.shape == outputs.logits.shape
    assert torch.allclose(_SCREAMING_SNAKE_CASE	,		outputs.logits	,		atol=1E-3	)

  Path(_SCREAMING_SNAKE_CASE	).mkdir(exist_ok=_SCREAMING_SNAKE_CASE	)
  print(F"""Saving model {vit_name} to {pytorch_dump_folder_path}"""	)
  model.save_pretrained(_SCREAMING_SNAKE_CASE	)
  print(F"""Saving image processor to {pytorch_dump_folder_path}"""	)
  image_processor.save_pretrained(_SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
      lowercase_					     =	argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--vit_name""",
          default="""vit_base_patch16_224""",
          type=str,
          help="""Name of the ViT timm model you'd like to convert.""",
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
      )

      lowercase_					     =	parser.parse_args()
      convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)









import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	List[Any]				      = StableDiffusionSAGPipeline
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_PARAMS
   _UpperCamelCase					:	Dict				      = TEXT_TO_IMAGE_BATCH_PARAMS
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Optional[int]				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Union[str, Any]				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     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.00085    ,  beta_end=0.012    ,  beta_schedule='scaled_linear'    ,  clip_sample=a    ,  set_alpha_to_one=a    ,  )
     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(a )
     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  SCREAMING_SNAKE_CASE_							(					self    :       Tuple    ,  a    :       Optional[int]    ,  a    :       Any=0 )->     Union[str, Any]:





     """simple docstring"""







     if str(a ).startswith('mps' ):
       lowercase__			    =						torch.manual_seed(a )
     else:
       lowercase__			    =						torch.Generator(device=a ).manual_seed(a )
     lowercase__			    =						{
         'prompt': '.',
         'generator': generator,
         'num_inference_steps': 2,
         'guidance_scale': 1.0,
         'sag_scale': 1.0,
         'output_type': 'numpy',
     }
     return inputs


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Any:





     """simple docstring"""







     super().test_inference_batch_single_identical(expected_max_diff=3E-3 )






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


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     int:





     """simple docstring"""







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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949] )

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371] )

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


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





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  width=768    ,  height=512    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np'    ,  )

     lowercase__			    =						output.images

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


