


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__						:
      def __init__( self       : Optional[Any]  ,							SCREAMING_SNAKE_CASE__       : Any  ,							SCREAMING_SNAKE_CASE__       : str=1_3  ,							SCREAMING_SNAKE_CASE__       : Tuple=3_2  ,							SCREAMING_SNAKE_CASE__       : Dict=3  ,							SCREAMING_SNAKE_CASE__       : str=4  ,							SCREAMING_SNAKE_CASE__       : Tuple=[1_0, 2_0, 3_0, 4_0]  ,							SCREAMING_SNAKE_CASE__       : Dict=[2, 2, 3, 2]  ,							SCREAMING_SNAKE_CASE__       : List[str]=True  ,							SCREAMING_SNAKE_CASE__       : List[str]=True  ,							SCREAMING_SNAKE_CASE__       : str=3_7  ,							SCREAMING_SNAKE_CASE__       : Union[str, Any]="gelu"  ,							SCREAMING_SNAKE_CASE__       : Optional[int]=1_0  ,							SCREAMING_SNAKE_CASE__       : Tuple=0.02  ,							SCREAMING_SNAKE_CASE__       : List[str]=["stage2", "stage3", "stage4"]  ,							SCREAMING_SNAKE_CASE__       : List[str]=3  ,							SCREAMING_SNAKE_CASE__       : str=None  ,							)	->    Optional[Any]:
             a_      :	List[str]							=						parent
             a_      :	Any							=						batch_size
             a_      :	Any							=						image_size
             a_      :	Dict							=						num_channels
             a_      :	Tuple							=						num_stages
             a_      :	Optional[int]							=						hidden_sizes
             a_      :	Dict							=						depths
             a_      :	Dict							=						is_training
             a_      :	Dict							=						use_labels
             a_      :	Union[str, Any]							=						intermediate_size
             a_      :	Any							=						hidden_act
             a_      :	Tuple							=						type_sequence_label_size
             a_      :	Union[str, Any]							=						initializer_range
             a_      :	int							=						out_features
             a_      :	str							=						num_labels
             a_      :	Optional[Any]							=						scope
             a_      :	List[Any]							=						num_stages
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Tuple:
             a_      :	Optional[int]							=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

             a_      :	Dict							=						None
             if self.use_labels:
                    a_      :	List[Any]							=						ids_tensor([self.batch_size]  ,							self.type_sequence_label_size  )

             a_      :	Any							=						self.get_config()

             return config, pixel_values, labels
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    List[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  SCREAMING_SNAKE_CASE							( self       : Any  )	->    int:
             return UperNetConfig(
                 backbone_config=self.get_backbone_config()  ,							hidden_size=5_1_2  ,							pool_scales=[1, 2, 3, 6]  ,							use_auxiliary_head=SCREAMING_SNAKE_CASE__  ,							auxiliary_loss_weight=0.4  ,							auxiliary_in_channels=4_0  ,							auxiliary_channels=2_5_6  ,							auxiliary_num_convs=1  ,							auxiliary_concat_input=SCREAMING_SNAKE_CASE__  ,							loss_ignore_index=2_5_5  ,							num_labels=self.num_labels  ,							)
      def  SCREAMING_SNAKE_CASE							( self       : Dict  ,							SCREAMING_SNAKE_CASE__       : str  ,							SCREAMING_SNAKE_CASE__       : Union[str, Any]  ,							SCREAMING_SNAKE_CASE__       : List[Any]  )	->    Tuple:
             a_      :	Dict							=						UperNetForSemanticSegmentation(config=SCREAMING_SNAKE_CASE__  )
             model.to(SCREAMING_SNAKE_CASE__  )
             model.eval()
             a_      :	str							=						model(SCREAMING_SNAKE_CASE__  )
             self.parent.assertEqual(
                 result.logits.shape  ,							(self.batch_size, self.num_labels, self.image_size, self.image_size)  )

      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    Any:
             a_      :	str							=						self.prepare_config_and_inputs()
             (
                 a_	
             )      :	List[Any]							=						config_and_inputs
             a_      :	Union[str, Any]							=						{'pixel_values': pixel_values}
             return config, inputs_dict
@require_torch
class 				SCREAMING_SNAKE_CASE__						(       lowercase__		,					lowercase__		,					unittest.TestCase    ):
      snake_case__       :  Any       =		(UperNetForSemanticSegmentation,) if is_torch_available() else ()
      snake_case__       :  Dict       =		{'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
      snake_case__       :  str       =		False
      snake_case__       :  List[Any]       =		False
      snake_case__       :  str       =		False
      snake_case__       :  str       =		False
      snake_case__       :  str       =		False
      snake_case__       :  Union[str, Any]       =		False
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    Union[str, Any]:
             a_      :	List[Any]							=						UperNetModelTester(self  )
             a_      :	Optional[Any]							=						ConfigTester(self  ,							config_class=SCREAMING_SNAKE_CASE__  ,							has_text_modality=SCREAMING_SNAKE_CASE__  ,							hidden_size=3_7  )
      def  SCREAMING_SNAKE_CASE							( self       : List[str]  )	->    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  SCREAMING_SNAKE_CASE							( self       : int  )	->    Union[str, Any]:
             return
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Optional[int]:
             a_      :	int							=						self.model_tester.prepare_config_and_inputs_for_common()

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

                    a_      :	Union[str, Any]							=						['pixel_values']
                    self.assertListEqual(arg_names[:1]  ,							SCREAMING_SNAKE_CASE__  )
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    int:
             a_      :	Tuple							=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_semantic_segmentation(*SCREAMING_SNAKE_CASE__  )
      @unittest.skip(reason='UperNet does not use inputs_embeds'  )
      def  SCREAMING_SNAKE_CASE							( self       : Optional[int]  )	->    int:
             pass
      @unittest.skip(reason='UperNet does not support input and output embeddings'  )
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    List[Any]:
             pass
      @unittest.skip(reason='UperNet does not have a base model'  )
      def  SCREAMING_SNAKE_CASE							( self       : Tuple  )	->    Dict:
             pass
      @unittest.skip(reason='UperNet does not have a base model'  )
      def  SCREAMING_SNAKE_CASE							( self       : Tuple  )	->    Optional[Any]:
             pass
      @require_torch_multi_gpu
      @unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'  )
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  )	->    List[str]:
             pass
      @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'  )
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    List[str]:
             pass
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    str:
             def check_hidden_states_output(SCREAMING_SNAKE_CASE__       : List[Any]  ,							SCREAMING_SNAKE_CASE__       : Tuple  ,							SCREAMING_SNAKE_CASE__       : str  ):
                    a_      :	int							=						model_class(SCREAMING_SNAKE_CASE__  )
                    model.to(SCREAMING_SNAKE_CASE__  )
                    model.eval()

                    with torch.no_grad():
                           a_      :	str							=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )  )

                    a_      :	int							=						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                    a_      :	str							=						self.model_tester.num_stages
                    self.assertEqual(len(SCREAMING_SNAKE_CASE__  )  ,							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]  ,							)

             a_      :	Optional[int]							=						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    a_      :	Optional[int]							=						True
                    check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )

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

                    check_hidden_states_output(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    str:
             a_      :	Tuple							=						self.model_tester.prepare_config_and_inputs_for_common()

             a_      :	Tuple							=						_config_zero_init(SCREAMING_SNAKE_CASE__  )
             a_      :	Optional[Any]							=						_config_zero_init(configs_no_init.backbone_config  )
             for model_class in self.all_model_classes:
                    a_      :	Optional[Any]							=						model_class(config=SCREAMING_SNAKE_CASE__  )
                    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  SCREAMING_SNAKE_CASE							( self       : Optional[int]  )	->    Optional[Any]:
             pass

      @slow
      def  SCREAMING_SNAKE_CASE							( self       : Union[str, Any]  )	->    Tuple:
             for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    a_      :	Optional[Any]							=						UperNetForSemanticSegmentation.from_pretrained(SCREAMING_SNAKE_CASE__  )
                    self.assertIsNotNone(SCREAMING_SNAKE_CASE__  )







def  SCREAMING_SNAKE_CASE_		(    )			->	List[Any]:

       """simple docstring"""

       a_      :	str							=						hf_hub_download(
           repo_id='hf-internal-testing/fixtures_ade20k'						,					repo_type='dataset'						,					filename='ADE_val_00000001.jpg'       )
       a_      :	Union[str, Any]							=						Image.open(__A       ).convert('RGB'       )
       return image
@require_torch
@require_vision
@slow
class 				SCREAMING_SNAKE_CASE__						(       unittest.TestCase    ):
      def  SCREAMING_SNAKE_CASE							( self       : Dict  )	->    Dict:
             a_      :	Tuple							=						AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'  )
             a_      :	Optional[Any]							=						UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	Dict							=						prepare_img()
             a_      :	Tuple							=						processor(images=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  ).to(SCREAMING_SNAKE_CASE__  )

             with torch.no_grad():
                    a_      :	Union[str, Any]							=						model(**SCREAMING_SNAKE_CASE__  )

             a_      :	Dict							=						torch.Size((1, model.config.num_labels, 5_1_2, 5_1_2)  )
             self.assertEqual(outputs.logits.shape  ,							SCREAMING_SNAKE_CASE__  )

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

      def  SCREAMING_SNAKE_CASE							( self       : Optional[int]  )	->    Dict:
             a_      :	Dict							=						AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'  )
             a_      :	Any							=						UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'  ).to(SCREAMING_SNAKE_CASE__  )

             a_      :	int							=						prepare_img()
             a_      :	Dict							=						processor(images=SCREAMING_SNAKE_CASE__  ,							return_tensors='pt'  ).to(SCREAMING_SNAKE_CASE__  )

             with torch.no_grad():
                    a_      :	Optional[Any]							=						model(**SCREAMING_SNAKE_CASE__  )

             a_      :	Union[str, Any]							=						torch.Size((1, model.config.num_labels, 5_1_2, 5_1_2)  )
             self.assertEqual(outputs.logits.shape  ,							SCREAMING_SNAKE_CASE__  )

             a_      :	Any							=						torch.tensor(
                 [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]]  ).to(SCREAMING_SNAKE_CASE__  )
             self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]  ,							SCREAMING_SNAKE_CASE__  ,							atol=1E-4  )  )






from sklearn.metrics import fa_score

import datasets


UpperCAmelCase_   :				List[Any]						      = '\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n'


UpperCAmelCase_   :				Optional[Any]						      = '\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n    Example 1-A simple binary example\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n        >>> print(results)\n        {\'f1\': 0.5}\n\n    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n        >>> print(round(results[\'f1\'], 2))\n        0.67\n\n    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n        >>> print(round(results[\'f1\'], 2))\n        0.35\n\n    Example 4-A multiclass example, with different values for the `average` input.\n        >>> predictions = [0, 2, 1, 0, 0, 1]\n        >>> references = [0, 1, 2, 0, 1, 2]\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")\n        >>> print(round(results[\'f1\'], 2))\n        0.33\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n        >>> print(results)\n        {\'f1\': array([0.8, 0. , 0. ])}\n'


UpperCAmelCase_   :				Optional[Any]						      = '\n@article{scikit-learn,\n    title={Scikit-learn: Machine Learning in {P}ython},\n    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n    journal={Journal of Machine Learning Research},\n    volume={12},\n    pages={2825--2830},\n    year={2011}\n}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,					_KWARGS_DESCRIPTION    )
class 				SCREAMING_SNAKE_CASE__						(       datasets.Metric    ):
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    int:
             return datasets.MetricInfo(
                 description=_DESCRIPTION  ,							citation=_CITATION  ,							inputs_description=_KWARGS_DESCRIPTION  ,							features=datasets.Features(
                     {
                         'predictions': datasets.Sequence(datasets.Value('int32'  )  ),
                         'references': datasets.Sequence(datasets.Value('int32'  )  ),
                     }
                     if self.config_name == 'multilabel'
                     else {
                         'predictions': datasets.Value('int32'  ),
                         'references': datasets.Value('int32'  ),
                     }  )  ,							reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html']  ,							)

      def  SCREAMING_SNAKE_CASE							( self       : Dict  ,							SCREAMING_SNAKE_CASE__       : Tuple  ,							SCREAMING_SNAKE_CASE__       : Any  ,							SCREAMING_SNAKE_CASE__       : List[Any]=None  ,							SCREAMING_SNAKE_CASE__       : List[str]=1  ,							SCREAMING_SNAKE_CASE__       : Union[str, Any]="binary"  ,							SCREAMING_SNAKE_CASE__       : Dict=None  )	->    Any:
             a_      :	List[Any]							=						fa_score(
                 SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  ,							labels=SCREAMING_SNAKE_CASE__  ,							pos_label=SCREAMING_SNAKE_CASE__  ,							average=SCREAMING_SNAKE_CASE__  ,							sample_weight=SCREAMING_SNAKE_CASE__  )
             return {"f1": float(SCREAMING_SNAKE_CASE__  ) if score.size == 1 else score}


