"""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 							a					:


    def __init__(       self						:	List[Any] ,					__lowerCAmelCase						:	Dict ,					__lowerCAmelCase						:	Optional[int]=13 ,					__lowerCAmelCase						:	int=32 ,					__lowerCAmelCase						:	Optional[int]=3 ,					__lowerCAmelCase						:	Tuple=4 ,					__lowerCAmelCase						:	Any=[10, 20, 30, 40] ,					__lowerCAmelCase						:	Tuple=[2, 2, 3, 2] ,					__lowerCAmelCase						:	str=True ,					__lowerCAmelCase						:	List[Any]=True ,					__lowerCAmelCase						:	Union[str, Any]=37 ,					__lowerCAmelCase						:	int="gelu" ,					__lowerCAmelCase						:	Any=10 ,					__lowerCAmelCase						:	Union[str, Any]=0.02 ,					__lowerCAmelCase						:	Dict=["stage2", "stage3", "stage4"] ,					__lowerCAmelCase						:	int=3 ,					__lowerCAmelCase						:	Any=None ,					):
      _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						:	Optional[int]       ):
      _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						:	Union[str, Any]       ):
      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						:	List[str]       ):
      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						:	Tuple ,					__lowerCAmelCase						:	str ,					__lowerCAmelCase						:	Union[str, Any] ,					__lowerCAmelCase						:	Tuple       ):
      _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						:	Union[str, Any]       ):
      _UpperCAmelCase    			=   self.prepare_config_and_inputs()
      (
          (
          _UpperCAmelCase
      )			,					(
          _UpperCAmelCase
      )			,					(
          _UpperCAmelCase
      )			,					
      )    			=   config_and_inputs
      _UpperCAmelCase    			=   {"""pixel_values""": pixel_values}
      return config, inputs_dict



@require_torch
class 							a					(		lowerCAmelCase_						,				lowerCAmelCase_						,				unittest.TestCase ):
    _snake_case  :	List[Any]  				=				(UperNetForSemanticSegmentation,) if is_torch_available() else ()
    _snake_case  :	Optional[int]  				=				{'image-segmentation': UperNetForSemanticSegmentation} if is_torch_available() else {}
    _snake_case  :	Optional[int]  				=				False
    _snake_case  :	int  				=				False
    _snake_case  :	Any  				=				False
    _snake_case  :	Dict  				=				False
    _snake_case  :	List[str]  				=				False
    _snake_case  :	Optional[int]  				=				False


    def   lowerCAmelCase_	(       self						:	Union[str, Any]       ):
      _UpperCAmelCase    			=   UperNetModelTester(self       )
      _UpperCAmelCase    			=   ConfigTester(self ,					config_class=__lowerCAmelCase ,					has_text_modality=__lowerCAmelCase ,					hidden_size=37       )


    def   lowerCAmelCase_	(       self						:	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   lowerCAmelCase_	(       self						:	int       ):
      return


    def   lowerCAmelCase_	(       self						:	Optional[Any]       ):
      _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						:	Dict       ):
      _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[str]       ):
      pass


    @unittest.skip(reason="""UperNet does not support input and output embeddings"""       )
    def   lowerCAmelCase_	(       self						:	Optional[int]       ):
      pass


    @unittest.skip(reason="""UperNet does not have a base model"""       )
    def   lowerCAmelCase_	(       self						:	Optional[int]       ):
      pass


    @unittest.skip(reason="""UperNet does not have a base model"""       )
    def   lowerCAmelCase_	(       self						:	Optional[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   lowerCAmelCase_	(       self						:	Union[str, Any]       ):
      pass


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


    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      def check_hidden_states_output(__lowerCAmelCase						:	Tuple ,					__lowerCAmelCase						:	Union[str, Any] ,					__lowerCAmelCase						:	Dict       ):
        _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						:	Optional[Any]       ):
      _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						:	int       ):
      pass


    @slow
    def   lowerCAmelCase_	(       self						:	List[str]       ):
      for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        _UpperCAmelCase    			=   UperNetForSemanticSegmentation.from_pretrained(__lowerCAmelCase       )
        self.assertIsNotNone(__lowerCAmelCase       )






def      __UpperCAmelCase       (      ):







  """simple docstring"""
  _UpperCAmelCase    			=   hf_hub_download(
      repo_id="""hf-internal-testing/fixtures_ade20k""" ,repo_type="""dataset""" ,filename="""ADE_val_00000001.jpg"""		)
  _UpperCAmelCase    			=   Image.open(lowercase		).convert("""RGB"""		)
  return image


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


    def   lowerCAmelCase_	(       self						:	Union[str, Any]       ):
      _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.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]]       ).to(__lowerCAmelCase       )
      self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] ,					__lowerCAmelCase ,					atol=1e-4       )       )


    def   lowerCAmelCase_	(       self						:	Optional[Any]       ):
      _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.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]]       ).to(__lowerCAmelCase       )
      self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] ,					__lowerCAmelCase ,					atol=1e-4       )       )

"""simple docstring"""


from transformers import BertTokenizerFast

from .custom_tokenization import CustomTokenizer


class 							a					(		lowerCAmelCase_ ):
    _snake_case  :	Dict  				=				CustomTokenizer
    pass
