



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



       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.02     ,UpperCAmelCase_=["stage2", "stage3", "stage4"]     ,UpperCAmelCase_=3     ,UpperCAmelCase_=None     ,)  ->							Optional[int]:

           '''simple docstring'''





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



       def 							_a      (				self      )  ->							str:

           '''simple docstring'''





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

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

           lowercase__		       =						self.get_config()

           return config, pixel_values, labels



       def 							_a      (				self      )  ->							str:

           '''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 							_a      (				self      )  ->							Union[str, Any]:

           '''simple docstring'''





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



       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							List[str]:

           '''simple docstring'''





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







       def 							_a      (				self      )  ->							int:

           '''simple docstring'''





           lowercase__		       =						self.prepare_config_and_inputs()
           (
               lowercase__    
           )		       =						config_and_inputs
           lowercase__		       =						{'pixel_values': pixel_values}
           return config, inputs_dict





@require_torch
class 				snake_case (UpperCamelCase		,      UpperCamelCase		,      unittest.TestCase   ):
       lowerCAmelCase__  :Dict						   =					(UperNetForSemanticSegmentation,) if is_torch_available() else ()
       lowerCAmelCase__  :Any						   =					{"image-segmentation": UperNetForSemanticSegmentation} if is_torch_available() else {}
       lowerCAmelCase__  :Optional[int]						   =					False
       lowerCAmelCase__  :Tuple						   =					False
       lowerCAmelCase__  :List[Any]						   =					False
       lowerCAmelCase__  :Union[str, Any]						   =					False
       lowerCAmelCase__  :Tuple						   =					False
       lowerCAmelCase__  :List[Any]						   =					False



       def 							_a      (				self      )  ->							Any:

           '''simple docstring'''





           lowercase__		       =						UperNetModelTester(self      )
           lowercase__		       =						ConfigTester(self     ,config_class=UpperCamelCase_     ,has_text_modality=UpperCamelCase_     ,hidden_size=37      )



       def 							_a      (				self      )  ->							Optional[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 							_a      (				self      )  ->							Any:

           '''simple docstring'''





           return



       def 							_a      (				self      )  ->							Any:

           '''simple docstring'''





           lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()

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

               lowercase__		       =						['pixel_values']
               self.assertListEqual(arg_names[:1]     ,UpperCamelCase_      )



       def 							_a      (				self      )  ->							Dict:

           '''simple docstring'''





           lowercase__		       =						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 							_a      (				self      )  ->							int:

           '''simple docstring'''





           pass



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

           '''simple docstring'''





           pass



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

           '''simple docstring'''





           pass



       @unittest.skip(reason="UperNet does not have a base model"      )
       def 							_a      (				self      )  ->							Dict:

           '''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 							_a      (				self      )  ->							Union[str, Any]:

           '''simple docstring'''





           pass



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

           '''simple docstring'''





           pass



       def 							_a      (				self      )  ->							Optional[Any]:

           '''simple docstring'''





           def check_hidden_states_output(UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_      ):
               lowercase__		       =						model_class(UpperCamelCase_      )
               model.to(UpperCamelCase_      )
               model.eval()

               with torch.no_grad():
                   lowercase__		       =						model(**self._prepare_for_class(UpperCamelCase_     ,UpperCamelCase_      )      )

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

               lowercase__		       =						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]     ,)

           lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               lowercase__		       =						True
               check_hidden_states_output(UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_      )

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

               check_hidden_states_output(UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_      )



       def 							_a      (				self      )  ->							List[Any]:

           '''simple docstring'''





           lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()

           lowercase__		       =						_config_zero_init(UpperCamelCase_      )
           lowercase__		       =						_config_zero_init(configs_no_init.backbone_config      )
           for model_class in self.all_model_classes:
               lowercase__		       =						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 							_a      (				self      )  ->							List[Any]:

           '''simple docstring'''





           pass







       @slow
       def 							_a      (				self      )  ->							List[str]:

           '''simple docstring'''





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





def        lowerCamelCase  (				):





    '''simple docstring'''


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



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



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

           '''simple docstring'''





           lowercase__		       =						AutoImageProcessor.from_pretrained("openmmlab/upernet-swin-tiny"      )
           lowercase__		       =						UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-swin-tiny"      ).to(UpperCamelCase_      )

           lowercase__		       =						prepare_img()
           lowercase__		       =						processor(images=UpperCamelCase_     ,return_tensors="pt"      ).to(UpperCamelCase_      )

           with torch.no_grad():
               lowercase__		       =						model(**UpperCamelCase_      )

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

           lowercase__		       =						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 							_a      (				self      )  ->							int:

           '''simple docstring'''





           lowercase__		       =						AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny"      )
           lowercase__		       =						UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny"      ).to(UpperCamelCase_      )

           lowercase__		       =						prepare_img()
           lowercase__		       =						processor(images=UpperCamelCase_     ,return_tensors="pt"      ).to(UpperCamelCase_      )

           with torch.no_grad():
               lowercase__		       =						model(**UpperCamelCase_      )

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

           lowercase__		       =						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      )      )









'''simple docstring'''





def        lowerCamelCase  (				_snake_case  :						list[int]     ,_snake_case  :						list[int]       ):





    '''simple docstring'''


    lowercase__		       =						len(_snake_case       )
    print("The following activities are selected:"       )

    # The first activity is always selected
    lowercase__		       =						0
    print(_snake_case     ,end=","       )

    # Consider rest of the activities
    for j in range(_snake_case       ):
        # If this activity has start time greater than
        # or equal to the finish time of previously
        # selected activity, then select it
        if start[j] >= finish[i]:
            print(_snake_case     ,end=","       )
            lowercase__		       =						j


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 SCREAMING_SNAKE_CASE__      					=     [1, 3, 0, 5, 8, 5]
 SCREAMING_SNAKE_CASE__      					=     [2, 4, 6, 7, 9, 9]
 print_max_activities(start, finish)




