




lowerCamelCase__			:       List[Any]         =							'0.18.2'

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
   if not is_onnx_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_onnx_objects import *  # noqa F403
else:
   from .pipelines import OnnxRuntimeModel

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_pt_objects import *  # noqa F403
else:
   from .models import (
       AutoencoderKL,
       ControlNetModel,
       ModelMixin,
       PriorTransformer,
       TaFilmDecoder,
       TransformeraDModel,
       UNetaDModel,
       UNetaDConditionModel,
       UNetaDModel,
       UNetaDConditionModel,
       VQModel,
   )
   from .optimization import (
       get_constant_schedule,
       get_constant_schedule_with_warmup,
       get_cosine_schedule_with_warmup,
       get_cosine_with_hard_restarts_schedule_with_warmup,
       get_linear_schedule_with_warmup,
       get_polynomial_decay_schedule_with_warmup,
       get_scheduler,
   )
   from .pipelines import (
       AudioPipelineOutput,
       ConsistencyModelPipeline,
       DanceDiffusionPipeline,
       DDIMPipeline,
       DDPMPipeline,
       DiffusionPipeline,
       DiTPipeline,
       ImagePipelineOutput,
       KarrasVePipeline,
       LDMPipeline,
       LDMSuperResolutionPipeline,
       PNDMPipeline,
       RePaintPipeline,
       ScoreSdeVePipeline,
   )
   from .schedulers import (
       CMStochasticIterativeScheduler,
       DDIMInverseScheduler,
       DDIMParallelScheduler,
       DDIMScheduler,
       DDPMParallelScheduler,
       DDPMScheduler,
       DEISMultistepScheduler,
       DPMSolverMultistepInverseScheduler,
       DPMSolverMultistepScheduler,
       DPMSolverSinglestepScheduler,
       EulerAncestralDiscreteScheduler,
       EulerDiscreteScheduler,
       HeunDiscreteScheduler,
       IPNDMScheduler,
       KarrasVeScheduler,
       KDPMaAncestralDiscreteScheduler,
       KDPMaDiscreteScheduler,
       PNDMScheduler,
       RePaintScheduler,
       SchedulerMixin,
       ScoreSdeVeScheduler,
       UnCLIPScheduler,
       UniPCMultistepScheduler,
       VQDiffusionScheduler,
   )
   from .training_utils import EMAModel

try:
   if not (is_torch_available() and is_scipy_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
   from .schedulers import LMSDiscreteScheduler

try:
   if not (is_torch_available() and is_torchsde_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
   from .schedulers import DPMSolverSDEScheduler

try:
   if not (is_torch_available() and is_transformers_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
   from .pipelines import (
       AltDiffusionImgaImgPipeline,
       AltDiffusionPipeline,
       AudioLDMPipeline,
       CycleDiffusionPipeline,
       IFImgaImgPipeline,
       IFImgaImgSuperResolutionPipeline,
       IFInpaintingPipeline,
       IFInpaintingSuperResolutionPipeline,
       IFPipeline,
       IFSuperResolutionPipeline,
       ImageTextPipelineOutput,
       KandinskyImgaImgPipeline,
       KandinskyInpaintPipeline,
       KandinskyPipeline,
       KandinskyPriorPipeline,
       KandinskyVaaControlnetImgaImgPipeline,
       KandinskyVaaControlnetPipeline,
       KandinskyVaaImgaImgPipeline,
       KandinskyVaaInpaintPipeline,
       KandinskyVaaPipeline,
       KandinskyVaaPriorEmbaEmbPipeline,
       KandinskyVaaPriorPipeline,
       LDMTextToImagePipeline,
       PaintByExamplePipeline,
       SemanticStableDiffusionPipeline,
       ShapEImgaImgPipeline,
       ShapEPipeline,
       StableDiffusionAttendAndExcitePipeline,
       StableDiffusionControlNetImgaImgPipeline,
       StableDiffusionControlNetInpaintPipeline,
       StableDiffusionControlNetPipeline,
       StableDiffusionDepthaImgPipeline,
       StableDiffusionDiffEditPipeline,
       StableDiffusionImageVariationPipeline,
       StableDiffusionImgaImgPipeline,
       StableDiffusionInpaintPipeline,
       StableDiffusionInpaintPipelineLegacy,
       StableDiffusionInstructPixaPixPipeline,
       StableDiffusionLatentUpscalePipeline,
       StableDiffusionLDMaDPipeline,
       StableDiffusionModelEditingPipeline,
       StableDiffusionPanoramaPipeline,
       StableDiffusionParadigmsPipeline,
       StableDiffusionPipeline,
       StableDiffusionPipelineSafe,
       StableDiffusionPixaPixZeroPipeline,
       StableDiffusionSAGPipeline,
       StableDiffusionUpscalePipeline,
       StableUnCLIPImgaImgPipeline,
       StableUnCLIPPipeline,
       TextToVideoSDPipeline,
       TextToVideoZeroPipeline,
       UnCLIPImageVariationPipeline,
       UnCLIPPipeline,
       UniDiffuserModel,
       UniDiffuserPipeline,
       UniDiffuserTextDecoder,
       VersatileDiffusionDualGuidedPipeline,
       VersatileDiffusionImageVariationPipeline,
       VersatileDiffusionPipeline,
       VersatileDiffusionTextToImagePipeline,
       VideoToVideoSDPipeline,
       VQDiffusionPipeline,
   )

try:
   if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
   from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
   if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
   from .pipelines import StableDiffusionKDiffusionPipeline

try:
   if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
   from .pipelines import (
       OnnxStableDiffusionImgaImgPipeline,
       OnnxStableDiffusionInpaintPipeline,
       OnnxStableDiffusionInpaintPipelineLegacy,
       OnnxStableDiffusionPipeline,
       OnnxStableDiffusionUpscalePipeline,
       StableDiffusionOnnxPipeline,
   )

try:
   if not (is_torch_available() and is_librosa_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
   from .pipelines import AudioDiffusionPipeline, Mel

try:
   if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
   from .pipelines import SpectrogramDiffusionPipeline

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_flax_objects import *  # noqa F403
else:
   from .models.controlnet_flax import FlaxControlNetModel
   from .models.modeling_flax_utils import FlaxModelMixin
   from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
   from .models.vae_flax import FlaxAutoencoderKL
   from .pipelines import FlaxDiffusionPipeline
   from .schedulers import (
       FlaxDDIMScheduler,
       FlaxDDPMScheduler,
       FlaxDPMSolverMultistepScheduler,
       FlaxKarrasVeScheduler,
       FlaxLMSDiscreteScheduler,
       FlaxPNDMScheduler,
       FlaxSchedulerMixin,
       FlaxScoreSdeVeScheduler,
   )


try:
   if not (is_flax_available() and is_transformers_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
   from .pipelines import (
       FlaxStableDiffusionControlNetPipeline,
       FlaxStableDiffusionImgaImgPipeline,
       FlaxStableDiffusionInpaintPipeline,
       FlaxStableDiffusionPipeline,
   )

try:
   if not (is_note_seq_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from .utils.dummy_note_seq_objects import *  # noqa F403
else:
   from .pipelines import MidiProcessor





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel

def  UpperCAmelCase_							(				__UpperCAmelCase						:     List[str]							) ->			List[Any]:
      # vision encoder
      if "img_encoder.pos_embed" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_encoder.pos_embed'      ,      'vision_model.embeddings.position_embeddings'							)
      if "img_encoder.patch_embed.proj" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_encoder.patch_embed.proj'      ,      'vision_model.embeddings.patch_embeddings.projection'							)
      if "img_encoder.patch_embed.norm" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_encoder.patch_embed.norm'      ,      'vision_model.embeddings.layernorm'							)
      if "img_encoder.layers" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_encoder.layers'      ,      'vision_model.encoder.stages'							)
      if "blocks" in name and "res" not in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('blocks'      ,      'layers'							)
      if "attn" in name and "pre_assign" not in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('attn'      ,      'self_attn'							)
      if "proj" in name and "self_attn" in name and "text" not in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('proj'      ,      'out_proj'							)
      if "pre_assign_attn.attn.proj" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('pre_assign_attn.attn.proj'      ,      'pre_assign_attn.attn.out_proj'							)
      if "norm1" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('norm1'      ,      'layer_norm1'							)
      if "norm2" in name and "pre_assign" not in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('norm2'      ,      'layer_norm2'							)
      if "img_encoder.norm" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_encoder.norm'      ,      'vision_model.layernorm'							)
      # text encoder
      if "text_encoder.token_embedding" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_encoder.token_embedding'      ,      'text_model.embeddings.token_embedding'							)
      if "text_encoder.positional_embedding" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_encoder.positional_embedding'      ,      'text_model.embeddings.position_embedding.weight'							)
      if "text_encoder.transformer.resblocks." in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_encoder.transformer.resblocks.'      ,      'text_model.encoder.layers.'							)
      if "ln_1" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('ln_1'      ,      'layer_norm1'							)
      if "ln_2" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('ln_2'      ,      'layer_norm2'							)
      if "c_fc" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('c_fc'      ,      'fc1'							)
      if "c_proj" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('c_proj'      ,      'fc2'							)
      if "text_encoder" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_encoder'      ,      'text_model'							)
      if "ln_final" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('ln_final'      ,      'final_layer_norm'							)
      # projection layers
      if "img_projector.linear_hidden." in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_projector.linear_hidden.'      ,      'visual_projection.'							)
      if "img_projector.linear_out." in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('img_projector.linear_out.'      ,      'visual_projection.3.'							)
      if "text_projector.linear_hidden" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_projector.linear_hidden'      ,      'text_projection'							)
      if "text_projector.linear_out" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('text_projector.linear_out'      ,      'text_projection.3'							)

      return name

def  UpperCAmelCase_							(				__UpperCAmelCase						:     Union[str, Any]      ,      __UpperCAmelCase						:     int							) ->			List[str]:
      for key in orig_state_dict.copy().keys():
            SCREAMING_SNAKE_CASE_     						=      orig_state_dict.pop(__UpperCAmelCase							)

            if "qkv" in key:
                  # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
                  # we need to split them up into separate matrices/vectors
                  SCREAMING_SNAKE_CASE_     						=      key.split('.'							)
                  SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      int(key_split[2]							), int(key_split[4]							)
                  SCREAMING_SNAKE_CASE_     						=      config.vision_config.hidden_size
                  if "weight" in key:
                        SCREAMING_SNAKE_CASE_     						=      val[:dim, :]
                        SCREAMING_SNAKE_CASE_     						=      val[dim : dim * 2, :]
                        SCREAMING_SNAKE_CASE_     						=      val[-dim:, :]
                  else:
                        SCREAMING_SNAKE_CASE_     						=      val[:dim]
                        SCREAMING_SNAKE_CASE_     						=      val[dim : dim * 2]
                        SCREAMING_SNAKE_CASE_     						=      val[-dim:]
            elif "in_proj" in key:
                  # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
                  # we need to split them up into separate matrices/vectors
                  SCREAMING_SNAKE_CASE_     						=      key.split('.'							)
                  SCREAMING_SNAKE_CASE_     						=      int(key_split[3]							)
                  SCREAMING_SNAKE_CASE_     						=      config.text_config.hidden_size
                  if "weight" in key:
                        SCREAMING_SNAKE_CASE_     						=      val[:dim, :]
                        SCREAMING_SNAKE_CASE_     						=      val[
                            dim : dim * 2, :
                        ]
                        SCREAMING_SNAKE_CASE_     						=      val[-dim:, :]
                  else:
                        SCREAMING_SNAKE_CASE_     						=      val[:dim]
                        SCREAMING_SNAKE_CASE_     						=      val[dim : dim * 2]
                        SCREAMING_SNAKE_CASE_     						=      val[-dim:]
            else:
                  SCREAMING_SNAKE_CASE_     						=      rename_key(__UpperCAmelCase							)
                  # squeeze if necessary
                  if (
                      "text_projection.0" in new_name
                      or "text_projection.3" in new_name
                      or "visual_projection.0" in new_name
                      or "visual_projection.3" in new_name
                  ):
                        SCREAMING_SNAKE_CASE_     						=      val.squeeze_()
                  else:
                        SCREAMING_SNAKE_CASE_     						=      val

      return orig_state_dict

def  UpperCAmelCase_							(				) ->			List[Any]:
      SCREAMING_SNAKE_CASE_     						=      'http://images.cocodataset.org/val2017/000000039769.jpg'
      SCREAMING_SNAKE_CASE_     						=      Image.open(requests.get(__UpperCAmelCase      ,      stream=__UpperCAmelCase							).raw							)
      return im

@torch.no_grad()
def  UpperCAmelCase_							(				__UpperCAmelCase						:     int      ,      __UpperCAmelCase						:     str      ,      __UpperCAmelCase						:     Dict="groupvit-gcc-yfcc"      ,      __UpperCAmelCase						:     Any=False							) ->			Optional[int]:
      SCREAMING_SNAKE_CASE_     						=      GroupViTConfig()
      SCREAMING_SNAKE_CASE_     						=      GroupViTModel(__UpperCAmelCase							).eval()

      SCREAMING_SNAKE_CASE_     						=      torch.load(__UpperCAmelCase      ,      map_location='cpu'							)['model']
      SCREAMING_SNAKE_CASE_     						=      convert_state_dict(__UpperCAmelCase      ,      __UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      model.load_state_dict(__UpperCAmelCase      ,      strict=__UpperCAmelCase							)
      assert missing_keys == ["text_model.embeddings.position_ids"]
      assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(__UpperCAmelCase							) == 0)

      # verify result
      SCREAMING_SNAKE_CASE_     						=      CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32'							)
      SCREAMING_SNAKE_CASE_     						=      prepare_img()
      SCREAMING_SNAKE_CASE_     						=      processor(text=['a photo of a cat', 'a photo of a dog']      ,      images=__UpperCAmelCase      ,      padding=__UpperCAmelCase      ,      return_tensors='pt'							)

      with torch.no_grad():
            SCREAMING_SNAKE_CASE_     						=      model(**__UpperCAmelCase							)

      if model_name == "groupvit-gcc-yfcc":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([[1_3.3_5_2_3, 6.3_6_2_9]]							)
      elif model_name == "groupvit-gcc-redcaps":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([[1_6.1_8_7_3, 8.6_2_3_0]]							)
      else:
            raise ValueError(f"Model name {model_name} not supported."							)
      assert torch.allclose(outputs.logits_per_image      ,      __UpperCAmelCase      ,      atol=1E-3							)

      processor.save_pretrained(__UpperCAmelCase							)
      model.save_pretrained(__UpperCAmelCase							)
      print('Successfully saved processor and model to'      ,      __UpperCAmelCase							)

      if push_to_hub:
            print('Pushing to the hub...'							)
            processor.push_to_hub(__UpperCAmelCase      ,      organization='nielsr'							)
            model.push_to_hub(__UpperCAmelCase      ,      organization='nielsr'							)


if __name__ == "__main__":
   lowerCamelCase__			:       int         =							argparse.ArgumentParser()
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, help='Path to dump the processor and PyTorch model.'
   )
   parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to GroupViT checkpoint')
   parser.add_argument(
       '--model_name',
       default='groupvit-gccy-fcc',
       type=str,
       help='Name of the model. Expecting either \'groupvit-gcc-yfcc\' or \'groupvit-gcc-redcaps\'',
   )
   parser.add_argument(
       '--push_to_hub',
       action='store_true',
       help='Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.',
   )
   lowerCamelCase__			:       List[str]         =							parser.parse_args()

   convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)