





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        _lowerCAmelCase    :


  '''simple docstring'''







  def __init__(      self      :					Optional[int]      ,				UpperCamelCase      :					Dict      ,				UpperCamelCase      :					Any=13      ,				UpperCamelCase      :					List[Any]=32      ,				UpperCamelCase      :					int=3      ,				UpperCamelCase      :					List[str]=4      ,				UpperCamelCase      :					Optional[Any]=[10, 20, 30, 40]      ,				UpperCamelCase      :					Union[str, Any]=[2, 2, 3, 2]      ,				UpperCamelCase      :					Tuple=True      ,				UpperCamelCase      :					int=True      ,				UpperCamelCase      :					Tuple=37      ,				UpperCamelCase      :					Union[str, Any]="gelu"      ,				UpperCamelCase      :					str=10      ,				UpperCamelCase      :					Tuple=0.02      ,				UpperCamelCase      :					Tuple=["stage2", "stage3", "stage4"]      ,				UpperCamelCase      :					Dict=3      ,				UpperCamelCase      :					Optional[Any]=None      ,				):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	parent
    _snake_case   :				Optional[int]														=	batch_size
    _snake_case   :				Optional[int]														=	image_size
    _snake_case   :				Dict														=	num_channels
    _snake_case   :				str														=	num_stages
    _snake_case   :				str														=	hidden_sizes
    _snake_case   :				Optional[Any]														=	depths
    _snake_case   :				List[Any]														=	is_training
    _snake_case   :				Tuple														=	use_labels
    _snake_case   :				Dict														=	intermediate_size
    _snake_case   :				List[Any]														=	hidden_act
    _snake_case   :				List[Any]														=	type_sequence_label_size
    _snake_case   :				Any														=	initializer_range
    _snake_case   :				List[Any]														=	out_features
    _snake_case   :				Optional[Any]														=	num_labels
    _snake_case   :				int														=	scope
    _snake_case   :				Union[str, Any]														=	num_stages







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

    _snake_case   :				str														=	None
    if self.use_labels:
      _snake_case   :				Dict														=	ids_tensor([self.batch_size]      ,				self.type_sequence_label_size							)

    _snake_case   :				Union[str, Any]														=	self.get_config()

    return config, pixel_values, labels







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''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 UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    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 UpperCamelCase_ (      self      :					Union[str, Any]      ,				UpperCamelCase      :					Optional[Any]      ,				UpperCamelCase      :					List[str]      ,				UpperCamelCase      :					Union[str, Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	UperNetForSemanticSegmentation(config=UpperCamelCase							)
    model.to(UpperCamelCase							)
    model.eval()
    _snake_case   :				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							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	self.prepare_config_and_inputs()
    (
        (
        _snake_case
    )							,					(
        _snake_case
    )							,					(
        _snake_case
    )							,					
    )   :				Tuple														=	config_and_inputs
    _snake_case   :				List[str]														=	{'pixel_values': pixel_values}
    return config, inputs_dict




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


  '''simple docstring'''
  a_							:       Union[str, Any]      					=(UperNetForSemanticSegmentation,) if is_torch_available() else ()
  a_							:       Union[str, Any]      					={"""image-segmentation""": UperNetForSemanticSegmentation} if is_torch_available() else {}
  a_							:       int      					=False
  a_							:       List[str]      					=False
  a_							:       List[Any]      					=False
  a_							:       Any      					=False
  a_							:       Optional[int]      					=False
  a_							:       Dict      					=False







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	UperNetModelTester(self							)
    _snake_case   :				Optional[Any]														=	ConfigTester(self      ,				config_class=UpperCamelCase      ,				has_text_modality=UpperCamelCase      ,				hidden_size=37							)







  def UpperCamelCase_ (      self      :					str							):


    '''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 UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    return







  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





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

    for model_class in self.all_model_classes:
      _snake_case   :				Dict														=	model_class(UpperCamelCase							)
      _snake_case   :				Optional[Any]														=	inspect.signature(model.forward							)
      # signature.parameters is an OrderedDict => so arg_names order is deterministic
      _snake_case   :				Tuple														=	[*signature.parameters.keys()]

      _snake_case   :				str														=	['pixel_values']
      self.assertListEqual(arg_names[:1]      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				Dict														=	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      :					Tuple							):


    '''simple docstring'''





    pass







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


    '''simple docstring'''





    pass







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


    '''simple docstring'''





    pass







  @unittest.skip(reason='UperNet does not have a base model'							)
  def UpperCamelCase_ (      self      :					Tuple							):


    '''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 UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    pass







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


    '''simple docstring'''





    pass







  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    def check_hidden_states_output(UpperCamelCase      :					Union[str, Any]      ,				UpperCamelCase      :					List[str]      ,				UpperCamelCase      :					int							):
      _snake_case   :				List[Any]														=	model_class(UpperCamelCase							)
      model.to(UpperCamelCase							)
      model.eval()

      with torch.no_grad():
        _snake_case   :				List[Any]														=	model(**self._prepare_for_class(UpperCamelCase      ,				UpperCamelCase							)							)

      _snake_case   :				Any														=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

      _snake_case   :				Any														=	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]      ,				)

    _snake_case							,					_snake_case   :				Tuple														=	self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      _snake_case   :				List[Any]														=	True
      check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)

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

      check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





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

    _snake_case   :				List[Any]														=	_config_zero_init(UpperCamelCase							)
    _snake_case   :				int														=	_config_zero_init(configs_no_init.backbone_config							)
    for model_class in self.all_model_classes:
      _snake_case   :				List[str]														=	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]							):


    '''simple docstring'''





    pass







  @slow
  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      _snake_case   :				int														=	UperNetForSemanticSegmentation.from_pretrained(UpperCamelCase							)
      self.assertIsNotNone(UpperCamelCase							)




def     lowerCamelCase_	(      )->		Optional[Any]:
  _snake_case   :				List[str]														=	hf_hub_download(
      repo_id='hf-internal-testing/fixtures_ade20k'    ,							repo_type='dataset'    ,							filename='ADE_val_00000001.jpg'				)
  _snake_case   :				int														=	Image.open(lowerCAmelCase				).convert('RGB'				)
  return image







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


  '''simple docstring'''







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'							)
    _snake_case   :				Tuple														=	UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'							).to(UpperCamelCase							)

    _snake_case   :				int														=	prepare_img()
    _snake_case   :				List[Any]														=	processor(images=UpperCamelCase      ,				return_tensors='pt'							).to(UpperCamelCase							)

    with torch.no_grad():
      _snake_case   :				Dict														=	model(**UpperCamelCase							)

    _snake_case   :				Union[str, Any]														=	torch.Size((1, model.config.num_labels, 5_12, 5_12)							)
    self.assertEqual(outputs.logits.shape      ,				UpperCamelCase							)

    _snake_case   :				Optional[Any]														=	torch.tensor(
        [[-7.59_58, -7.59_58, -7.43_02], [-7.59_58, -7.59_58, -7.43_02], [-7.47_97, -7.47_97, -7.30_68]]							).to(UpperCamelCase							)
    self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      ,				UpperCamelCase      ,				atol=1e-4							)							)







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'							)
    _snake_case   :				Union[str, Any]														=	UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'							).to(UpperCamelCase							)

    _snake_case   :				Optional[Any]														=	prepare_img()
    _snake_case   :				Tuple														=	processor(images=UpperCamelCase      ,				return_tensors='pt'							).to(UpperCamelCase							)

    with torch.no_grad():
      _snake_case   :				Dict														=	model(**UpperCamelCase							)

    _snake_case   :				int														=	torch.Size((1, model.config.num_labels, 5_12, 5_12)							)
    self.assertEqual(outputs.logits.shape      ,				UpperCamelCase							)

    _snake_case   :				List[str]														=	torch.tensor(
        [[-8.81_10, -8.81_10, -8.65_21], [-8.81_10, -8.81_10, -8.65_21], [-8.77_46, -8.77_46, -8.61_30]]							).to(UpperCamelCase							)
    self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      ,				UpperCamelCase      ,				atol=1e-4							)							)











from random import randint, random


def     lowerCamelCase_	(      lowerCAmelCase:	int    ,							lowerCAmelCase:	int    ,							lowerCAmelCase:	int    ,							lowerCAmelCase:	bool = False    ,							lowerCAmelCase:	bool = False    ,							lowerCAmelCase:	int = 5    ,							)->		list:
  _snake_case   :				Dict														=	[[-1] * number_of_cells]  # Create a highway without any car
  _snake_case   :				List[str]														=	0
  _snake_case   :				List[str]														=	max(lowerCAmelCase    ,							0				)
  while i < number_of_cells:
    _snake_case   :				Optional[Any]														=	(
        randint(0    ,							lowerCAmelCase				) if random_speed else initial_speed
    )  # Place the cars
    i += (
        randint(1    ,							max_speed * 2				) if random_frequency else frequency
    )  # Arbitrary number, may need tuning
  return highway


def     lowerCamelCase_	(      lowerCAmelCase:	list    ,							lowerCAmelCase:	int				)->		int:
  _snake_case   :				Dict														=	0
  _snake_case   :				Optional[Any]														=	highway_now[car_index + 1 :]
  for cell in range(len(lowerCAmelCase				)				):  # May need a better name for this
    if cells[cell] != -1:  # If the cell is not empty then
      return distance  # we have the distance we wanted
    distance += 1
  # Here if the car is near the end of the highway
  return distance + get_distance(lowerCAmelCase    ,							-1				)


def     lowerCamelCase_	(      lowerCAmelCase:	list    ,							lowerCAmelCase:	float    ,							lowerCAmelCase:	int				)->		list:
  _snake_case   :				List[Any]														=	len(lowerCAmelCase				)
  # Beforce calculations, the highway is empty
  _snake_case   :				List[Any]														=	[-1] * number_of_cells

  for car_index in range(lowerCAmelCase				):
    if highway_now[car_index] != -1:
      # Add 1 to the current speed of the car and cap the speed
      _snake_case   :				int														=	min(highway_now[car_index] + 1    ,							lowerCAmelCase				)
      # Number of empty cell before the next car
      _snake_case   :				Tuple														=	get_distance(lowerCAmelCase    ,							lowerCAmelCase				) - 1
      # We can't have the car causing an accident
      _snake_case   :				Union[str, Any]														=	min(next_highway[car_index]    ,							lowerCAmelCase				)
      if random() < probability:
        # Randomly, a driver will slow down
        _snake_case   :				int														=	max(next_highway[car_index] - 1    ,							0				)
  return next_highway


def     lowerCamelCase_	(      lowerCAmelCase:	list    ,							lowerCAmelCase:	int    ,							lowerCAmelCase:	float    ,							lowerCAmelCase:	int				)->		list:
  _snake_case   :				Dict														=	len(highway[0]				)

  for i in range(lowerCAmelCase				):
    _snake_case   :				Any														=	update(highway[i]    ,							lowerCAmelCase    ,							lowerCAmelCase				)
    _snake_case   :				Tuple														=	[-1] * number_of_cells

    for car_index in range(lowerCAmelCase				):
      _snake_case   :				Union[str, Any]														=	next_speeds_calculated[car_index]
      if speed != -1:
        # Change the position based on the speed (with % to create the loop)
        _snake_case   :				Union[str, Any]														=	(car_index + speed) % number_of_cells
        # Commit the change of position
        _snake_case   :				Tuple														=	speed
    highway.append(lowerCAmelCase				)

  return highway


if __name__ == "__main__":
      import doctest

      doctest.testmod()




