
"""simple docstring"""

import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

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


if is_torch_available():
					import torch

					from transformers import UperNetForSemanticSegmentation
					from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor






class 	_lowercase       :




	def __init__(			self		,			UpperCAmelCase_		,			UpperCAmelCase_=13		,			UpperCAmelCase_=32		,			UpperCAmelCase_=3		,			UpperCAmelCase_=4		,			UpperCAmelCase_=[10, 20, 30, 40]		,			UpperCAmelCase_=[2, 2, 3, 2]		,			UpperCAmelCase_=True		,			UpperCAmelCase_=True		,			UpperCAmelCase_=37		,			UpperCAmelCase_="gelu"		,			UpperCAmelCase_=10		,			UpperCAmelCase_=0.02		,			UpperCAmelCase_=["stage2", "stage3", "stage4"]		,			UpperCAmelCase_=3		,			UpperCAmelCase_=None		,			)		->							Optional[int]:
			lowerCamelCase					:      int          =   parent
			lowerCamelCase					:      Optional[Any]          =   batch_size
			lowerCamelCase					:      Tuple          =   image_size
			lowerCamelCase					:      Optional[int]          =   num_channels
			lowerCamelCase					:      Union[str, Any]          =   num_stages
			lowerCamelCase					:      Union[str, Any]          =   hidden_sizes
			lowerCamelCase					:      List[str]          =   depths
			lowerCamelCase					:      Tuple          =   is_training
			lowerCamelCase					:      int          =   use_labels
			lowerCamelCase					:      Dict          =   intermediate_size
			lowerCamelCase					:      Dict          =   hidden_act
			lowerCamelCase					:      Dict          =   type_sequence_label_size
			lowerCamelCase					:      List[str]          =   initializer_range
			lowerCamelCase					:      Optional[Any]          =   out_features
			lowerCamelCase					:      Any          =   num_labels
			lowerCamelCase					:      str          =   scope
			lowerCamelCase					:      Tuple          =   num_stages




	def       _UpperCamelCase   (			self )		->							Dict:
			lowerCamelCase					:      List[str]          =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

			lowerCamelCase					:      Union[str, Any]          =   None
			if self.use_labels:
					lowerCamelCase					:      Optional[int]          =   ids_tensor([self.batch_size]		,			self.type_sequence_label_size )

			lowerCamelCase					:      str          =   self.get_config()

			return config, pixel_values, labels




	def       _UpperCamelCase   (			self )		->							Dict:
			return ConvNextConfig(
			    num_channels=self.num_channels		,			num_stages=self.num_stages		,			hidden_sizes=self.hidden_sizes		,			depths=self.depths		,			is_training=self.is_training		,			intermediate_size=self.intermediate_size		,			hidden_act=self.hidden_act		,			out_features=self.out_features		,			)




	def       _UpperCamelCase   (			self )		->							Tuple:
			return UperNetConfig(
			    backbone_config=self.get_backbone_config()		,			hidden_size=512		,			pool_scales=[1, 2, 3, 6]		,			use_auxiliary_head=UpperCAmelCase_		,			auxiliary_loss_weight=0.4		,			auxiliary_in_channels=40		,			auxiliary_channels=256		,			auxiliary_num_convs=1		,			auxiliary_concat_input=UpperCAmelCase_		,			loss_ignore_index=255		,			num_labels=self.num_labels		,			)




	def       _UpperCamelCase   (			self		,			UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_ )		->							List[Any]:
			lowerCamelCase					:      Union[str, Any]          =   UperNetForSemanticSegmentation(config=UpperCAmelCase_ )
			model.to(UpperCAmelCase_ )
			model.eval()
			lowerCamelCase					:      List[Any]          =   model(UpperCAmelCase_ )
			self.parent.assertEqual(
			    result.logits.shape		,			(self.batch_size, self.num_labels, self.image_size, self.image_size) )




	def       _UpperCamelCase   (			self )		->							int:
			lowerCamelCase					:      Optional[int]          =   self.prepare_config_and_inputs()
			(
			    (
			    lowerCamelCase
			)     ,   (
			    lowerCamelCase
			)     ,   (
			    lowerCamelCase
			)     ,   
			)					:      Optional[int]          =   config_and_inputs
			lowerCamelCase					:      int          =   {'pixel_values': pixel_values}
			return config, inputs_dict






@require_torch
class 	_lowercase       (    __UpperCAmelCase    ,	__UpperCAmelCase    ,	unittest.TestCase		):
	lowercase_				=     (UperNetForSemanticSegmentation,) if is_torch_available() else ()
	lowercase_				=     {'image-segmentation': UperNetForSemanticSegmentation} if is_torch_available() else {}
	lowercase_				=     False
	lowercase_				=     False
	lowercase_				=     False
	lowercase_				=     False
	lowercase_				=     False
	lowercase_				=     False




	def       _UpperCamelCase   (			self )		->							int:
			lowerCamelCase					:      str          =   UperNetModelTester(self )
			lowerCamelCase					:      List[Any]          =   ConfigTester(self		,			config_class=UpperCAmelCase_		,			has_text_modality=UpperCAmelCase_		,			hidden_size=37 )




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			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       _UpperCamelCase   (			self )		->							Tuple:
			return




	def       _UpperCamelCase   (			self )		->							str:
			lowerCamelCase     ,   lowerCamelCase					:      Optional[Any]          =   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					lowerCamelCase					:      Union[str, Any]          =   model_class(UpperCAmelCase_ )
					lowerCamelCase					:      List[str]          =   inspect.signature(model.forward )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					lowerCamelCase					:      Optional[int]          =   [*signature.parameters.keys()]

					lowerCamelCase					:      List[Any]          =   ['pixel_values']
					self.assertListEqual(arg_names[:1]		,			UpperCAmelCase_ )




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			lowerCamelCase					:      Union[str, Any]          =   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_semantic_segmentation(*UpperCAmelCase_ )




	@unittest.skip(reason='UperNet does not use inputs_embeds' )
	def       _UpperCamelCase   (			self )		->							Any:
			pass




	@unittest.skip(reason='UperNet does not support input and output embeddings' )
	def       _UpperCamelCase   (			self )		->							int:
			pass




	@unittest.skip(reason='UperNet does not have a base model' )
	def       _UpperCamelCase   (			self )		->							str:
			pass




	@unittest.skip(reason='UperNet does not have a base model' )
	def       _UpperCamelCase   (			self )		->							int:
			pass




	@require_torch_multi_gpu
	@unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' )
	def       _UpperCamelCase   (			self )		->							int:
			pass




	@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' )
	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			pass




	def       _UpperCamelCase   (			self )		->							str:
			def check_hidden_states_output(UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_ ):
					lowerCamelCase					:      Optional[int]          =   model_class(UpperCAmelCase_ )
					model.to(UpperCAmelCase_ )
					model.eval()

					with torch.no_grad():
							lowerCamelCase					:      Union[str, Any]          =   model(**self._prepare_for_class(UpperCAmelCase_		,			UpperCAmelCase_ ) )

					lowerCamelCase					:      List[str]          =   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

					lowerCamelCase					:      Dict          =   self.model_tester.num_stages
					self.assertEqual(len(UpperCAmelCase_ )		,			expected_num_stages + 1 )

					# ConvNext'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]		,			)

			lowerCamelCase     ,   lowerCamelCase					:      Any          =   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					lowerCamelCase					:      Any          =   True
					check_hidden_states_output(UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_ )

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					lowerCamelCase					:      Dict          =   True

					check_hidden_states_output(UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_ )




	def       _UpperCamelCase   (			self )		->							Any:
			lowerCamelCase     ,   lowerCamelCase					:      Tuple          =   self.model_tester.prepare_config_and_inputs_for_common()

			lowerCamelCase					:      Dict          =   _config_zero_init(UpperCAmelCase_ )
			lowerCamelCase					:      List[str]          =   _config_zero_init(configs_no_init.backbone_config )
			for model_class in self.all_model_classes:
					lowerCamelCase					:      Tuple          =   model_class(config=UpperCAmelCase_ )
					for name, param in model.named_parameters():
							if param.requires_grad:
									self.assertIn(
									    ((param.data.mean() * 1E9).round() / 1E9).item()		,			[0.0, 1.0]		,			msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		,			)




	@unittest.skip(reason='UperNet does not have tied weights' )
	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			pass




	@slow
	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCamelCase					:      int          =   UperNetForSemanticSegmentation.from_pretrained(UpperCAmelCase_ )
					self.assertIsNotNone(UpperCAmelCase_ )


def 		UpperCAmelCase (		):





		'''simple docstring'''


		lowerCamelCase					:      int          =   hf_hub_download(
		    repo_id='hf-internal-testing/fixtures_ade20k',						repo_type='dataset',						filename='ADE_val_00000001.jpg'      )
		lowerCamelCase					:      Tuple          =   Image.open(a_      ).convert('RGB'      )
		return image






@require_torch
@require_vision
@slow
class 	_lowercase       (    unittest.TestCase		):




	def       _UpperCamelCase   (			self )		->							str:
			lowerCamelCase					:      List[str]          =   AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny' )
			lowerCamelCase					:      Union[str, Any]          =   UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny' ).to(UpperCAmelCase_ )

			lowerCamelCase					:      str          =   prepare_img()
			lowerCamelCase					:      Any          =   processor(images=UpperCAmelCase_		,			return_tensors='pt' ).to(UpperCAmelCase_ )

			with torch.no_grad():
					lowerCamelCase					:      Any          =   model(**UpperCAmelCase_ )

			lowerCamelCase					:      Tuple          =   torch.Size((1, model.config.num_labels, 512, 512) )
			self.assertEqual(outputs.logits.shape		,			UpperCAmelCase_ )

			lowerCamelCase					:      str          =   torch.tensor(
			    [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]] ).to(UpperCAmelCase_ )
			self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]		,			UpperCAmelCase_		,			atol=1E-4 ) )




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			lowerCamelCase					:      Union[str, Any]          =   AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny' )
			lowerCamelCase					:      Union[str, Any]          =   UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny' ).to(UpperCAmelCase_ )

			lowerCamelCase					:      Any          =   prepare_img()
			lowerCamelCase					:      Any          =   processor(images=UpperCAmelCase_		,			return_tensors='pt' ).to(UpperCAmelCase_ )

			with torch.no_grad():
					lowerCamelCase					:      int          =   model(**UpperCAmelCase_ )

			lowerCamelCase					:      Optional[Any]          =   torch.Size((1, model.config.num_labels, 512, 512) )
			self.assertEqual(outputs.logits.shape		,			UpperCAmelCase_ )

			lowerCamelCase					:      Optional[int]          =   torch.tensor(
			    [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]] ).to(UpperCAmelCase_ )
			self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]		,			UpperCAmelCase_		,			atol=1E-4 ) )








"""simple docstring"""

import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
					import ctypes
					import msvcrt  # noqa






					class 	_lowercase       (    ctypes.Structure		):
						# _fields is a specific attr expected by ctypes
						lowercase_				=     [('size', ctypes.c_int), ('visible', ctypes.c_byte)]
def 		UpperCAmelCase (		):





		'''simple docstring'''


		if os.name == "nt":
				lowerCamelCase					:      Optional[int]          =   CursorInfo()
				lowerCamelCase					:      Union[str, Any]          =   ctypes.windll.kernelaa.GetStdHandle(-11      )
				ctypes.windll.kernelaa.GetConsoleCursorInfo(a_,						ctypes.byref(a_      )      )
				lowerCamelCase					:      Dict          =   False
				ctypes.windll.kernelaa.SetConsoleCursorInfo(a_,						ctypes.byref(a_      )      )
		elif os.name == "posix":
				sys.stdout.write('\033[?25l'      )
				sys.stdout.flush()
def 		UpperCAmelCase (		):





		'''simple docstring'''


		if os.name == "nt":
				lowerCamelCase					:      List[str]          =   CursorInfo()
				lowerCamelCase					:      List[Any]          =   ctypes.windll.kernelaa.GetStdHandle(-11      )
				ctypes.windll.kernelaa.GetConsoleCursorInfo(a_,						ctypes.byref(a_      )      )
				lowerCamelCase					:      Optional[Any]          =   True
				ctypes.windll.kernelaa.SetConsoleCursorInfo(a_,						ctypes.byref(a_      )      )
		elif os.name == "posix":
				sys.stdout.write('\033[?25h'      )
				sys.stdout.flush()





@contextmanager
def 		UpperCAmelCase (		):





		'''simple docstring'''


		try:
				hide_cursor()
				yield
		finally:
				show_cursor()






