
"""simple docstring"""







import inspect
import unittest

from transformers import BitConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
		from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image







class 							__magic_name__     :





					def __init__(				self   :							List[str]							,						snake_case_   :							int							,						snake_case_   :							Dict=3							,						snake_case_   :							int=32							,						snake_case_   :							Union[str, Any]=3							,						snake_case_   :							int=10							,						snake_case_   :							Dict=[8, 16, 32, 64]							,						snake_case_   :							Union[str, Any]=[1, 1, 2, 1]							,						snake_case_   :							Union[str, Any]=True							,						snake_case_   :							Tuple=True							,						snake_case_   :							Union[str, Any]="relu"							,						snake_case_   :							Dict=3							,						snake_case_   :							Tuple=None							,						snake_case_   :							List[Any]=["stage2", "stage3", "stage4"]							,						snake_case_   :							int=[2, 3, 4]							,						snake_case_   :							Tuple=1							,						):
												__snake_case     			=       parent
												__snake_case     			=       batch_size
												__snake_case     			=       image_size
												__snake_case     			=       num_channels
												__snake_case     			=       embeddings_size
												__snake_case     			=       hidden_sizes
												__snake_case     			=       depths
												__snake_case     			=       is_training
												__snake_case     			=       use_labels
												__snake_case     			=       hidden_act
												__snake_case     			=       num_labels
												__snake_case     			=       scope
												__snake_case     			=       len(snake_case_    )
												__snake_case     			=       out_features
												__snake_case     			=       out_indices
												__snake_case     			=       num_groups





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												__snake_case     			=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

												__snake_case     			=       None
												if self.use_labels:
																			__snake_case     			=       ids_tensor([self.batch_size]							,						self.num_labels    )

												__snake_case     			=       self.get_config()

												return config, pixel_values, labels





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												return BitConfig(
												    num_channels=self.num_channels							,						embeddings_size=self.embeddings_size							,						hidden_sizes=self.hidden_sizes							,						depths=self.depths							,						hidden_act=self.hidden_act							,						num_labels=self.num_labels							,						out_features=self.out_features							,						out_indices=self.out_indices							,						num_groups=self.num_groups							,						)





					def 							lowerCAmelCase      (				self   :							Union[str, Any]							,						snake_case_   :							List[str]							,						snake_case_   :							List[Any]							,						snake_case_   :							List[Any]    ):
												__snake_case     			=       BitModel(config=snake_case_    )
												model.to(snake_case_    )
												model.eval()
												__snake_case     			=       model(snake_case_    )
												self.parent.assertEqual(
												    result.last_hidden_state.shape							,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)							,						)





					def 							lowerCAmelCase      (				self   :							Tuple							,						snake_case_   :							Dict							,						snake_case_   :							str							,						snake_case_   :							Any    ):
												__snake_case     			=       self.num_labels
												__snake_case     			=       BitForImageClassification(snake_case_    )
												model.to(snake_case_    )
												model.eval()
												__snake_case     			=       model(snake_case_							,						labels=snake_case_    )
												self.parent.assertEqual(result.logits.shape							,						(self.batch_size, self.num_labels)    )





					def 							lowerCAmelCase      (				self   :							Optional[Any]							,						snake_case_   :							int							,						snake_case_   :							Dict							,						snake_case_   :							Union[str, Any]    ):
												__snake_case     			=       BitBackbone(config=snake_case_    )
												model.to(snake_case_    )
												model.eval()
												__snake_case     			=       model(snake_case_    )

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps    )							,						len(config.out_features    )    )
												self.parent.assertListEqual(list(result.feature_maps[0].shape    )							,						[self.batch_size, self.hidden_sizes[1], 4, 4]    )

												# verify channels
												self.parent.assertEqual(len(model.channels    )							,						len(config.out_features    )    )
												self.parent.assertListEqual(model.channels							,						config.hidden_sizes[1:]    )

												# verify backbone works with out_features=None
												__snake_case     			=       None
												__snake_case     			=       BitBackbone(config=snake_case_    )
												model.to(snake_case_    )
												model.eval()
												__snake_case     			=       model(snake_case_    )

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps    )							,						1    )
												self.parent.assertListEqual(list(result.feature_maps[0].shape    )							,						[self.batch_size, self.hidden_sizes[-1], 1, 1]    )

												# verify channels
												self.parent.assertEqual(len(model.channels    )							,						1    )
												self.parent.assertListEqual(model.channels							,						[config.hidden_sizes[-1]]    )





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												__snake_case     			=       self.prepare_config_and_inputs()
												__snake_case			,   __snake_case			,   __snake_case     			=       config_and_inputs
												__snake_case     			=       {"pixel_values": pixel_values}
												return config, inputs_dict







@require_torch
class 							__magic_name__     (		lowercase__      ,		lowercase__      ,		unittest.TestCase   ):
					_SCREAMING_SNAKE_CASE       :					Dict     							=   (BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
					_SCREAMING_SNAKE_CASE       :					List[str]     							=   (
					    {'feature-extraction': BitModel, 'image-classification': BitForImageClassification}
					    if is_torch_available()
					    else {}
					)

					_SCREAMING_SNAKE_CASE       :					Optional[Any]     							=   False
					_SCREAMING_SNAKE_CASE       :					Tuple     							=   False
					_SCREAMING_SNAKE_CASE       :					List[str]     							=   False
					_SCREAMING_SNAKE_CASE       :					Optional[Any]     							=   False
					_SCREAMING_SNAKE_CASE       :					int     							=   False





					def 							lowerCAmelCase      (				self   :							List[str]    ):
												__snake_case     			=       BitModelTester(self    )
												__snake_case     			=       ConfigTester(self							,						config_class=snake_case_							,						has_text_modality=snake_case_    )





					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()





					def 							lowerCAmelCase      (				self   :							Any    ):
												return





					@unittest.skip(reason="Bit does not output attentions"    )
					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												pass





					@unittest.skip(reason="Bit does not use inputs_embeds"    )
					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												pass





					@unittest.skip(reason="Bit does not support input and output embeddings"    )
					def 							lowerCAmelCase      (				self   :							int    ):
												pass





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case			,   __snake_case     			=       self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			__snake_case     			=       model_class(snake_case_    )
																			__snake_case     			=       inspect.signature(model.forward    )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			__snake_case     			=       [*signature.parameters.keys()]

																			__snake_case     			=       ["pixel_values"]
																			self.assertListEqual(arg_names[:1]							,						snake_case_    )





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*snake_case_    )





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case     			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*snake_case_    )





					def 							lowerCAmelCase      (				self   :							Any    ):
												__snake_case			,   __snake_case     			=       self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			__snake_case     			=       model_class(config=snake_case_    )
																			for name, module in model.named_modules():
																										if isinstance(snake_case_							,						(nn.BatchNormad, nn.GroupNorm)    ):
																																	self.assertTrue(
																																	    torch.all(module.weight == 1    )							,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''							,						)
																																	self.assertTrue(
																																	    torch.all(module.bias == 0    )							,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''							,						)





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												def check_hidden_states_output(snake_case_   :							Optional[Any]							,						snake_case_   :							Optional[Any]							,						snake_case_   :							Optional[int]    ):
																			__snake_case     			=       model_class(snake_case_    )
																			model.to(snake_case_    )
																			model.eval()

																			with torch.no_grad():
																										__snake_case     			=       model(**self._prepare_for_class(snake_case_							,						snake_case_    )    )

																			__snake_case     			=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																			__snake_case     			=       self.model_tester.num_stages
																			self.assertEqual(len(snake_case_    )							,						expected_num_stages + 1    )

																			# Bit's feature maps are of shape (batch_size, num_channels, height, width)
																			self.assertListEqual(
																			    list(hidden_states[0].shape[-2:]    )							,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,						)

												__snake_case			,   __snake_case     			=       self.model_tester.prepare_config_and_inputs_for_common()
												__snake_case     			=       ["preactivation", "bottleneck"]
												for model_class in self.all_model_classes:
																			for layer_type in layers_type:
																										__snake_case     			=       layer_type
																										__snake_case     			=       True
																										check_hidden_states_output(snake_case_							,						snake_case_							,						snake_case_    )

																										# check that output_hidden_states also work using config
																										del inputs_dict["output_hidden_states"]
																										__snake_case     			=       True

																										check_hidden_states_output(snake_case_							,						snake_case_							,						snake_case_    )





					@unittest.skip(reason="Bit does not use feedforward chunking"    )
					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												pass





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												__snake_case     			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*snake_case_    )





					@slow
					def 							lowerCAmelCase      (				self   :							int    ):
												for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			__snake_case     			=       BitModel.from_pretrained(snake_case_    )
																			self.assertIsNotNone(snake_case_    )




def   __UpperCamelCase   (					)  ->     Optional[int]:







							"""simple docstring"""


							__snake_case     			=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
							return image







@require_torch
@require_vision
class 							__magic_name__     (		unittest.TestCase   ):





					@cached_property
					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												return (
												    BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ) if is_vision_available() else None
												)





					@slow
					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(snake_case_    )

												__snake_case     			=       self.default_image_processor
												__snake_case     			=       prepare_img()
												__snake_case     			=       image_processor(images=snake_case_							,						return_tensors="pt"    ).to(snake_case_    )

												# forward pass
												with torch.no_grad():
																			__snake_case     			=       model(**snake_case_    )

												# verify the logits
												__snake_case     			=       torch.Size((1, 1000)    )
												self.assertEqual(outputs.logits.shape							,						snake_case_    )

												__snake_case     			=       torch.tensor([[-0.6526, -0.5263, -1.4398]]    ).to(snake_case_    )

												self.assertTrue(torch.allclose(outputs.logits[0, :3]							,						snake_case_							,						atol=1e-4    )    )







@require_torch
class 							__magic_name__     (		lowercase__      ,		unittest.TestCase   ):
					_SCREAMING_SNAKE_CASE       :					Any     							=   (BitBackbone,) if is_torch_available() else ()
					_SCREAMING_SNAKE_CASE       :					List[Any]     							=   BitConfig

					_SCREAMING_SNAKE_CASE       :					Optional[int]     							=   False





					def 							lowerCAmelCase      (				self   :							Any    ):
												__snake_case     			=       BitModelTester(self    )


"""simple docstring"""







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   __UpperCamelCase   (					SCREAMING_SNAKE_CASE )  ->     List[str]:







							"""simple docstring"""


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

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

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

							return config
def   __UpperCamelCase   (					SCREAMING_SNAKE_CASE )  ->     Optional[Any]:







							"""simple docstring"""


							__snake_case     			=       []

							# 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   __UpperCamelCase   (					SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE )  ->     str:







							"""simple docstring"""


							__snake_case     			=       dct.pop(SCREAMING_SNAKE_CASE )
							__snake_case     			=       val
def   __UpperCamelCase   (					SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE )  ->     Optional[int]:







							"""simple docstring"""


							__snake_case     			=       {
							    "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",
							}
							__snake_case     			=       model_name_to_url[model_name]
							__snake_case     			=       torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE							,    map_location="cpu" )["state_dict"]

							__snake_case     			=       get_upernet_config(SCREAMING_SNAKE_CASE )
							__snake_case     			=       UperNetForSemanticSegmentation(SCREAMING_SNAKE_CASE )
							model.eval()

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

							# rename keys
							__snake_case     			=       create_rename_keys(SCREAMING_SNAKE_CASE )
							for src, dest in rename_keys:
														rename_key(SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE							,    SCREAMING_SNAKE_CASE )

							model.load_state_dict(SCREAMING_SNAKE_CASE )

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

							__snake_case     			=       SegformerImageProcessor()
							__snake_case     			=       processor(SCREAMING_SNAKE_CASE							,    return_tensors="pt" ).pixel_values

							with torch.no_grad():
														__snake_case     			=       model(SCREAMING_SNAKE_CASE )

							if model_name == "upernet-convnext-tiny":
														__snake_case     			=       torch.tensor(
														    [[-8.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]] )
							elif model_name == "upernet-convnext-small":
														__snake_case     			=       torch.tensor(
														    [[-8.8_236, -8.8_236, -8.6_771], [-8.8_236, -8.8_236, -8.6_771], [-8.7_638, -8.7_638, -8.6_240]] )
							elif model_name == "upernet-convnext-base":
														__snake_case     			=       torch.tensor(
														    [[-8.8_558, -8.8_558, -8.6_905], [-8.8_558, -8.8_558, -8.6_905], [-8.7_669, -8.7_669, -8.6_021]] )
							elif model_name == "upernet-convnext-large":
														__snake_case     			=       torch.tensor(
														    [[-8.6_660, -8.6_660, -8.6_210], [-8.6_660, -8.6_660, -8.6_210], [-8.6_310, -8.6_310, -8.5_964]] )
							elif model_name == "upernet-convnext-xlarge":
														__snake_case     			=       torch.tensor(
														    [[-8.4_980, -8.4_980, -8.3_977], [-8.4_980, -8.4_980, -8.3_977], [-8.4_379, -8.4_379, -8.3_412]] )
							print("Logits:"							,    outputs.logits[0, 0, :3, :3] )
							assert torch.allclose(outputs.logits[0, 0, :3, :3]							,    SCREAMING_SNAKE_CASE							,    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(SCREAMING_SNAKE_CASE )
														print(F'''Saving processor to {pytorch_dump_folder_path}''' )
														processor.save_pretrained(SCREAMING_SNAKE_CASE )

							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__":
		_SCREAMING_SNAKE_CASE	       =      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."""
		)

		_SCREAMING_SNAKE_CASE	       =      parser.parse_args()
		convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
