




"""simple docstring"""




def      __UpperCAmelCase     ( __UpperCamelCase	):
			if not isinstance(__UpperCamelCase	,				__UpperCamelCase	) or number < 0:
						raise ValueError('''Input must be a non-negative integer'''	)

			__lowercase			:  Optional[int]								=       0
			while number:
						# This way we arrive at next set bit (next 1) instead of looping
						# through each bit and checking for 1s hence the
						# loop won't run 32 times it will only run the number of `1` times
						number &= number - 1
						count += 1
			return count


if __name__ == "__main__":
			import doctest

			doctest.testmod()






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  :





							"""simple docstring"""

							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.0_2    ,						__UpperCAmelCase=["stage2", "stage3", "stage4"]    ,						__UpperCAmelCase=3    ,						__UpperCAmelCase=None    ,						)		->       Optional[Any]:
														A      :					Tuple      		=					parent
														A      :					Any      		=					batch_size
														A      :					List[Any]      		=					image_size
														A      :					Tuple      		=					num_channels
														A      :					Any      		=					num_stages
														A      :					Any      		=					hidden_sizes
														A      :					List[str]      		=					depths
														A      :					str      		=					is_training
														A      :					Any      		=					use_labels
														A      :					Any      		=					intermediate_size
														A      :					List[str]      		=					hidden_act
														A      :					List[Any]      		=					type_sequence_label_size
														A      :					Optional[int]      		=					initializer_range
														A      :					Tuple      		=					out_features
														A      :					Tuple      		=					num_labels
														A      :					Tuple      		=					scope
														A      :					int      		=					num_stages




							def       snake_case			(					self						)		->       Optional[Any]:
														A      :					Any      		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

														A      :					Any      		=					self.get_config()

														return config, pixel_values, labels




							def       snake_case			(					self						)		->       Optional[int]:
														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       snake_case			(					self						)		->       Tuple:
														return UperNetConfig(
														    backbone_config=self.get_backbone_config()    ,						hidden_size=5_12    ,						pool_scales=[1, 2, 3, 6]    ,						use_auxiliary_head=__UpperCAmelCase    ,						auxiliary_loss_weight=0.4    ,						auxiliary_in_channels=40    ,						auxiliary_channels=2_56    ,						auxiliary_num_convs=1    ,						auxiliary_concat_input=__UpperCAmelCase    ,						loss_ignore_index=2_55    ,						num_labels=self.num_labels    ,						)




							def       snake_case			(					self    ,						__UpperCAmelCase    ,						__UpperCAmelCase    ,						__UpperCAmelCase						)		->       List[Any]:
														A      :					List[Any]      		=					UperNetForSemanticSegmentation(config=__UpperCAmelCase						)
														model.to(__UpperCAmelCase						)
														model.eval()
														A      :					int      		=					model(__UpperCAmelCase						)
														self.parent.assertEqual(
														    result.logits.shape    ,						(self.batch_size, self.num_labels, self.image_size, self.image_size)						)






							def       snake_case			(					self						)		->       Tuple:
														A      :					List[str]      		=					self.prepare_config_and_inputs()
														(
														    (
														    A
														)		,		(
														    A
														)		,		(
														    A
														)		,		
														)      :					Tuple      		=					config_and_inputs
														A      :					Dict      		=					{'''pixel_values''': pixel_values}
														return config, inputs_dict







@require_torch
class 					__lowercase  (						_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE		,       unittest.TestCase				):





							"""simple docstring"""

							UpperCAmelCase_						:		str								=	(UperNetForSemanticSegmentation,) if is_torch_available() else ()
							UpperCAmelCase_						:		Union[str, Any]								=	{'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
							UpperCAmelCase_						:		int								=	False
							UpperCAmelCase_						:		List[Any]								=	False
							UpperCAmelCase_						:		Tuple								=	False
							UpperCAmelCase_						:		List[Any]								=	False
							UpperCAmelCase_						:		int								=	False
							UpperCAmelCase_						:		Dict								=	False




							def       snake_case			(					self						)		->       Union[str, Any]:
														A      :					int      		=					UperNetModelTester(self						)
														A      :					Any      		=					ConfigTester(self    ,						config_class=__UpperCAmelCase    ,						has_text_modality=__UpperCAmelCase    ,						hidden_size=37						)




							def       snake_case			(					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       snake_case			(					self						)		->       Optional[int]:
														return




							def       snake_case			(					self						)		->       Any:
														A		,		A      :					Any      		=					self.model_tester.prepare_config_and_inputs_for_common()

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

																					A      :					Any      		=					['''pixel_values''']
																					self.assertListEqual(arg_names[:1]    ,						__UpperCAmelCase						)




							def       snake_case			(					self						)		->       List[str]:
														A      :					Optional[int]      		=					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       snake_case			(					self						)		->       Optional[Any]:
														pass




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




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




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




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




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




							def       snake_case			(					self						)		->       Union[str, Any]:
														def check_hidden_states_output(__UpperCAmelCase    ,						__UpperCAmelCase    ,						__UpperCAmelCase						):
																					A      :					Any      		=					model_class(__UpperCAmelCase						)
																					model.to(__UpperCAmelCase						)
																					model.eval()

																					with torch.no_grad():
																												A      :					List[str]      		=					model(**self._prepare_for_class(__UpperCAmelCase    ,						__UpperCAmelCase						)						)

																					A      :					List[Any]      		=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																					A      :					List[str]      		=					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]    ,						)

														A		,		A      :					Optional[Any]      		=					self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					A      :					List[str]      		=					True
																					check_hidden_states_output(__UpperCAmelCase    ,						__UpperCAmelCase    ,						__UpperCAmelCase						)

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

																					check_hidden_states_output(__UpperCAmelCase    ,						__UpperCAmelCase    ,						__UpperCAmelCase						)




							def       snake_case			(					self						)		->       Tuple:
														A		,		A      :					Dict      		=					self.model_tester.prepare_config_and_inputs_for_common()

														A      :					Dict      		=					_config_zero_init(__UpperCAmelCase						)
														A      :					List[str]      		=					_config_zero_init(configs_no_init.backbone_config						)
														for model_class in self.all_model_classes:
																					A      :					Any      		=					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       snake_case			(					self						)		->       Tuple:
														pass






							@slow
							def       snake_case			(					self						)		->       str:
														for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					A      :					Tuple      		=					UperNetForSemanticSegmentation.from_pretrained(__UpperCAmelCase						)
																					self.assertIsNotNone(__UpperCAmelCase						)






def        snake_case__		(    ):
							A      :					Tuple      		=					hf_hub_download(
							    repo_id='''hf-internal-testing/fixtures_ade20k'''     ,				repo_type='''dataset'''     ,				filename='''ADE_val_00000001.jpg'''		)
							A      :					Optional[Any]      		=					Image.open(lowerCamelCase_		).convert('''RGB'''		)
							return image







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





							"""simple docstring"""

							def       snake_case			(					self						)		->       Dict:
														A      :					List[Any]      		=					AutoImageProcessor.from_pretrained('''openmmlab/upernet-swin-tiny'''						)
														A      :					List[str]      		=					UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-swin-tiny'''						).to(__UpperCAmelCase						)

														A      :					List[str]      		=					prepare_img()
														A      :					str      		=					processor(images=__UpperCAmelCase    ,						return_tensors='''pt'''						).to(__UpperCAmelCase						)

														with torch.no_grad():
																					A      :					str      		=					model(**__UpperCAmelCase						)

														A      :					Optional[int]      		=					torch.Size((1, model.config.num_labels, 5_12, 5_12)						)
														self.assertEqual(outputs.logits.shape    ,						__UpperCAmelCase						)

														A      :					List[Any]      		=					torch.tensor(
														    [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]						).to(__UpperCAmelCase						)
														self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]    ,						__UpperCAmelCase    ,						atol=1E-4						)						)






							def       snake_case			(					self						)		->       int:
														A      :					List[str]      		=					AutoImageProcessor.from_pretrained('''openmmlab/upernet-convnext-tiny'''						)
														A      :					Any      		=					UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-convnext-tiny'''						).to(__UpperCAmelCase						)

														A      :					str      		=					prepare_img()
														A      :					List[Any]      		=					processor(images=__UpperCAmelCase    ,						return_tensors='''pt'''						).to(__UpperCAmelCase						)

														with torch.no_grad():
																					A      :					List[Any]      		=					model(**__UpperCAmelCase						)

														A      :					List[str]      		=					torch.Size((1, model.config.num_labels, 5_12, 5_12)						)
														self.assertEqual(outputs.logits.shape    ,						__UpperCAmelCase						)

														A      :					Tuple      		=					torch.tensor(
														    [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]]						).to(__UpperCAmelCase						)
														self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]    ,						__UpperCAmelCase    ,						atol=1E-4						)						)






