





"""simple docstring"""





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel


def       lowerCamelCase_       (   UpperCAmelCase_  )						->Optional[int]:





  """simple docstring"""


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

  return name


def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  )						->Union[str, Any]:





  """simple docstring"""


  for key in orig_state_dict.copy().keys():
    __UpperCAmelCase    :						Union[str, Any]       =						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
      __UpperCAmelCase    :						int       =						key.split('''.'''  )
      __UpperCAmelCase    :						Optional[int]       =						int(key_split[2]  ), int(key_split[4]  )
      __UpperCAmelCase    :						int       =						config.vision_config.hidden_size
      if "weight" in key:
        __UpperCAmelCase    :						int       =						val[:dim, :]
        __UpperCAmelCase    :						List[Any]       =						val[dim : dim * 2, :]
        __UpperCAmelCase    :						Optional[int]       =						val[-dim:, :]
      else:
        __UpperCAmelCase    :						Tuple       =						val[:dim]
        __UpperCAmelCase    :						Optional[int]       =						val[dim : dim * 2]
        __UpperCAmelCase    :						int       =						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
      __UpperCAmelCase    :						List[str]       =						key.split('''.'''  )
      __UpperCAmelCase    :						int       =						int(key_split[3]  )
      __UpperCAmelCase    :						int       =						config.text_config.hidden_size
      if "weight" in key:
        __UpperCAmelCase    :						int       =						val[:dim, :]
        __UpperCAmelCase    :						List[str]       =						val[
            dim : dim * 2, :
        ]
        __UpperCAmelCase    :						str       =						val[-dim:, :]
      else:
        __UpperCAmelCase    :						List[Any]       =						val[:dim]
        __UpperCAmelCase    :						Dict       =						val[dim : dim * 2]
        __UpperCAmelCase    :						Optional[int]       =						val[-dim:]
    else:
      __UpperCAmelCase    :						Dict       =						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
      ):
        __UpperCAmelCase    :						Union[str, Any]       =						val.squeeze_()
      else:
        __UpperCAmelCase    :						Union[str, Any]       =						val

  return orig_state_dict


def       lowerCamelCase_       (   )						->Optional[int]:





  """simple docstring"""


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


@torch.no_grad()
def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  ,			UpperCAmelCase_="groupvit-gcc-yfcc"  ,			UpperCAmelCase_=False  )						->Union[str, Any]:





  """simple docstring"""


  __UpperCAmelCase    :						List[Any]       =						GroupViTConfig()
  __UpperCAmelCase    :						Tuple       =						GroupViTModel(UpperCAmelCase_  ).eval()

  __UpperCAmelCase    :						Optional[int]       =						torch.load(UpperCAmelCase_  ,			map_location='''cpu'''  )['''model''']
  __UpperCAmelCase    :						List[str]       =						convert_state_dict(UpperCAmelCase_  ,			UpperCAmelCase_  )
  __UpperCAmelCase    :						Tuple       =						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
  __UpperCAmelCase    :						str       =						CLIPProcessor.from_pretrained('''openai/clip-vit-base-patch32'''  )
  __UpperCAmelCase    :						Dict       =						prepare_img()
  __UpperCAmelCase    :						Tuple       =						processor(text=['''a photo of a cat''', '''a photo of a dog''']  ,			images=UpperCAmelCase_  ,			padding=UpperCAmelCase_  ,			return_tensors='''pt'''  )

  with torch.no_grad():
    __UpperCAmelCase    :						List[Any]       =						model(**UpperCAmelCase_  )

  if model_name == "groupvit-gcc-yfcc":
    __UpperCAmelCase    :						Tuple       =						torch.tensor([[13.3_523, 6.3_629]]  )
  elif model_name == "groupvit-gcc-redcaps":
    __UpperCAmelCase    :						List[Any]       =						torch.tensor([[16.1_873, 8.6_230]]  )
  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__":
      lowercase__				:Any				   =       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`.',
      )
      lowercase__				:List[str]				   =       parser.parse_args()

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






"""simple docstring"""





# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


lowercase__				:int				   =       '3'

print('Python version:', sys.version)
print('transformers version:', transformers.__version__)

try:
  import torch

  print('Torch version:', torch.__version__)
  print('Cuda available:', torch.cuda.is_available())
  print('Cuda version:', torch.version.cuda)
  print('CuDNN version:', torch.backends.cudnn.version())
  print('Number of GPUs available:', torch.cuda.device_count())
  print('NCCL version:', torch.cuda.nccl.version())
except ImportError:
  print('Torch version:', None)

try:
  import deepspeed

  print('DeepSpeed version:', deepspeed.__version__)
except ImportError:
  print('DeepSpeed version:', None)

try:
  import tensorflow as tf

  print('TensorFlow version:', tf.__version__)
  print('TF GPUs available:', bool(tf.config.list_physical_devices('GPU')))
  print('Number of TF GPUs available:', len(tf.config.list_physical_devices('GPU')))
except ImportError:
  print('TensorFlow version:', None)