






from scipy.stats import pearsonr

import datasets


lowercase  							=					"\nPearson correlation coefficient and p-value for testing non-correlation.\nThe Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\nThe p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.\n"


lowercase  							=					"\nArgs:\n    predictions (`list` of `int`): Predicted class labels, as returned by a model.\n    references (`list` of `int`): Ground truth labels.\n    return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.\n\nReturns:\n    pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.\n    p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.\n\nExamples:\n\n    Example 1-A simple example using only predictions and references.\n        >>> pearsonr_metric = datasets.load_metric(\"pearsonr\")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])\n        >>> print(round(results['pearsonr'], 2))\n        -0.74\n\n    Example 2-The same as Example 1, but that also returns the `p-value`.\n        >>> pearsonr_metric = datasets.load_metric(\"pearsonr\")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)\n        >>> print(sorted(list(results.keys())))\n        ['p-value', 'pearsonr']\n        >>> print(round(results['pearsonr'], 2))\n        -0.74\n        >>> print(round(results['p-value'], 2))\n        0.15\n"


lowercase  							=					"\n@article{2020SciPy-NMeth,\nauthor  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n      Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n      Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n      Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n      Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n      Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n      Kern, Robert and Larson, Eric and Carey, C J and\n      Polat, Ilhan and Feng, Yu and Moore, Eric W. and\n      {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n      Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n      Harris, Charles R. and Archibald, Anne M. and\n      Ribeiro, Antonio H. and Pedregosa, Fabian and\n      {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\ntitle   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n      Computing in Python}},\njournal = {Nature Methods},\nyear    = {2020},\nvolume  = {17},\npages   = {261--272},\nadsurl  = {https://rdcu.be/b08Wh},\ndoi = {10.1038/s41592-019-0686-2},\n}\n"




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,					_KWARGS_DESCRIPTION				)
class  UpperCamelCase_      (			datasets.Metric				):



	'''simple docstring'''




	def 							_UpperCamelCase			(       self					)       ->    str:
								return datasets.MetricInfo(
								    description=_DESCRIPTION       ,			citation=_CITATION       ,			inputs_description=_KWARGS_DESCRIPTION       ,			features=datasets.Features(
								        {
								            'predictions': datasets.Value('float'					),
								            'references': datasets.Value('float'					),
								        }					)       ,			reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html']       ,			)






	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a=False					)       ->    Union[str, Any]:
								if return_pvalue:
															snake_case_				=							pearsonr(a       ,			a					)
															return {"pearsonr": results[0], "p-value": results[1]}
								else:
															return {"pearsonr": float(pearsonr(a       ,			a					)[0]					)}













import argparse
import json
from collections import OrderedDict
from pathlib import Path

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

from transformers import (
    SegformerConfig,
    SegformerForImageClassification,
    SegformerForSemanticSegmentation,
    SegformerImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowercase  							=					logging.get_logger(__name__)





def 						__UpperCAmelCase			(     a_							,     a_=False):
							snake_case_				=							OrderedDict()
							for key, value in state_dict.items():
														if encoder_only and not key.startswith('head'):
																					snake_case_				=							'segformer.encoder.' + key
														if key.startswith('backbone'):
																					snake_case_				=							key.replace('backbone'							,     'segformer.encoder')
														if "patch_embed" in key:
																					# replace for example patch_embed1 by patch_embeddings.0
																					snake_case_				=							key[key.find('patch_embed') + len('patch_embed')]
																					snake_case_				=							key.replace(f'''patch_embed{idx}'''							,     f'''patch_embeddings.{int(a_)-1}''')
														if "norm" in key:
																					snake_case_				=							key.replace('norm'							,     'layer_norm')
														if "segformer.encoder.layer_norm" in key:
																					# replace for example layer_norm1 by layer_norm.0
																					snake_case_				=							key[key.find('segformer.encoder.layer_norm') + len('segformer.encoder.layer_norm')]
																					snake_case_				=							key.replace(f'''layer_norm{idx}'''							,     f'''layer_norm.{int(a_)-1}''')
														if "layer_norm1" in key:
																					snake_case_				=							key.replace('layer_norm1'							,     'layer_norm_1')
														if "layer_norm2" in key:
																					snake_case_				=							key.replace('layer_norm2'							,     'layer_norm_2')
														if "block" in key:
																					# replace for example block1 by block.0
																					snake_case_				=							key[key.find('block') + len('block')]
																					snake_case_				=							key.replace(f'''block{idx}'''							,     f'''block.{int(a_)-1}''')
														if "attn.q" in key:
																					snake_case_				=							key.replace('attn.q'							,     'attention.self.query')
														if "attn.proj" in key:
																					snake_case_				=							key.replace('attn.proj'							,     'attention.output.dense')
														if "attn" in key:
																					snake_case_				=							key.replace('attn'							,     'attention.self')
														if "fc1" in key:
																					snake_case_				=							key.replace('fc1'							,     'dense1')
														if "fc2" in key:
																					snake_case_				=							key.replace('fc2'							,     'dense2')
														if "linear_pred" in key:
																					snake_case_				=							key.replace('linear_pred'							,     'classifier')
														if "linear_fuse" in key:
																					snake_case_				=							key.replace('linear_fuse.conv'							,     'linear_fuse')
																					snake_case_				=							key.replace('linear_fuse.bn'							,     'batch_norm')
														if "linear_c" in key:
																					# replace for example linear_c4 by linear_c.3
																					snake_case_				=							key[key.find('linear_c') + len('linear_c')]
																					snake_case_				=							key.replace(f'''linear_c{idx}'''							,     f'''linear_c.{int(a_)-1}''')
														if key.startswith('head'):
																					snake_case_				=							key.replace('head'							,     'classifier')
														snake_case_				=							value

							return new_state_dict





def 						__UpperCAmelCase			(     a_							,     a_):
							# for each of the encoder blocks:
							for i in range(config.num_encoder_blocks):
														for j in range(config.depths[i]):
																					# read in weights + bias of keys and values (which is a single matrix in the original implementation)
																					snake_case_				=							state_dict.pop(f'''segformer.encoder.block.{i}.{j}.attention.self.kv.weight''')
																					snake_case_				=							state_dict.pop(f'''segformer.encoder.block.{i}.{j}.attention.self.kv.bias''')
																					# next, add keys and values (in that order) to the state dict
																					snake_case_				=							kv_weight[
																					    : config.hidden_sizes[i], :
																					]
																					snake_case_				=							kv_bias[: config.hidden_sizes[i]]
																					snake_case_				=							kv_weight[
																					    config.hidden_sizes[i] :, :
																					]
																					snake_case_				=							kv_bias[
																					    config.hidden_sizes[i] :
																					]





def 						__UpperCAmelCase			(     ):
							snake_case_				=							'http://images.cocodataset.org/val2017/000000039769.jpg'
							snake_case_				=							Image.open(requests.get(a_							,     stream=a_).raw)

							return image





@torch.no_grad()
def 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							SegformerConfig()
							snake_case_				=							False

							# set attributes based on model_name
							snake_case_				=							'huggingface/label-files'
							if "segformer" in model_name:
														snake_case_				=							model_name[len('segformer.') : len('segformer.') + 2]
														if "ade" in model_name:
																					snake_case_				=							1_50
																					snake_case_				=							'ade20k-id2label.json'
																					snake_case_				=							(1, 1_50, 1_28, 1_28)
														elif "city" in model_name:
																					snake_case_				=							19
																					snake_case_				=							'cityscapes-id2label.json'
																					snake_case_				=							(1, 19, 1_28, 1_28)
														else:
																					raise ValueError(f'''Model {model_name} not supported''')
							elif "mit" in model_name:
														snake_case_				=							True
														snake_case_				=							model_name[4:6]
														snake_case_				=							10_00
														snake_case_				=							'imagenet-1k-id2label.json'
														snake_case_				=							(1, 10_00)
							else:
														raise ValueError(f'''Model {model_name} not supported''')

							# set config attributes
							snake_case_				=							json.load(open(hf_hub_download(a_							,     a_							,     repo_type='dataset')							,     'r'))
							snake_case_				=							{int(a_): v for k, v in idalabel.items()}
							snake_case_				=							idalabel
							snake_case_				=							{v: k for k, v in idalabel.items()}
							if size == "b0":
														pass
							elif size == "b1":
														snake_case_				=							[64, 1_28, 3_20, 5_12]
														snake_case_				=							2_56
							elif size == "b2":
														snake_case_				=							[64, 1_28, 3_20, 5_12]
														snake_case_				=							7_68
														snake_case_				=							[3, 4, 6, 3]
							elif size == "b3":
														snake_case_				=							[64, 1_28, 3_20, 5_12]
														snake_case_				=							7_68
														snake_case_				=							[3, 4, 18, 3]
							elif size == "b4":
														snake_case_				=							[64, 1_28, 3_20, 5_12]
														snake_case_				=							7_68
														snake_case_				=							[3, 8, 27, 3]
							elif size == "b5":
														snake_case_				=							[64, 1_28, 3_20, 5_12]
														snake_case_				=							7_68
														snake_case_				=							[3, 6, 40, 3]
							else:
														raise ValueError(f'''Size {size} not supported''')

							# load image processor (only resize + normalize)
							snake_case_				=							SegformerImageProcessor(
							    image_scale=(5_12, 5_12)							,     keep_ratio=a_							,     align=a_							,     do_random_crop=a_)

							# prepare image
							snake_case_				=							prepare_img()
							snake_case_				=							image_processor(images=a_							,     return_tensors='pt').pixel_values

							logger.info(f'''Converting model {model_name}...''')

							# load original state dict
							if encoder_only:
														snake_case_				=							torch.load(a_							,     map_location=torch.device('cpu'))
							else:
														snake_case_				=							torch.load(a_							,     map_location=torch.device('cpu'))['state_dict']

							# rename keys
							snake_case_				=							rename_keys(a_							,     encoder_only=a_)
							if not encoder_only:
														del state_dict["decode_head.conv_seg.weight"]
														del state_dict["decode_head.conv_seg.bias"]

							# key and value matrices need special treatment
							read_in_k_v(a_							,     a_)

							# create HuggingFace model and load state dict
							if encoder_only:
														snake_case_				=							False
														snake_case_				=							SegformerForImageClassification(a_)
							else:
														snake_case_				=							SegformerForSemanticSegmentation(a_)
							model.load_state_dict(a_)
							model.eval()

							# forward pass
							snake_case_				=							model(a_)
							snake_case_				=							outputs.logits

							# set expected_slice based on model name
							# ADE20k checkpoints
							if model_name == "segformer.b0.512x512.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-4.63_10, -5.52_32, -6.23_56], [-5.19_21, -6.14_44, -6.59_96], [-5.44_24, -6.27_90, -6.75_74]],
														        [[-12.13_91, -13.31_22, -13.95_54], [-12.87_32, -13.93_52, -14.35_63], [-12.94_38, -13.82_26, -14.25_13]],
														        [[-12.51_34, -13.46_86, -14.49_15], [-12.86_69, -14.43_43, -14.77_58], [-13.25_23, -14.58_19, -15.06_94]],
														    ])
							elif model_name == "segformer.b1.512x512.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-7.58_20, -8.72_31, -8.32_15], [-8.06_00, -10.35_29, -10.03_04], [-7.52_08, -9.41_03, -9.62_39]],
														        [[-12.69_18, -13.89_94, -13.71_37], [-13.31_96, -15.75_23, -15.47_89], [-12.93_43, -14.87_57, -14.96_89]],
														        [[-11.19_11, -11.94_21, -11.32_43], [-11.33_42, -13.68_39, -13.35_81], [-10.39_09, -12.18_32, -12.48_58]],
														    ])
							elif model_name == "segformer.b2.512x512.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-11.81_73, -14.38_50, -16.31_28], [-14.56_48, -16.58_04, -18.65_68], [-14.72_23, -15.73_87, -18.42_18]],
														        [[-15.72_90, -17.91_71, -19.44_23], [-18.31_05, -19.94_48, -21.46_61], [-17.92_96, -18.64_97, -20.79_10]],
														        [[-15.07_83, -17.03_36, -18.27_89], [-16.87_71, -18.68_70, -20.16_12], [-16.24_54, -17.14_26, -19.50_55]],
														    ])
							elif model_name == "segformer.b3.512x512.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-9.08_78, -10.20_81, -10.18_91], [-9.31_44, -10.79_41, -10.98_43], [-9.22_94, -10.38_55, -10.57_04]],
														        [[-12.23_16, -13.90_68, -13.61_02], [-12.91_61, -14.37_02, -14.32_35], [-12.52_33, -13.71_74, -13.79_32]],
														        [[-14.62_75, -15.24_90, -14.97_27], [-14.34_00, -15.96_87, -16.28_27], [-14.14_84, -15.40_33, -15.89_37]],
														    ])
							elif model_name == "segformer.b4.512x512.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-12.31_44, -13.24_47, -14.08_02], [-13.36_14, -14.58_16, -15.61_17], [-13.33_40, -14.44_33, -16.22_19]],
														        [[-19.27_81, -20.41_28, -20.75_06], [-20.61_53, -21.65_66, -22.09_98], [-19.98_00, -21.04_30, -22.14_94]],
														        [[-18.87_39, -19.78_04, -21.18_34], [-20.12_33, -21.67_65, -23.29_44], [-20.03_15, -21.26_41, -23.69_44]],
														    ])
							elif model_name == "segformer.b5.640x640.ade.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-9.55_24, -12.08_35, -11.73_48], [-10.52_29, -13.64_46, -14.56_62], [-9.58_42, -12.88_51, -13.94_14]],
														        [[-15.34_32, -17.53_23, -17.08_18], [-16.33_30, -18.92_55, -19.21_01], [-15.13_40, -17.78_48, -18.39_71]],
														        [[-12.60_72, -14.94_86, -14.66_31], [-13.76_29, -17.09_07, -17.77_45], [-12.78_99, -16.16_95, -17.16_71]],
														    ])
							# Cityscapes checkpoints
							elif model_name == "segformer.b0.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-11.92_95, -13.40_57, -14.81_06], [-13.34_31, -14.81_79, -15.37_81], [-14.28_36, -15.59_42, -16.15_88]],
														        [[-11.49_06, -12.80_67, -13.65_64], [-13.11_89, -14.05_00, -14.15_43], [-13.87_48, -14.51_36, -14.87_89]],
														        [[0.53_74, 0.10_67, -0.47_42], [0.11_41, -0.22_55, -0.70_99], [-0.30_00, -0.59_24, -1.31_05]],
														    ])
							elif model_name == "segformer.b0.512x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-7.82_17, -9.87_67, -10.17_17], [-9.44_38, -10.90_58, -11.40_47], [-9.79_39, -12.34_95, -12.10_79]],
														        [[-7.15_14, -9.53_36, -10.08_60], [-9.77_76, -11.68_22, -11.84_39], [-10.14_11, -12.76_55, -12.89_72]],
														        [[0.30_21, 0.08_05, -0.23_10], [-0.03_28, -0.16_05, -0.27_14], [-0.14_08, -0.54_77, -0.69_76]],
														    ])
							elif model_name == "segformer.b0.640x1280.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [
														            [-1.1_372E01, -1.2_787E01, -1.3_477E01],
														            [-1.2_536E01, -1.4_194E01, -1.4_409E01],
														            [-1.3_217E01, -1.4_888E01, -1.5_327E01],
														        ],
														        [
														            [-1.4_791E01, -1.7_122E01, -1.8_277E01],
														            [-1.7_163E01, -1.9_192E01, -1.9_533E01],
														            [-1.7_897E01, -1.9_991E01, -2.0_315E01],
														        ],
														        [
														            [7.6_723E-01, 4.1_921E-01, -7.7_878E-02],
														            [4.7_772E-01, 9.5_557E-03, -2.8_082E-01],
														            [3.6_032E-01, -2.4_826E-01, -5.1_168E-01],
														        ],
														    ])
							elif model_name == "segformer.b0.768x768.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-9.49_59, -11.30_87, -11.74_79], [-11.00_25, -12.65_40, -12.33_19], [-11.40_64, -13.04_87, -12.99_05]],
														        [[-9.89_05, -11.30_84, -12.08_54], [-11.17_26, -12.76_98, -12.95_83], [-11.59_85, -13.32_78, -14.17_74]],
														        [[0.22_13, 0.01_92, -0.24_66], [-0.17_31, -0.42_13, -0.48_74], [-0.31_26, -0.65_41, -1.13_89]],
														    ])
							elif model_name == "segformer.b1.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-13.57_48, -13.91_11, -12.65_00], [-14.35_00, -15.36_83, -14.23_28], [-14.75_32, -16.04_24, -15.60_87]],
														        [[-17.16_51, -15.87_25, -12.96_53], [-17.25_80, -17.37_18, -14.82_23], [-16.60_58, -16.87_83, -16.74_52]],
														        [[-3.64_56, -3.02_09, -1.42_03], [-3.07_97, -3.19_59, -2.00_00], [-1.87_57, -1.92_17, -1.69_97]],
														    ])
							elif model_name == "segformer.b2.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-16.09_76, -16.48_56, -17.39_62], [-16.62_34, -19.03_42, -19.76_85], [-16.09_00, -18.06_61, -19.11_80]],
														        [[-18.47_50, -18.84_88, -19.50_74], [-19.40_30, -22.15_70, -22.59_77], [-19.11_91, -20.84_86, -22.37_83]],
														        [[-4.51_78, -5.50_37, -6.51_09], [-5.08_84, -7.21_74, -8.03_34], [-4.41_56, -5.81_17, -7.29_70]],
														    ])
							elif model_name == "segformer.b3.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-14.20_81, -14.47_32, -14.19_77], [-14.58_67, -16.44_23, -16.63_56], [-13.44_41, -14.96_85, -16.86_96]],
														        [[-14.45_76, -14.70_73, -15.04_51], [-15.08_16, -17.62_37, -17.98_73], [-14.42_13, -16.01_99, -18.59_92]],
														        [[-4.73_49, -4.95_88, -5.09_66], [-4.32_10, -6.93_25, -7.25_91], [-3.43_12, -4.74_84, -7.19_17]],
														    ])
							elif model_name == "segformer.b4.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-11.77_37, -11.95_26, -11.32_73], [-13.66_92, -14.45_74, -13.88_78], [-13.89_37, -14.69_24, -15.93_45]],
														        [[-14.67_06, -14.53_30, -14.13_06], [-16.15_02, -16.81_80, -16.42_69], [-16.83_38, -17.89_39, -20.17_46]],
														        [[1.04_91, 0.82_89, 1.03_10], [1.10_44, 0.52_19, 0.80_55], [1.08_99, 0.69_26, 0.55_90]],
														    ])
							elif model_name == "segformer.b5.1024x1024.city.160k":
														snake_case_				=							torch.tensor(
														    [
														        [[-12.56_41, -13.47_77, -13.06_84], [-13.95_87, -15.89_83, -16.65_57], [-13.31_09, -15.73_50, -16.31_41]],
														        [[-14.70_74, -15.43_52, -14.59_44], [-16.63_53, -18.16_63, -18.61_20], [-15.17_02, -18.03_29, -18.15_47]],
														        [[-1.79_90, -2.09_51, -1.77_84], [-2.63_97, -3.82_45, -3.96_86], [-1.52_64, -2.81_26, -2.93_16]],
														    ])
							else:
														snake_case_				=							logits.argmax(-1).item()
														print('Predicted class:'							,     model.config.idalabel[predicted_class_idx])

							# verify logits
							if not encoder_only:
														assert logits.shape == expected_shape
														assert torch.allclose(logits[0, :3, :3, :3]							,     a_							,     atol=1E-2)

							# finally, save model and image processor
							logger.info(f'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...''')
							Path(a_).mkdir(exist_ok=a_)
							model.save_pretrained(a_)
							image_processor.save_pretrained(a_)


if __name__ == "__main__":
	lowercase  							=					argparse.ArgumentParser()

	parser.add_argument(
	    "--model_name",
	    default="segformer.b0.512x512.ade.160k",
	    type=str,
	    help="Name of the model you'd like to convert.",
	)
	parser.add_argument(
	    "--checkpoint_path", default=None, type=str, help="Path to the original PyTorch checkpoint (.pth file)."
	)
	parser.add_argument(
	    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
	)
	lowercase  							=					parser.parse_args()
	convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)





