


"""simple docstring"""




import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel

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

		return name

def        lowercase							(		lowerCAmelCase__ :     Optional[int]    ,					lowerCAmelCase__ :     Optional[Any]			) ->      int:
		for key in orig_state_dict.copy().keys():
				__a           =			orig_state_dict.pop(lowerCAmelCase__			)

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

		return orig_state_dict

def        lowercase							(		) ->      Tuple:
		__a           =			'''http://images.cocodataset.org/val2017/000000039769.jpg'''
		__a           =			Image.open(requests.get(lowerCAmelCase__    ,					stream=lowerCAmelCase__			).raw			)
		return im

@torch.no_grad()
def        lowercase							(		lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     Optional[Any]    ,					lowerCAmelCase__ :     Any="groupvit-gcc-yfcc"    ,					lowerCAmelCase__ :     List[str]=False			) ->      Optional[Any]:
		__a           =			GroupViTConfig()
		__a           =			GroupViTModel(lowerCAmelCase__			).eval()

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

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

		with torch.no_grad():
				__a           =			model(**lowerCAmelCase__			)

		if model_name == "groupvit-gcc-yfcc":
				__a           =			torch.tensor([[13.35_23, 6.36_29]]			)
		elif model_name == "groupvit-gcc-redcaps":
				__a           =			torch.tensor([[16.18_73, 8.62_30]]			)
		else:
				raise ValueError(f'''Model name {model_name} not supported.'''			)
		assert torch.allclose(outputs.logits_per_image    ,					lowerCAmelCase__    ,					atol=1e-3			)

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

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


if __name__ == "__main__":
				lowercase_			     =  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_			     =  parser.parse_args()

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










"""simple docstring"""




lowercase_			     =  [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
lowercase_			     =  [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
lowercase_			     =  {
    0: "Sunday",
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
}

def        lowercase							(		lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     int			) ->      str:
		assert len(str(lowerCAmelCase__			)			) > 2, "year should be in YYYY format"
		assert 1 <= month <= 12, "month should be between 1 to 12"
		assert 1 <= day <= 31, "day should be between 1 to 31"

		# Doomsday algorithm:
		__a           =			year // 100
		__a           =			(5 * (century % 4) + 2) % 7
		__a           =			year % 100
		__a           =			centurian % 12
		__a           =			(
		    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
		) % 7
		__a           =			(
		    DOOMSDAY_NOT_LEAP[month - 1]
		    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
		    else DOOMSDAY_LEAP[month - 1]
		)
		__a           =			(dooms_day + day - day_anchor) % 7
		return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
				import doctest

				doctest.testmod()






