

# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# 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.

import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


lowerCamelCase      				=     '''Run commands across TPU VMs for initial setup before running `accelerate launch`.'''


def        __lowercase    (  UpperCAmelCase__=None      ):

					"""simple docstring"""






					if subparsers is not None:
										__lowerCAmelCase					=							subparsers.add_parser('tpu-config'		,					description=_description      )
					else:
										__lowerCAmelCase					=							argparse.ArgumentParser('Accelerate tpu-config command'		,					description=_description      )
					# Core arguments
					__lowerCAmelCase					=							parser.add_argument_group(
					    'Config Arguments'		,					'Arguments that can be configured through `accelerate config`.'      )
					config_args.add_argument(
					    '--config_file'		,					type=UpperCAmelCase__		,					default=UpperCAmelCase__		,					help='Path to the config file to use for accelerate.'		,					)
					config_args.add_argument(
					    '--tpu_name'		,					default=UpperCAmelCase__		,					help='The name of the TPU to use. If not specified, will use the TPU specified in the config file.'		,					)
					config_args.add_argument(
					    '--tpu_zone'		,					default=UpperCAmelCase__		,					help='The zone of the TPU to use. If not specified, will use the zone specified in the config file.'		,					)
					__lowerCAmelCase					=							parser.add_argument_group('TPU Arguments'		,					'Arguments for options ran inside the TPU.'      )
					pod_args.add_argument(
					    '--use_alpha'		,					action='store_true'		,					help='Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.'		,					)
					pod_args.add_argument(
					    '--command_file'		,					default=UpperCAmelCase__		,					help='The path to the file containing the commands to run on the pod on startup.'		,					)
					pod_args.add_argument(
					    '--command'		,					action='append'		,					nargs='+'		,					help='A command to run on the pod. Can be passed multiple times.'		,					)
					pod_args.add_argument(
					    '--install_accelerate'		,					action='store_true'		,					help='Whether to install accelerate on the pod. Defaults to False.'		,					)
					pod_args.add_argument(
					    '--accelerate_version'		,					default='latest'		,					help='The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.'		,					)
					pod_args.add_argument(
					    '--debug'		,					action='store_true'		,					help='If set, will print the command that would be run instead of running it.'      )

					if subparsers is not None:
										parser.set_defaults(func=UpperCAmelCase__      )
					return parser


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							None

					# Get the default from the config file if it exists.
					if args.config_file is not None or os.path.isfile(UpperCAmelCase__      ):
										__lowerCAmelCase					=							load_config_from_file(args.config_file      )
										if not args.command_file and defaults.command_file is not None and not args.command:
															__lowerCAmelCase					=							defaults.command_file
										if not args.command and defaults.commands is not None:
															__lowerCAmelCase					=							defaults.commands
										if not args.tpu_name:
															__lowerCAmelCase					=							defaults.tpu_name
										if not args.tpu_zone:
															__lowerCAmelCase					=							defaults.tpu_zone
					if args.accelerate_version == "dev":
										__lowerCAmelCase					=							'git+https://github.com/huggingface/accelerate.git'
					elif args.accelerate_version == "latest":
										__lowerCAmelCase					=							'accelerate -U'
					elif isinstance(parse(args.accelerate_version      )		,					UpperCAmelCase__      ):
										__lowerCAmelCase					=							F"""accelerate=={args.accelerate_version}"""

					if not args.command_file and not args.command:
										raise ValueError('You must specify either a command file or a command to run on the pod.'      )

					if args.command_file:
										with open(args.command_file		,					'r'      ) as f:
															__lowerCAmelCase					=							[f.read().splitlines()]

    # To turn list of lists into list of strings
					if isinstance(args.command[0]		,					UpperCAmelCase__      ):
										__lowerCAmelCase					=							[line for cmd in args.command for line in cmd]
					# Default to the shared folder and install accelerate
					__lowerCAmelCase					=							['cd /usr/share']
					if args.install_accelerate:
										new_cmd += [F"""pip install {args.accelerate_version}"""]
					new_cmd += args.command
					__lowerCAmelCase					=							'; '.join(UpperCAmelCase__      )

					# Then send it to gcloud
					# Eventually try to use google-api-core to do this instead of subprocess
					__lowerCAmelCase					=							['gcloud']
					if args.use_alpha:
										cmd += ["alpha"]
					cmd += [
					    "compute",
					    "tpus",
					    "tpu-vm",
					    "ssh",
					    args.tpu_name,
					    "--zone",
					    args.tpu_zone,
					    "--command",
					    args.command,
					    "--worker",
					    "all",
					]
					if args.debug:
										print(F"""Running {' '.join(UpperCAmelCase__      )}"""      )
										return
					subprocess.run(UpperCAmelCase__      )
					print('Successfully setup pod.'      )


def        __lowercase    (  ):

					"""simple docstring"""






					__lowerCAmelCase					=							tpu_command_parser()
					__lowerCAmelCase					=							parser.parse_args()

					tpu_command_launcher(UpperCAmelCase__      )









import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






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

					return name


def        __lowercase    (  UpperCAmelCase__		,					UpperCAmelCase__      ):

					"""simple docstring"""






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

					return orig_state_dict


def        __lowercase    (  ):

					"""simple docstring"""






					__lowerCAmelCase					=							'http://images.cocodataset.org/val2017/000000039769.jpg'
					__lowerCAmelCase					=							Image.open(requests.get(UpperCAmelCase__		,					stream=UpperCAmelCase__      ).raw      )
					return im


@torch.no_grad()
def        __lowercase    (  UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__="groupvit-gcc-yfcc"		,					UpperCAmelCase__=False      ):

					"""simple docstring"""






					__lowerCAmelCase					=							GroupViTConfig()
					__lowerCAmelCase					=							GroupViTModel(UpperCAmelCase__      ).eval()

					__lowerCAmelCase					=							torch.load(UpperCAmelCase__		,					map_location='cpu'      )['model']
					__lowerCAmelCase					=							convert_state_dict(UpperCAmelCase__		,					UpperCAmelCase__      )
					__lowerCAmelCase,	__lowerCAmelCase					=							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
					__lowerCAmelCase					=							CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32'      )
					__lowerCAmelCase					=							prepare_img()
					__lowerCAmelCase					=							processor(text=['a photo of a cat', 'a photo of a dog']		,					images=UpperCAmelCase__		,					padding=UpperCAmelCase__		,					return_tensors='pt'      )

					with torch.no_grad():
										__lowerCAmelCase					=							model(**UpperCAmelCase__      )

					if model_name == "groupvit-gcc-yfcc":
										__lowerCAmelCase					=							torch.tensor([[13.3523, 6.3629]]      )
					elif model_name == "groupvit-gcc-redcaps":
										__lowerCAmelCase					=							torch.tensor([[16.1873, 8.6230]]      )
					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      				=     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      				=     parser.parse_args()

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






