


import math
import os
from copy import deepcopy

import datasets
import evaluate
import torch
import transformers
from datasets import load_dataset
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer

from accelerate import Accelerator
from accelerate.test_utils import RegressionDataset, RegressionModel
from accelerate.utils import is_tpu_available, set_seed


_lowercase							:   int						=						"true"





def 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  Optional[int]=82				,       UpperCamelCase__:  Optional[int]=16    )			-> List[str]:





	"""simple docstring"""







	set_seed(42    )
	A             =					RegressionModel()
	A             =					deepcopy(UpperCamelCase__    )
	A             =					RegressionDataset(length=UpperCamelCase__    )
	A             =					DataLoader(UpperCamelCase__				,       batch_size=UpperCamelCase__    )
	model.to(accelerator.device    )
	A       ,      A             =					accelerator.prepare(UpperCamelCase__				,       UpperCamelCase__    )
	return model, ddp_model, dataloader





def 	_lowerCAmelCase					( UpperCamelCase__:  Accelerator				,       UpperCamelCase__:  Union[str, Any]=False    )			-> Dict:





	"""simple docstring"""







	A             =					AutoTokenizer.from_pretrained("""hf-internal-testing/mrpc-bert-base-cased"""    )
	A             =					load_dataset("""glue"""				,       """mrpc"""				,       split="""validation"""    )

	def tokenize_function(UpperCamelCase__:  Optional[Any]    ):
		A             =					tokenizer(examples["""sentence1"""]				,       examples["""sentence2"""]				,       truncation=UpperCamelCase__				,       max_length=UpperCamelCase__    )
		return outputs

	with accelerator.main_process_first():
		A             =					dataset.map(
		    UpperCamelCase__				,       batched=UpperCamelCase__				,       remove_columns=["""idx""", """sentence1""", """sentence2"""]				,       )

	A             =					tokenized_datasets.rename_column("""label"""				,       """labels"""    )

	def collate_fn(UpperCamelCase__:  Dict    ):
		if use_longest:
			return tokenizer.pad(UpperCamelCase__				,       padding="""longest"""				,       return_tensors="""pt"""    )
		return tokenizer.pad(UpperCamelCase__				,       padding="""max_length"""				,       max_length=1_28				,       return_tensors="""pt"""    )

	return DataLoader(UpperCamelCase__				,       shuffle=UpperCamelCase__				,       collate_fn=UpperCamelCase__				,       batch_size=16    )





def 	_lowerCAmelCase					( UpperCamelCase__:  int				,       UpperCamelCase__:  List[str]    )			-> List[Any]:





	"""simple docstring"""







	A             =					Accelerator(dispatch_batches=UpperCamelCase__				,       split_batches=UpperCamelCase__    )
	A             =					get_dataloader(UpperCamelCase__				,       not dispatch_batches    )
	A             =					AutoModelForSequenceClassification.from_pretrained(
	    """hf-internal-testing/mrpc-bert-base-cased"""				,       return_dict=UpperCamelCase__    )
	A       ,      A             =					accelerator.prepare(UpperCamelCase__				,       UpperCamelCase__    )
	return {"ddp": [ddp_model, ddp_dataloader, "cuda:0"], "no": [model, dataloader, accelerator.device]}, accelerator





def 	_lowerCAmelCase					( UpperCamelCase__:  int				,       UpperCamelCase__:  Optional[int]				,       UpperCamelCase__:  Tuple    )			-> Dict:





	"""simple docstring"""







	A             =					[]
	for batch in dataloader:
		A       ,      A             =					batch.values()
		with torch.no_grad():
			A             =					model(UpperCamelCase__    )
			A       ,      A             =					accelerator.gather_for_metrics((logit, target)    )
			logits_and_targets.append((logit, target)    )
	A       ,      A             =					[], []
	for logit, targ in logits_and_targets:
		logits.append(UpperCamelCase__    )
		targs.append(UpperCamelCase__    )
	A       ,      A             =					torch.cat(UpperCamelCase__    ), torch.cat(UpperCamelCase__    )
	return logits, targs





def 	_lowerCAmelCase					( UpperCamelCase__:  Accelerator				,       UpperCamelCase__:  int=82				,       UpperCamelCase__:  Dict=False				,       UpperCamelCase__:  Any=False				,       UpperCamelCase__:  Union[str, Any]=16    )			-> Optional[Any]:





	"""simple docstring"""







	A       ,      A       ,      A             =					get_basic_setup(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__    )
	A       ,      A             =					generate_predictions(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__    )
	assert (
	    len(UpperCamelCase__    ) == num_samples
	), f'Unexpected number of inputs:\n    Expected: {num_samples}\n    Actual: {len(UpperCamelCase__    )}'





def 	_lowerCAmelCase					( UpperCamelCase__:  bool = False				,       UpperCamelCase__:  bool = False    )			-> Dict:





	"""simple docstring"""







	A             =					evaluate.load("""glue"""				,       """mrpc"""    )
	A       ,      A             =					get_mrpc_setup(UpperCamelCase__				,       UpperCamelCase__    )
	# First do baseline
	A       ,      A       ,      A             =					setup["""no"""]
	model.to(UpperCamelCase__    )
	model.eval()
	for batch in dataloader:
		batch.to(UpperCamelCase__    )
		with torch.inference_mode():
			A             =					model(**UpperCamelCase__    )
		A             =					outputs.logits.argmax(dim=-1    )
		metric.add_batch(predictions=UpperCamelCase__				,       references=batch["""labels"""]    )
	A             =					metric.compute()

	# Then do distributed
	A       ,      A       ,      A             =					setup["""ddp"""]
	model.eval()
	for batch in dataloader:
		with torch.inference_mode():
			A             =					model(**UpperCamelCase__    )
		A             =					outputs.logits.argmax(dim=-1    )
		A             =					batch["""labels"""]
		A       ,      A             =					accelerator.gather_for_metrics((preds, references)    )
		metric.add_batch(predictions=UpperCamelCase__				,       references=UpperCamelCase__    )
	A             =					metric.compute()

	for key in "accuracy f1".split():
		assert math.isclose(
		    baseline[key]				,       distributed[key]    ), f'Baseline and Distributed are not the same for key {key}:\n\tBaseline: {baseline[key]}\n\tDistributed: {distributed[key]}\n'





def 	_lowerCAmelCase					( )			-> int:





	"""simple docstring"""







	A             =					Accelerator(split_batches=UpperCamelCase__				,       dispatch_batches=UpperCamelCase__    )
	if accelerator.is_local_main_process:
		datasets.utils.logging.set_verbosity_warning()
		transformers.utils.logging.set_verbosity_warning()
	else:
		datasets.utils.logging.set_verbosity_error()
		transformers.utils.logging.set_verbosity_error()
	# These are a bit slower so they should only be ran on the GPU or TPU
	if torch.cuda.is_available() or is_tpu_available():
		if accelerator.is_local_main_process:
			print("""**Testing gather_for_metrics**"""    )
		for split_batches in [True, False]:
			for dispatch_batches in [True, False]:
				if accelerator.is_local_main_process:
					print(f'With: `split_batches={split_batches}`, `dispatch_batches={dispatch_batches}`'    )
				test_mrpc(UpperCamelCase__				,       UpperCamelCase__    )
				accelerator.state._reset_state()
	if accelerator.is_local_main_process:
		print("""**Test torch metrics**"""    )
	for split_batches in [True, False]:
		for dispatch_batches in [True, False]:
			A             =					Accelerator(split_batches=UpperCamelCase__				,       dispatch_batches=UpperCamelCase__    )
			if accelerator.is_local_main_process:
				print(f'With: `split_batches={split_batches}`, `dispatch_batches={dispatch_batches}`, length=99'    )
			test_torch_metrics(UpperCamelCase__				,       99    )
			accelerator.state._reset_state()
	if accelerator.is_local_main_process:
		print("""**Test last batch is not dropped when perfectly divisible**"""    )
	A             =					Accelerator()
	test_torch_metrics(UpperCamelCase__				,       5_12    )
	accelerator.state._reset_state()





def 	_lowerCAmelCase					( UpperCamelCase__:  str    )			-> Any:





	"""simple docstring"""







	main()


if __name__ == "__main__":
				main()







import argparse
import json

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

from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation





def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					3_84
	if "tiny" in model_name:
		A             =					[3, 3, 9, 3]
		A             =					[96, 1_92, 3_84, 7_68]
	if "small" in model_name:
		A             =					[3, 3, 27, 3]
		A             =					[96, 1_92, 3_84, 7_68]
	if "base" in model_name:
		A             =					[3, 3, 27, 3]
		A             =					[1_28, 2_56, 5_12, 10_24]
		A             =					5_12
	if "large" in model_name:
		A             =					[3, 3, 27, 3]
		A             =					[1_92, 3_84, 7_68, 15_36]
		A             =					7_68
	if "xlarge" in model_name:
		A             =					[3, 3, 27, 3]
		A             =					[2_56, 5_12, 10_24, 20_48]
		A             =					10_24

	# set label information
	A             =					1_50
	A             =					"""huggingface/label-files"""
	A             =					"""ade20k-id2label.json"""
	A             =					json.load(open(hf_hub_download(UpperCamelCase__				,       UpperCamelCase__				,       repo_type="""dataset"""    )				,       """r"""    )    )
	A             =					{int(UpperCamelCase__    ): v for k, v in idalabel.items()}
	A             =					{v: k for k, v in idalabel.items()}

	A             =					ConvNextConfig(
	    depths=UpperCamelCase__				,       hidden_sizes=UpperCamelCase__				,       out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]    )
	A             =					UperNetConfig(
	    backbone_config=UpperCamelCase__				,       auxiliary_in_channels=UpperCamelCase__				,       num_labels=UpperCamelCase__				,       idalabel=UpperCamelCase__				,       labelaid=UpperCamelCase__				,       )

	return config





def 	_lowerCAmelCase					( UpperCamelCase__:  int    )			-> Dict:





	"""simple docstring"""







	A             =					[]

	# fmt: off
	# stem
	rename_keys.append(("""backbone.downsample_layers.0.0.weight""", """backbone.embeddings.patch_embeddings.weight""")    )
	rename_keys.append(("""backbone.downsample_layers.0.0.bias""", """backbone.embeddings.patch_embeddings.bias""")    )
	rename_keys.append(("""backbone.downsample_layers.0.1.weight""", """backbone.embeddings.layernorm.weight""")    )
	rename_keys.append(("""backbone.downsample_layers.0.1.bias""", """backbone.embeddings.layernorm.bias""")    )
	# stages
	for i in range(len(config.backbone_config.depths    )    ):
		for j in range(config.backbone_config.depths[i]    ):
			rename_keys.append((f'backbone.stages.{i}.{j}.gamma', f'backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.depthwise_conv.weight', f'backbone.encoder.stages.{i}.layers.{j}.dwconv.weight')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.depthwise_conv.bias', f'backbone.encoder.stages.{i}.layers.{j}.dwconv.bias')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.norm.weight', f'backbone.encoder.stages.{i}.layers.{j}.layernorm.weight')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.norm.bias', f'backbone.encoder.stages.{i}.layers.{j}.layernorm.bias')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.pointwise_conv1.weight', f'backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.pointwise_conv1.bias', f'backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.pointwise_conv2.weight', f'backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight')    )
			rename_keys.append((f'backbone.stages.{i}.{j}.pointwise_conv2.bias', f'backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias')    )
		if i > 0:
			rename_keys.append((f'backbone.downsample_layers.{i}.0.weight', f'backbone.encoder.stages.{i}.downsampling_layer.0.weight')    )
			rename_keys.append((f'backbone.downsample_layers.{i}.0.bias', f'backbone.encoder.stages.{i}.downsampling_layer.0.bias')    )
			rename_keys.append((f'backbone.downsample_layers.{i}.1.weight', f'backbone.encoder.stages.{i}.downsampling_layer.1.weight')    )
			rename_keys.append((f'backbone.downsample_layers.{i}.1.bias', f'backbone.encoder.stages.{i}.downsampling_layer.1.bias')    )

		rename_keys.append((f'backbone.norm{i}.weight', f'backbone.hidden_states_norms.stage{i+1}.weight')    )
		rename_keys.append((f'backbone.norm{i}.bias', f'backbone.hidden_states_norms.stage{i+1}.bias')    )

	# decode head
	rename_keys.extend(
	    [
	        ("""decode_head.conv_seg.weight""", """decode_head.classifier.weight"""),
	        ("""decode_head.conv_seg.bias""", """decode_head.classifier.bias"""),
	        ("""auxiliary_head.conv_seg.weight""", """auxiliary_head.classifier.weight"""),
	        ("""auxiliary_head.conv_seg.bias""", """auxiliary_head.classifier.bias"""),
	    ]    )
	# fmt: on

	return rename_keys





def 	_lowerCAmelCase					( UpperCamelCase__:  Tuple				,       UpperCamelCase__:  List[str]				,       UpperCamelCase__:  int    )			-> Optional[Any]:





	"""simple docstring"""







	A             =					dct.pop(UpperCamelCase__    )
	A             =					val





def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]				,       UpperCamelCase__:  Any				,       UpperCamelCase__:  int    )			-> List[Any]:





	"""simple docstring"""







	A             =					{
	    """upernet-convnext-tiny""": """https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth""",
	    """upernet-convnext-small""": """https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth""",
	    """upernet-convnext-base""": """https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth""",
	    """upernet-convnext-large""": """https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth""",
	    """upernet-convnext-xlarge""": """https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth""",
	}
	A             =					model_name_to_url[model_name]
	A             =					torch.hub.load_state_dict_from_url(UpperCamelCase__				,       map_location="""cpu"""    )["""state_dict"""]

	A             =					get_upernet_config(UpperCamelCase__    )
	A             =					UperNetForSemanticSegmentation(UpperCamelCase__    )
	model.eval()

	# replace "bn" => "batch_norm"
	for key in state_dict.copy().keys():
		A             =					state_dict.pop(UpperCamelCase__    )
		if "bn" in key:
			A             =					key.replace("""bn"""				,       """batch_norm"""    )
		A             =					val

	# rename keys
	A             =					create_rename_keys(UpperCamelCase__    )
	for src, dest in rename_keys:
		rename_key(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__    )

	model.load_state_dict(UpperCamelCase__    )

	# verify on image
	A             =					"""https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"""
	A             =					Image.open(requests.get(UpperCamelCase__				,       stream=UpperCamelCase__    ).raw    ).convert("""RGB"""    )

	A             =					SegformerImageProcessor()
	A             =					processor(UpperCamelCase__				,       return_tensors="""pt"""    ).pixel_values

	with torch.no_grad():
		A             =					model(UpperCamelCase__    )

	if model_name == "upernet-convnext-tiny":
		A             =					torch.tensor(
		    [[-8.81_10, -8.81_10, -8.65_21], [-8.81_10, -8.81_10, -8.65_21], [-8.77_46, -8.77_46, -8.61_30]]    )
	elif model_name == "upernet-convnext-small":
		A             =					torch.tensor(
		    [[-8.82_36, -8.82_36, -8.67_71], [-8.82_36, -8.82_36, -8.67_71], [-8.76_38, -8.76_38, -8.62_40]]    )
	elif model_name == "upernet-convnext-base":
		A             =					torch.tensor(
		    [[-8.85_58, -8.85_58, -8.69_05], [-8.85_58, -8.85_58, -8.69_05], [-8.76_69, -8.76_69, -8.60_21]]    )
	elif model_name == "upernet-convnext-large":
		A             =					torch.tensor(
		    [[-8.66_60, -8.66_60, -8.62_10], [-8.66_60, -8.66_60, -8.62_10], [-8.63_10, -8.63_10, -8.59_64]]    )
	elif model_name == "upernet-convnext-xlarge":
		A             =					torch.tensor(
		    [[-8.49_80, -8.49_80, -8.39_77], [-8.49_80, -8.49_80, -8.39_77], [-8.43_79, -8.43_79, -8.34_12]]    )
	print("""Logits:"""				,       outputs.logits[0, 0, :3, :3]    )
	assert torch.allclose(outputs.logits[0, 0, :3, :3]				,       UpperCamelCase__				,       atol=1e-4    )
	print("""Looks ok!"""    )

	if pytorch_dump_folder_path is not None:
		print(f'Saving model {model_name} to {pytorch_dump_folder_path}'    )
		model.save_pretrained(UpperCamelCase__    )
		print(f'Saving processor to {pytorch_dump_folder_path}'    )
		processor.save_pretrained(UpperCamelCase__    )

	if push_to_hub:
		print(f'Pushing model and processor for {model_name} to hub'    )
		model.push_to_hub(f'openmmlab/{model_name}'    )
		processor.push_to_hub(f'openmmlab/{model_name}'    )


if __name__ == "__main__":
				_lowercase							:   List[str]						=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    "--model_name",
				    default="upernet-convnext-tiny",
				    type=str,
				    choices=[f'''upernet-convnext-{size}''' for size in ["tiny", "small", "base", "large", "xlarge"]],
				    help="Name of the ConvNext UperNet 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 or not to push the converted model to the 🤗 hub."
				)

				_lowercase							:   str						=						parser.parse_args()
				convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



