






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

  '''simple docstring'''







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


         """simple docstring"""
         _UpperCAmelCase							=    parent
         _UpperCAmelCase							=    batch_size
         _UpperCAmelCase							=    image_size
         _UpperCAmelCase							=    num_channels
         _UpperCAmelCase							=    num_stages
         _UpperCAmelCase							=    hidden_sizes
         _UpperCAmelCase							=    depths
         _UpperCAmelCase							=    is_training
         _UpperCAmelCase							=    use_labels
         _UpperCAmelCase							=    intermediate_size
         _UpperCAmelCase							=    hidden_act
         _UpperCAmelCase							=    type_sequence_label_size
         _UpperCAmelCase							=    initializer_range
         _UpperCAmelCase							=    out_features
         _UpperCAmelCase							=    num_labels
         _UpperCAmelCase							=    scope
         _UpperCAmelCase							=    num_stages


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

         _UpperCAmelCase							=    self.get_config()

         return config, pixel_values, labels


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	List[Any]:


         """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  lowerCamelCase       (      self		:			Optional[int]							)						->	List[str]:


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


  def  lowerCamelCase       (      self		:			Any       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Dict							)						->	Tuple:


         """simple docstring"""
         _UpperCAmelCase							=    UperNetForSemanticSegmentation(config=lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase							)
         self.parent.assertEqual(
             result.logits.shape       ,				(self.batch_size, self.num_labels, self.image_size, self.image_size)							)





  def  lowerCamelCase       (      self		:			List[Any]							)						->	int:


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



@require_torch
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase					,      UpperCAmelCase					,      unittest.TestCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  (UperNetForSemanticSegmentation,) if is_torch_available() else ()
  _lowerCamelCase    =  {'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False


  def  lowerCamelCase       (      self		:			Tuple							)						->	Tuple:


         """simple docstring"""
         _UpperCAmelCase							=    UperNetModelTester(self							)
         _UpperCAmelCase							=    ConfigTester(self       ,				config_class=lowerCamelCase       ,				has_text_modality=lowerCamelCase       ,				hidden_size=37							)


  def  lowerCamelCase       (      self		:			Any							)						->	int:


         """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  lowerCamelCase       (      self		:			Tuple							)						->	Any:


         """simple docstring"""
         return


  def  lowerCamelCase       (      self		:			Any							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

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

                _UpperCAmelCase							=    ["""pixel_values"""]
                self.assertListEqual(arg_names[:1]       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			int							)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase							)


  @unittest.skip(reason="""UperNet does not use inputs_embeds"""							)
  def  lowerCamelCase       (      self		:			List[Any]							)						->	Optional[int]:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not support input and output embeddings"""							)
  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	Union[str, Any]:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not have a base model"""							)
  def  lowerCamelCase       (      self		:			Optional[int]							)						->	Tuple:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not have a base model"""							)
  def  lowerCamelCase       (      self		:			Dict							)						->	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  lowerCamelCase       (      self		:			str							)						->	Tuple:


         """simple docstring"""
         pass


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


         """simple docstring"""
         pass


  def  lowerCamelCase       (      self		:			List[Any]							)						->	List[str]:


         """simple docstring"""
         def check_hidden_states_output(lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			str							):
                _UpperCAmelCase							=    model_class(lowerCamelCase							)
                model.to(lowerCamelCase							)
                model.eval()

                with torch.no_grad():
                       _UpperCAmelCase							=    model(**self._prepare_for_class(lowerCamelCase       ,				lowerCamelCase							)							)

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

                _UpperCAmelCase							=    self.model_tester.num_stages
                self.assertEqual(len(lowerCamelCase							)       ,				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]       ,				)

         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

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

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

                check_hidden_states_output(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Any							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

         _UpperCAmelCase							=    _config_zero_init(lowerCamelCase							)
         _UpperCAmelCase							=    _config_zero_init(configs_no_init.backbone_config							)
         for model_class in self.all_model_classes:
                _UpperCAmelCase							=    model_class(config=lowerCamelCase							)
                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  lowerCamelCase       (      self		:			Union[str, Any]							)						->	Tuple:


         """simple docstring"""
         pass





  @slow
  def  lowerCamelCase       (      self		:			str							)						->	Optional[int]:


         """simple docstring"""
         for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained(lowerCamelCase							)
                self.assertIsNotNone(lowerCamelCase							)




def       _SCREAMING_SNAKE_CASE (							)				->						Union[str, Any]:
       _UpperCAmelCase							=    hf_hub_download(
           repo_id="""hf-internal-testing/fixtures_ade20k"""   ,      repo_type="""dataset"""   ,      filename="""ADE_val_00000001.jpg""" )
       _UpperCAmelCase							=    Image.open(__snake_case ).convert("""RGB""" )
       return image





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

  '''simple docstring'''







  def  lowerCamelCase       (      self		:			str							)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny"""							)
         _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny"""							).to(lowerCamelCase							)

         _UpperCAmelCase							=    prepare_img()
         _UpperCAmelCase							=    processor(images=lowerCamelCase       ,				return_tensors="""pt"""							).to(lowerCamelCase							)

         with torch.no_grad():
                _UpperCAmelCase							=    model(**lowerCamelCase							)

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

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





  def  lowerCamelCase       (      self		:			List[Any]							)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny"""							)
         _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny"""							).to(lowerCamelCase							)

         _UpperCAmelCase							=    prepare_img()
         _UpperCAmelCase							=    processor(images=lowerCamelCase       ,				return_tensors="""pt"""							).to(lowerCamelCase							)

         with torch.no_grad():
                _UpperCAmelCase							=    model(**lowerCamelCase							)

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

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


from typing import List, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCAmelCase						:							Union[str, Any]    							=						logging.get_logger(__name__)

__lowerCAmelCase						:							Optional[int]    							=						{
    "huggingface/time-series-transformer-tourism-monthly": (
        "https://huggingface.co/huggingface/time-series-transformer-tourism-monthly/resolve/main/config.json"
    ),
    # See all TimeSeriesTransformer models at https://huggingface.co/models?filter=time_series_transformer
}






class     A ( UpperCAmelCase ):
							a_										=   '''time_series_transformer'''
							a_										=   {
							    '''hidden_size''': '''d_model''',
							    '''num_attention_heads''': '''encoder_attention_heads''',
							    '''num_hidden_layers''': '''encoder_layers''',
							}





							def __init__(   self					:				str  ,		__a					:				Optional[int] = None  ,		__a					:				Optional[int] = None  ,		__a					:				str = "student_t"  ,		__a					:				str = "nll"  ,		__a					:				int = 1  ,		__a					:				List[int] = [1, 2, 3, 4, 5, 6, 7]  ,		__a					:				Optional[Union[str, bool]] = "mean"  ,		__a					:				int = 0  ,		__a					:				int = 0  ,		__a					:				int = 0  ,		__a					:				int = 0  ,		__a					:				Optional[List[int]] = None  ,		__a					:				Optional[List[int]] = None  ,		__a					:				int = 3_2  ,		__a					:				int = 3_2  ,		__a					:				int = 2  ,		__a					:				int = 2  ,		__a					:				int = 2  ,		__a					:				int = 2  ,		__a					:				bool = True  ,		__a					:				str = "gelu"  ,		__a					:				int = 6_4  ,		__a					:				float = 0.1  ,		__a					:				float = 0.1  ,		__a					:				float = 0.1  ,		__a					:				float = 0.1  ,		__a					:				float = 0.1  ,		__a					:				int = 1_0_0  ,		__a					:				float = 0.0_2  ,		__a					:				Optional[int]=True  ,		**__a					:				str  ,		)				->						int:
								# time series specific configuration
								__UpperCAmelCase      					=      prediction_length
								__UpperCAmelCase      					=      context_length or prediction_length
								__UpperCAmelCase      					=      distribution_output
								__UpperCAmelCase      					=      loss
								__UpperCAmelCase      					=      input_size
								__UpperCAmelCase      					=      num_time_features
								__UpperCAmelCase      					=      lags_sequence
								__UpperCAmelCase      					=      scaling
								__UpperCAmelCase      					=      num_dynamic_real_features
								__UpperCAmelCase      					=      num_static_real_features
								__UpperCAmelCase      					=      num_static_categorical_features
								if cardinality and num_static_categorical_features > 0:
									if len(__a						) != num_static_categorical_features:
										raise ValueError(
										    '''The cardinality should be a list of the same length as `num_static_categorical_features`'''						)
									__UpperCAmelCase      					=      cardinality
								else:
									__UpperCAmelCase      					=      [0]
								if embedding_dimension and num_static_categorical_features > 0:
									if len(__a						) != num_static_categorical_features:
										raise ValueError(
										    '''The embedding dimension should be a list of the same length as `num_static_categorical_features`'''						)
									__UpperCAmelCase      					=      embedding_dimension
								else:
									__UpperCAmelCase      					=      [min(5_0  ,		(cat + 1) // 2						) for cat in self.cardinality]
								__UpperCAmelCase      					=      num_parallel_samples

								# Transformer architecture configuration
								__UpperCAmelCase      					=      input_size * len(__a						) + self._number_of_features
								__UpperCAmelCase      					=      d_model
								__UpperCAmelCase      					=      encoder_attention_heads
								__UpperCAmelCase      					=      decoder_attention_heads
								__UpperCAmelCase      					=      encoder_ffn_dim
								__UpperCAmelCase      					=      decoder_ffn_dim
								__UpperCAmelCase      					=      encoder_layers
								__UpperCAmelCase      					=      decoder_layers

								__UpperCAmelCase      					=      dropout
								__UpperCAmelCase      					=      attention_dropout
								__UpperCAmelCase      					=      activation_dropout
								__UpperCAmelCase      					=      encoder_layerdrop
								__UpperCAmelCase      					=      decoder_layerdrop

								__UpperCAmelCase      					=      activation_function
								__UpperCAmelCase      					=      init_std

								__UpperCAmelCase      					=      use_cache

								super().__init__(is_encoder_decoder=__a  ,		**__a						)






							@property
							def    snake_case__    (   self					:				List[Any]						)				->						int:
								return (
								    sum(self.embedding_dimension						)
								    + self.num_dynamic_real_features
								    + self.num_time_features
								    + self.num_static_real_features
								    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
								)
