"""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						,			__lowerCAmelCase						,			__lowerCAmelCase=13						,			__lowerCAmelCase=32						,			__lowerCAmelCase=3						,			__lowerCAmelCase=4						,			__lowerCAmelCase=[10, 20, 30, 40]						,			__lowerCAmelCase=[2, 2, 3, 2]						,			__lowerCAmelCase=True						,			__lowerCAmelCase=True						,			__lowerCAmelCase=37						,			__lowerCAmelCase="gelu"						,			__lowerCAmelCase=10						,			__lowerCAmelCase=0.0_2						,			__lowerCAmelCase=["stage2", "stage3", "stage4"]						,			__lowerCAmelCase=3						,			__lowerCAmelCase=None						,			):







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







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







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







            """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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



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







      def 							A__			(		self		):







            """simple docstring"""



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






@require_torch
class 					_A		(			lowerCAmelCase    ,       lowerCAmelCase    ,       unittest.TestCase      ):
      snake_case__     :  str				    =      (UperNetForSemanticSegmentation,) if is_torch_available() else ()
      snake_case__     :  Any				    =      {'image-segmentation': UperNetForSemanticSegmentation} if is_torch_available() else {}
      snake_case__     :  Union[str, Any]				    =      False
      snake_case__     :  Optional[Any]				    =      False
      snake_case__     :  Dict				    =      False
      snake_case__     :  Tuple				    =      False
      snake_case__     :  Union[str, Any]				    =      False
      snake_case__     :  Union[str, Any]				    =      False

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      UperNetModelTester(self		)
            lowercase								=      ConfigTester(self						,			config_class=__lowerCAmelCase						,			has_text_modality=__lowerCAmelCase						,			hidden_size=37		)

      def 							A__			(		self		):







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







            """simple docstring"""



            return

      def 							A__			(		self		):







            """simple docstring"""



            lowercase				,				lowercase								=      self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  lowercase								=      model_class(__lowerCAmelCase		)
                  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]						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            pass

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







            """simple docstring"""



            pass

      @unittest.skip(reason="""UperNet does not have a base model"""		)
      def 							A__			(		self		):







            """simple docstring"""



            pass

      @unittest.skip(reason="""UperNet does not have a base model"""		)
      def 							A__			(		self		):







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







            """simple docstring"""



            pass

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







            """simple docstring"""



            pass

      def 							A__			(		self		):







            """simple docstring"""



            def check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):
                  lowercase								=      model_class(__lowerCAmelCase		)
                  model.to(__lowerCAmelCase		)
                  model.eval()

                  with torch.no_grad():
                        lowercase								=      model(**self._prepare_for_class(__lowerCAmelCase						,			__lowerCAmelCase		)		)

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

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

            lowercase				,				lowercase								=      self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  lowercase								=      True
                  check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)

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

                  check_hidden_states_output(__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase				,				lowercase								=      self.model_tester.prepare_config_and_inputs_for_common()

            lowercase								=      _config_zero_init(__lowerCAmelCase		)
            lowercase								=      _config_zero_init(configs_no_init.backbone_config		)
            for model_class in self.all_model_classes:
                  lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            pass







      @slow
      def 							A__			(		self		):







            """simple docstring"""



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






def      UpperCAmelCase__			(							)					->       str:
      '''simple docstring'''


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






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

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny"""		)
            lowercase								=      UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny"""		).to(__lowerCAmelCase		)

            lowercase								=      prepare_img()
            lowercase								=      processor(images=__lowerCAmelCase						,			return_tensors="""pt"""		).to(__lowerCAmelCase		)

            with torch.no_grad():
                  lowercase								=      model(**__lowerCAmelCase		)

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

            lowercase								=      torch.tensor(
                [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]		).to(__lowerCAmelCase		)
            self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]						,			__lowerCAmelCase						,			atol=1E-4		)		)







      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny"""		)
            lowercase								=      UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny"""		).to(__lowerCAmelCase		)

            lowercase								=      prepare_img()
            lowercase								=      processor(images=__lowerCAmelCase						,			return_tensors="""pt"""		).to(__lowerCAmelCase		)

            with torch.no_grad():
                  lowercase								=      model(**__lowerCAmelCase		)

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

            lowercase								=      torch.tensor(
                [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]]		).to(__lowerCAmelCase		)
            self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]						,			__lowerCAmelCase						,			atol=1E-4		)		)




"""simple docstring"""






# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool





class 					_A		(			lowerCAmelCase      ):
      snake_case__     :  List[Any]				    =      'philschmid/bart-large-cnn-samsum'
      snake_case__     :  int				    =      (
          'This is a tool that summarizes an English text. It takes an input `text` containing the text to summarize, '
          'and returns a summary of the text.'
      )
      snake_case__     :  Tuple				    =      'summarizer'
      snake_case__     :  int				    =      AutoTokenizer
      snake_case__     :  Any				    =      AutoModelForSeqaSeqLM

      snake_case__     :  Optional[int]				    =      ['text']
      snake_case__     :  Optional[int]				    =      ['text']

      def 							A__			(		self						,			__lowerCAmelCase		):







            """simple docstring"""



            return self.pre_processor(__lowerCAmelCase						,			return_tensors="""pt"""						,			truncation=__lowerCAmelCase		)

      def 							A__			(		self						,			__lowerCAmelCase		):







            """simple docstring"""



            return self.model.generate(**__lowerCAmelCase		)[0]







      def 							A__			(		self						,			__lowerCAmelCase		):







            """simple docstring"""



            return self.pre_processor.decode(__lowerCAmelCase						,			skip_special_tokens=__lowerCAmelCase						,			clean_up_tokenization_spaces=__lowerCAmelCase		)



