
'''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     UpperCAmelCase_	:






						'''simple docstring'''






						def __init__(   self       ,  _lowercase       ,  _lowercase=13       ,  _lowercase=32       ,  _lowercase=3       ,  _lowercase=4       ,  _lowercase=[10, 20, 30, 40]       ,  _lowercase=[2, 2, 3, 2]       ,  _lowercase=True       ,  _lowercase=True       ,  _lowercase=37       ,  _lowercase="gelu"       ,  _lowercase=10       ,  _lowercase=0.02       ,  _lowercase=["stage2", "stage3", "stage4"]       ,  _lowercase=3       ,  _lowercase=None       ,  ):

												"""simple docstring"""



												_lowerCAmelCase    		=					parent
												_lowerCAmelCase    		=					batch_size
												_lowerCAmelCase    		=					image_size
												_lowerCAmelCase    		=					num_channels
												_lowerCAmelCase    		=					num_stages
												_lowerCAmelCase    		=					hidden_sizes
												_lowerCAmelCase    		=					depths
												_lowerCAmelCase    		=					is_training
												_lowerCAmelCase    		=					use_labels
												_lowerCAmelCase    		=					intermediate_size
												_lowerCAmelCase    		=					hidden_act
												_lowerCAmelCase    		=					type_sequence_label_size
												_lowerCAmelCase    		=					initializer_range
												_lowerCAmelCase    		=					out_features
												_lowerCAmelCase    		=					num_labels
												_lowerCAmelCase    		=					scope
												_lowerCAmelCase    		=					num_stages




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

												_lowerCAmelCase    		=					None
												if self.use_labels:
																		_lowerCAmelCase    		=					ids_tensor([self.batch_size]       ,  self.type_sequence_label_size )

												_lowerCAmelCase    		=					self.get_config()

												return config, pixel_values, labels




						def    _lowercase      (   self ):

												"""simple docstring"""



												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    _lowercase      (   self ):

												"""simple docstring"""



												return UperNetConfig(
												    backbone_config=self.get_backbone_config()       ,  hidden_size=512       ,  pool_scales=[1, 2, 3, 6]       ,  use_auxiliary_head=_lowercase       ,  auxiliary_loss_weight=0.4       ,  auxiliary_in_channels=40       ,  auxiliary_channels=256       ,  auxiliary_num_convs=1       ,  auxiliary_concat_input=_lowercase       ,  loss_ignore_index=255       ,  num_labels=self.num_labels       ,  )




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase ):

												"""simple docstring"""



												_lowerCAmelCase    		=					UperNetForSemanticSegmentation(config=_lowercase )
												model.to(_lowercase )
												model.eval()
												_lowerCAmelCase    		=					model(_lowercase )
												self.parent.assertEqual(
												    result.logits.shape       ,  (self.batch_size, self.num_labels, self.image_size, self.image_size) )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.prepare_config_and_inputs()
												(
												    (
												    _lowerCAmelCase
												)		,       (
												    _lowerCAmelCase
												)		,       (
												    _lowerCAmelCase
												)		,       
												)    		=					config_and_inputs
												_lowerCAmelCase    		=					{"""pixel_values""": pixel_values}
												return config, inputs_dict






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






						'''simple docstring'''






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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					UperNetModelTester(self )
												_lowerCAmelCase    		=					ConfigTester(self       ,  config_class=_lowercase       ,  has_text_modality=_lowercase       ,  hidden_size=37 )




						def    _lowercase      (   self ):

												"""simple docstring"""



												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    _lowercase      (   self ):

												"""simple docstring"""



												return




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase		,       _lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

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

																		_lowerCAmelCase    		=					["""pixel_values"""]
																		self.assertListEqual(arg_names[:1]       ,  _lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_semantic_segmentation(*_lowercase )




						@unittest.skip(reason="""UperNet does not use inputs_embeds""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip(reason="""UperNet does not support input and output embeddings""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip(reason="""UperNet does not have a base model""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip(reason="""UperNet does not have a base model""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@require_torch_multi_gpu
						@unittest.skip(reason="""UperNet has some layers using `add_module` which doesn't work well with `nn.DataParallel`""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						def    _lowercase      (   self ):

												"""simple docstring"""



												def check_hidden_states_output(_lowercase       ,  _lowercase       ,  _lowercase ):
																		_lowerCAmelCase    		=					model_class(_lowercase )
																		model.to(_lowercase )
																		model.eval()

																		with torch.no_grad():
																								_lowerCAmelCase    		=					model(**self._prepare_for_class(_lowercase       ,  _lowercase ) )

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

																		_lowerCAmelCase    		=					self.model_tester.num_stages
																		self.assertEqual(len(_lowercase )       ,  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    		=					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		_lowerCAmelCase    		=					True
																		check_hidden_states_output(_lowercase       ,  _lowercase       ,  _lowercase )

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

																		check_hidden_states_output(_lowercase       ,  _lowercase       ,  _lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase		,       _lowerCAmelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

												_lowerCAmelCase    		=					_config_zero_init(_lowercase )
												_lowerCAmelCase    		=					_config_zero_init(configs_no_init.backbone_config )
												for model_class in self.all_model_classes:
																		_lowerCAmelCase    		=					model_class(config=_lowercase )
																		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    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@slow
						def    _lowercase      (   self ):

												"""simple docstring"""



												for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		_lowerCAmelCase    		=					UperNetForSemanticSegmentation.from_pretrained(_lowercase )
																		self.assertIsNotNone(_lowercase )






def A ():
						_lowerCAmelCase    		=					hf_hub_download(
						    repo_id="""hf-internal-testing/fixtures_ade20k"""					,      repo_type="""dataset"""					,      filename="""ADE_val_00000001.jpg"""						)
						_lowerCAmelCase    		=					Image.open(__lowerCamelCase						).convert("""RGB"""						)
						return image





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






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny""" )
												_lowerCAmelCase    		=					UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny""" ).to(_lowercase )

												_lowerCAmelCase    		=					prepare_img()
												_lowerCAmelCase    		=					processor(images=_lowercase       ,  return_tensors="""pt""" ).to(_lowercase )

												with torch.no_grad():
																		_lowerCAmelCase    		=					model(**_lowercase )

												_lowerCAmelCase    		=					torch.Size((1, model.config.num_labels, 512, 512) )
												self.assertEqual(outputs.logits.shape       ,  _lowercase )

												_lowerCAmelCase    		=					torch.tensor(
												    [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]] ).to(_lowercase )
												self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]       ,  _lowercase       ,  atol=1e-4 ) )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny""" )
												_lowerCAmelCase    		=					UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny""" ).to(_lowercase )

												_lowerCAmelCase    		=					prepare_img()
												_lowerCAmelCase    		=					processor(images=_lowercase       ,  return_tensors="""pt""" ).to(_lowercase )

												with torch.no_grad():
																		_lowerCAmelCase    		=					model(**_lowercase )

												_lowerCAmelCase    		=					torch.Size((1, model.config.num_labels, 512, 512) )
												self.assertEqual(outputs.logits.shape       ,  _lowercase )

												_lowerCAmelCase    		=					torch.tensor(
												    [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]] ).to(_lowercase )
												self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]       ,  _lowercase       ,  atol=1e-4 ) )


'''simple docstring'''



import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


_lowercase          =						False
try:
						_lowercase          =						_is_package_available("""google.colab""")
except ModuleNotFoundError:
						pass




@input.register
class     UpperCAmelCase_	:






						'''simple docstring'''






						def __init__(   self       ,  _lowercase = None       ,  _lowercase = [] ):

												"""simple docstring"""



												_lowerCAmelCase    		=					0
												_lowerCAmelCase    		=					choices
												_lowerCAmelCase    		=					prompt
												if sys.platform == "win32":
																		_lowerCAmelCase    		=					"""*"""
												else:
																		_lowerCAmelCase    		=					"""➔ """




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase = "" ):

												"""simple docstring"""



												if sys.platform != "win32":
																		writeColor(self.choices[index]       ,  32       ,  _lowercase )
												else:
																		forceWrite(self.choices[index]       ,  _lowercase )




						def    _lowercase      (   self       ,  _lowercase ):

												"""simple docstring"""



												if index == self.position:
																		forceWrite(F' {self.arrow_char} ' )
																		self.write_choice(_lowercase )
												else:
																		forceWrite(F'    {self.choices[index]}' )
												reset_cursor()




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase = 1 ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.position
												if direction == Direction.DOWN:
																		if self.position + 1 >= len(self.choices ):
																								return
																		self.position += num_spaces
												else:
																		if self.position - 1 < 0:
																								return
																		self.position -= num_spaces
												clear_line()
												self.print_choice(_lowercase )
												move_cursor(_lowercase       ,  direction.name )
												self.print_choice(self.position )




						@input.mark(KEYMAP["""up"""] )
						def    _lowercase      (   self ):

												"""simple docstring"""



												self.move_direction(Direction.UP )




						@input.mark(KEYMAP["""down"""] )
						def    _lowercase      (   self ):

												"""simple docstring"""



												self.move_direction(Direction.DOWN )




						@input.mark(KEYMAP["""newline"""] )
						def    _lowercase      (   self ):

												"""simple docstring"""



												move_cursor(len(self.choices ) - self.position       ,  """DOWN""" )
												return self.position




						@input.mark(KEYMAP["""interrupt"""] )
						def    _lowercase      (   self ):

												"""simple docstring"""



												move_cursor(len(self.choices ) - self.position       ,  """DOWN""" )
												raise KeyboardInterrupt




						@input.mark_multiple(*[KEYMAP[str(_lowercase )] for number in range(10 )] )
						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					int(chr(self.current_selection ) )
												_lowerCAmelCase    		=					index - self.position
												if index == self.position:
																		return
												if index < len(self.choices ):
																		if self.position > index:
																								self.move_direction(Direction.UP       ,  -movement )
																		elif self.position < index:
																								self.move_direction(Direction.DOWN       ,  _lowercase )
																		else:
																								return
												else:
																		return




						def    _lowercase      (   self       ,  _lowercase = 0 ):

												"""simple docstring"""



												if self.prompt:
																		linebreak()
																		forceWrite(self.prompt       ,  """\n""" )
																		if in_colab:
																								forceWrite("""Please input a choice index (starting from 0), and press enter"""       ,  """\n""" )
																		else:
																								forceWrite("""Please select a choice using the arrow or number keys, and selecting with enter"""       ,  """\n""" )
												_lowerCAmelCase    		=					default_choice
												for i in range(len(self.choices ) ):
																		self.print_choice(_lowercase )
																		forceWrite("""\n""" )
												move_cursor(len(self.choices ) - self.position       ,  """UP""" )
												with cursor.hide():
																		while True:
																								if in_colab:
																														try:
																																				_lowerCAmelCase    		=					int(builtins.input() )
																														except ValueError:
																																				_lowerCAmelCase    		=					default_choice
																								else:
																														_lowerCAmelCase    		=					self.handle_input()
																								if choice is not None:
																														reset_cursor()
																														for _ in range(len(self.choices ) + 1 ):
																																				move_cursor(1       ,  """UP""" )
																																				clear_line()
																														self.write_choice(_lowercase       ,  """\n""" )
																														return choice
