





"""simple docstring"""




# 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


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






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Any=None   )					->Union[str, Any]:






	'''simple docstring'''






	if subparsers is not None:
		a :						Optional[int]      =							subparsers.add_parser("tpu-config"       ,			description=_description   )
	else:
		a :						Optional[Any]      =							argparse.ArgumentParser("Accelerate tpu-config command"       ,			description=_description   )
	# Core arguments
	a :						Dict      =							parser.add_argument_group(
	    "Config Arguments"       ,			"Arguments that can be configured through `accelerate config`."   )
	config_args.add_argument(
	    "--config_file"       ,			type=_lowercase       ,			default=_lowercase       ,			help="Path to the config file to use for accelerate."       ,			)
	config_args.add_argument(
	    "--tpu_name"       ,			default=_lowercase       ,			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=_lowercase       ,			help="The zone of the TPU to use. If not specified, will use the zone specified in the config file."       ,			)
	a :						int      =							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=_lowercase       ,			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=_lowercase   )
	return parser






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Union[str, Any]   )					->Any:






	'''simple docstring'''






	a :						List[Any]      =							None

	# Get the default from the config file if it exists.
	if args.config_file is not None or os.path.isfile(_lowercase   ):
		a :						Union[str, Any]      =							load_config_from_file(args.config_file   )
		if not args.command_file and defaults.command_file is not None and not args.command:
			a :						Union[str, Any]      =							defaults.command_file
		if not args.command and defaults.commands is not None:
			a :						Union[str, Any]      =							defaults.commands
		if not args.tpu_name:
			a :						List[Any]      =							defaults.tpu_name
		if not args.tpu_zone:
			a :						str      =							defaults.tpu_zone
	if args.accelerate_version == "dev":
		a :						List[str]      =							"git+https://github.com/huggingface/accelerate.git"
	elif args.accelerate_version == "latest":
		a :						Union[str, Any]      =							"accelerate -U"
	elif isinstance(parse(args.accelerate_version   )       ,			_lowercase   ):
		a :						Optional[Any]      =							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:
			a :						List[str]      =							[f.read().splitlines()]

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

	# Then send it to gcloud
	# Eventually try to use google-api-core to do this instead of subprocess
	a :						Union[str, Any]      =							["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(_lowercase   )}"""   )
		return
	subprocess.run(_lowercase   )
	print("Successfully setup pod."   )







def  _SCREAMING_SNAKE_CASE						(      )					->Optional[int]:






	'''simple docstring'''






	a :						Tuple      =							tpu_command_parser()
	a :						int      =							parser.parse_args()

	tpu_command_launcher(_lowercase   )









"""simple docstring"""




import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       List[Any]   )					->Dict:






	'''simple docstring'''






	a :						Any      =							[2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
	a :						str      =							True if "large" in model_name or "huge" in model_name else False
	a :						Optional[Any]      =							True if "large" in model_name or "huge" in model_name else False
	a :						Dict      =							True if "large" in model_name or "huge" in model_name else False

	if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
		if "fl3" in model_name:
			a :						Union[str, Any]      =							[3, 3, 3, 3]
			a :						List[str]      =							[5, 5, 5, 5]
		elif "fl4" in model_name:
			a :						Any      =							[4, 4, 4, 4]
			a :						Optional[Any]      =							[3, 3, 3, 3]

	if "tiny" in model_name or "small" in model_name or "base" in model_name:
		a :						Dict      =							[3, 3, 3, 3]
		if "lrf" in model_name:
			a :						Optional[int]      =							[3, 3, 3, 3]
		else:
			a :						Tuple      =							[2, 2, 2, 2]

	if "tiny" in model_name:
		a :						List[str]      =							96
	elif "small" in model_name:
		a :						Union[str, Any]      =							96
	elif "base" in model_name:
		a :						Dict      =							128
	elif "large" in model_name:
		a :						Union[str, Any]      =							192
	elif "xlarge" in model_name:
		a :						Tuple      =							256
	elif "huge" in model_name:
		a :						List[str]      =							352

	# set label information
	a :						List[Any]      =							"huggingface/label-files"
	if "large" in model_name or "huge" in model_name:
		a :						Optional[int]      =							"imagenet-22k-id2label.json"
	else:
		a :						List[str]      =							"imagenet-1k-id2label.json"

	a :						Optional[int]      =							json.load(open(hf_hub_download(_lowercase       ,			_lowercase       ,			repo_type="dataset"   )       ,			"r"   )   )
	a :						str      =							{int(_lowercase   ): v for k, v in idalabel.items()}
	a :						List[str]      =							{v: k for k, v in idalabel.items()}

	a :						Dict      =							FocalNetConfig(
	    embed_dim=_lowercase       ,			depths=_lowercase       ,			focal_levels=_lowercase       ,			focal_windows=_lowercase       ,			use_conv_embed=_lowercase       ,			idalabel=_lowercase       ,			labelaid=_lowercase       ,			use_post_layernorm=_lowercase       ,			use_layerscale=_lowercase       ,			)

	return config






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       List[str]   )					->List[Any]:






	'''simple docstring'''






	if "patch_embed.proj" in name:
		a :						Any      =							name.replace("patch_embed.proj"       ,			"embeddings.patch_embeddings.projection"   )
	if "patch_embed.norm" in name:
		a :						List[str]      =							name.replace("patch_embed.norm"       ,			"embeddings.norm"   )
	if "layers" in name:
		a :						List[Any]      =							"encoder." + name
	if "encoder.layers" in name:
		a :						int      =							name.replace("encoder.layers"       ,			"encoder.stages"   )
	if "downsample.proj" in name:
		a :						Any      =							name.replace("downsample.proj"       ,			"downsample.projection"   )
	if "blocks" in name:
		a :						str      =							name.replace("blocks"       ,			"layers"   )
	if "modulation.f.weight" in name or "modulation.f.bias" in name:
		a :						Union[str, Any]      =							name.replace("modulation.f"       ,			"modulation.projection_in"   )
	if "modulation.h.weight" in name or "modulation.h.bias" in name:
		a :						Dict      =							name.replace("modulation.h"       ,			"modulation.projection_context"   )
	if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
		a :						Any      =							name.replace("modulation.proj"       ,			"modulation.projection_out"   )

	if name == "norm.weight":
		a :						str      =							"layernorm.weight"
	if name == "norm.bias":
		a :						Optional[Any]      =							"layernorm.bias"

	if "head" in name:
		a :						Tuple      =							name.replace("head"       ,			"classifier"   )
	else:
		a :						int      =							"focalnet." + name

	return name






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Tuple       ,			_lowercase		:       Optional[Any]       ,			_lowercase		:       Tuple=False   )					->str:






	'''simple docstring'''






	a :						List[Any]      =							{
	    "focalnet-tiny": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth",
	    "focalnet-tiny-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth",
	    "focalnet-small": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth",
	    "focalnet-small-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth",
	    "focalnet-base": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth",
	    "focalnet-base-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth",
	    "focalnet-large-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth",
	    "focalnet-large-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth",
	    "focalnet-xlarge-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth",
	    "focalnet-xlarge-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth",
	}
	# fmt: on

	a :						str      =							model_name_to_url[model_name]
	print("Checkpoint URL: "       ,			_lowercase   )
	a :						Any      =							torch.hub.load_state_dict_from_url(_lowercase       ,			map_location="cpu"   )["model"]

	# rename keys
	for key in state_dict.copy().keys():
		a :						Any      =							state_dict.pop(_lowercase   )
		a :						Any      =							val

	a :						Any      =							get_focalnet_config(_lowercase   )
	a :						Optional[int]      =							FocalNetForImageClassification(_lowercase   )
	model.eval()

	# load state dict
	model.load_state_dict(_lowercase   )

	# verify conversion
	a :						Union[str, Any]      =							"http://images.cocodataset.org/val2017/000000039769.jpg"

	a :						Optional[int]      =							BitImageProcessor(
	    do_resize=_lowercase       ,			size={"shortest_edge": 256}       ,			resample=PILImageResampling.BILINEAR       ,			do_center_crop=_lowercase       ,			crop_size=224       ,			do_normalize=_lowercase       ,			image_mean=_lowercase       ,			image_std=_lowercase       ,			)
	a :						int      =							Image.open(requests.get(_lowercase       ,			stream=_lowercase   ).raw   )
	a :						Dict      =							processor(images=_lowercase       ,			return_tensors="pt"   )

	a :						Optional[int]      =							transforms.Compose(
	    [
	        transforms.Resize(256   ),
	        transforms.CenterCrop(224   ),
	        transforms.ToTensor(),
	        transforms.Normalize(mean=[0.485, 0.456, 0.406]       ,			std=[0.229, 0.224, 0.225]   ),
	    ]   )

	a :						str      =							image_transforms(_lowercase   ).unsqueeze(0   )

	# verify pixel_values
	assert torch.allclose(inputs.pixel_values       ,			_lowercase       ,			atol=1E-4   )

	a :						Dict      =							model(**_lowercase   )

	a :						List[str]      =							outputs.logits.argmax(-1   ).item()
	print("Predicted class:"       ,			model.config.idalabel[predicted_class_idx]   )

	print("First values of logits:"       ,			outputs.logits[0, :3]   )

	if model_name == "focalnet-tiny":
		a :						Union[str, Any]      =							torch.tensor([0.2166, -0.4368, 0.2191]   )
	elif model_name == "focalnet-tiny-lrf":
		a :						Union[str, Any]      =							torch.tensor([1.1669, 0.0125, -0.1695]   )
	elif model_name == "focalnet-small":
		a :						Dict      =							torch.tensor([0.4917, -0.0430, 0.1341]   )
	elif model_name == "focalnet-small-lrf":
		a :						Dict      =							torch.tensor([-0.2588, -0.5342, -0.2331]   )
	elif model_name == "focalnet-base":
		a :						Any      =							torch.tensor([-0.1655, -0.4090, -0.1730]   )
	elif model_name == "focalnet-base-lrf":
		a :						str      =							torch.tensor([0.5306, -0.0483, -0.3928]   )
	assert torch.allclose(outputs.logits[0, :3]       ,			_lowercase       ,			atol=1E-4   )
	print("Looks ok!"   )

	if pytorch_dump_folder_path is not None:
		print(F"""Saving model and processor of {model_name} to {pytorch_dump_folder_path}"""   )
		model.save_pretrained(_lowercase   )
		processor.save_pretrained(_lowercase   )

	if push_to_hub:
		print(F"""Pushing model and processor of {model_name} to the hub..."""   )
		model.push_to_hub(F"""{model_name}"""   )
		processor.push_to_hub(F"""{model_name}"""   )


if __name__ == "__main__":
		a		:					str	      =     argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--model_name''',
		    default='''focalnet-tiny''',
		    type=str,
		    help='''Name of the FocalNet 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.'''
		)
		parser.add_argument(
		    '''--push_to_hub''',
		    action='''store_true''',
		    help='''Whether to push the model and processor to the hub.''',
		)

		a		:					Tuple	      =     parser.parse_args()
		convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


