




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



					'''simple docstring'''





					def __init__(	self     :						str      ,       _lowercase     :						int      ,       _lowercase     :						int=13      ,       _lowercase     :						str=32      ,       _lowercase     :						List[Any]=3      ,       _lowercase     :						int=4      ,       _lowercase     :						Dict=[10, 20, 30, 40]      ,       _lowercase     :						int=[2, 2, 3, 2]      ,       _lowercase     :						Dict=True      ,       _lowercase     :						str=True      ,       _lowercase     :						Tuple=37      ,       _lowercase     :						List[str]="gelu"      ,       _lowercase     :						Dict=10      ,       _lowercase     :						Tuple=0.02      ,       _lowercase     :						str=["stage2", "stage3", "stage4"]      ,       _lowercase     :						Union[str, Any]=3      ,       _lowercase     :						Optional[Any]=None      ,       )    ->							Union[str, Any]:
								A_									= parent
								A_									= batch_size
								A_									= image_size
								A_									= num_channels
								A_									= num_stages
								A_									= hidden_sizes
								A_									= depths
								A_									= is_training
								A_									= use_labels
								A_									= intermediate_size
								A_									= hidden_act
								A_									= type_sequence_label_size
								A_									= initializer_range
								A_									= out_features
								A_									= num_labels
								A_									= scope
								A_									= num_stages



					def     __snake_case						(	self     :						Optional[int])    ->							int:
								A_									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

								A_									= self.get_config()

								return config, pixel_values, labels



					def     __snake_case						(	self     :						Union[str, Any])    ->							int:
								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     __snake_case						(	self     :						Tuple)    ->							List[str]:
								return UperNetConfig(
								    backbone_config=self.get_backbone_config()      ,       hidden_size=512      ,       pool_scales=[1, 2, 3, 6]      ,       use_auxiliary_head=_lowercase      ,       auxiliary_loss_weight=0.4      ,       auxiliary_in_channels=40      ,       auxiliary_channels=256      ,       auxiliary_num_convs=1      ,       auxiliary_concat_input=_lowercase      ,       loss_ignore_index=255      ,       num_labels=self.num_labels      ,       )



					def     __snake_case						(	self     :						Tuple      ,       _lowercase     :						Dict      ,       _lowercase     :						List[Any]      ,       _lowercase     :						List[str])    ->							Tuple:
								A_									= UperNetForSemanticSegmentation(config=_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(
								    result.logits.shape      ,       (self.batch_size, self.num_labels, self.image_size, self.image_size))



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_									= self.prepare_config_and_inputs()
								(
								    A_				
								)									= config_and_inputs
								A_									= {'pixel_values': pixel_values}
								return config, inputs_dict





@require_torch
class   __UpperCAmelCase				(     __UpperCamelCase			,__UpperCamelCase			,unittest.TestCase				):



					'''simple docstring'''





					_UpperCamelCase							=		(UperNetForSemanticSegmentation,) if is_torch_available() else ()
					_UpperCamelCase							=		{"""image-segmentation""": UperNetForSemanticSegmentation} if is_torch_available() else {}
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False



					def     __snake_case						(	self     :						Any)    ->							Dict:
								A_									= UperNetModelTester(self)
								A_									= ConfigTester(self      ,       config_class=_lowercase      ,       has_text_modality=_lowercase      ,       hidden_size=37)



					def     __snake_case						(	self     :						Dict)    ->							List[Any]:
								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     __snake_case						(	self     :						Optional[int])    ->							int:
								return



					def     __snake_case						(	self     :						Any)    ->							List[str]:
								A_									= self.model_tester.prepare_config_and_inputs_for_common()

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

											A_									= ['pixel_values']
											self.assertListEqual(arg_names[:1]      ,       _lowercase)



					def     __snake_case						(	self     :						Any)    ->							Union[str, Any]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*_lowercase)



					@unittest.skip(reason='UperNet does not use inputs_embeds')
					def     __snake_case						(	self     :						Optional[Any])    ->							Tuple:
								pass



					@unittest.skip(reason='UperNet does not support input and output embeddings')
					def     __snake_case						(	self     :						int)    ->							Union[str, Any]:
								pass



					@unittest.skip(reason='UperNet does not have a base model')
					def     __snake_case						(	self     :						Dict)    ->							List[str]:
								pass



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



					@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
					def     __snake_case						(	self     :						Any)    ->							Union[str, Any]:
								pass



					def     __snake_case						(	self     :						Union[str, Any])    ->							Union[str, Any]:
								def check_hidden_states_output(_lowercase     :						Optional[Any]      ,       _lowercase     :						Tuple      ,       _lowercase     :						int):
											A_									= model_class(_lowercase)
											model.to(_lowercase)
											model.eval()

											with torch.no_grad():
														A_									= model(**self._prepare_for_class(_lowercase      ,       _lowercase))

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

											A_									= self.model_tester.num_stages
											self.assertEqual(len(_lowercase)      ,       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_									= self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_									= True
											check_hidden_states_output(_lowercase      ,       _lowercase      ,       _lowercase)

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

											check_hidden_states_output(_lowercase      ,       _lowercase      ,       _lowercase)



					def     __snake_case						(	self     :						Any)    ->							List[str]:
								A_									= self.model_tester.prepare_config_and_inputs_for_common()

								A_									= _config_zero_init(_lowercase)
								A_									= _config_zero_init(configs_no_init.backbone_config)
								for model_class in self.all_model_classes:
											A_									= model_class(config=_lowercase)
											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     __snake_case						(	self     :						str)    ->							int:
								pass



					@slow
					def     __snake_case						(	self     :						str)    ->							Any:
								for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A_									= UperNetForSemanticSegmentation.from_pretrained(_lowercase)
											self.assertIsNotNone(_lowercase)





def 			lowerCamelCase(							)		->		Optional[int]:
			A_									= hf_hub_download(
			    repo_id='hf-internal-testing/fixtures_ade20k'       ,repo_type='dataset'       ,filename='ADE_val_00000001.jpg'     )
			A_									= Image.open(_UpperCAmelCase     ).convert('RGB'     )
			return image






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



					'''simple docstring'''





					def     __snake_case						(	self     :						Optional[Any])    ->							Union[str, Any]:
								A_									= AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny')
								A_									= UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny').to(_lowercase)

								A_									= prepare_img()
								A_									= processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								with torch.no_grad():
											A_									= model(**_lowercase)

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

								A_									= 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(_lowercase)
								self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      ,       _lowercase      ,       atol=1E-4))



					def     __snake_case						(	self     :						List[str])    ->							Any:
								A_									= AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny')
								A_									= UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny').to(_lowercase)

								A_									= prepare_img()
								A_									= processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								with torch.no_grad():
											A_									= model(**_lowercase)

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

								A_									= 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(_lowercase)
								self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      ,       _lowercase      ,       atol=1E-4))











# 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   lowerCAmelCase				(   __UpperCamelCase     ):
 UpperCAmelCase__						=						"""philschmid/bart-large-cnn-samsum"""
 UpperCAmelCase__						=						(
     """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."""
 )
 UpperCAmelCase__						=						"""summarizer"""
 UpperCAmelCase__						=						AutoTokenizer
 UpperCAmelCase__						=						AutoModelForSeqaSeqLM

 UpperCAmelCase__						=						["""text"""]
 UpperCAmelCase__						=						["""text"""]
 def 	A_      ( self    : Tuple     ,	UpperCAmelCase    : List[Any]      )     ->      List[str]:
     return self.pre_processor(UpperCAmelCase     ,	return_tensors='pt'     ,	truncation=UpperCAmelCase      )
 def 	A_      ( self    : Optional[int]     ,	UpperCAmelCase    : Dict      )     ->      str:
     return self.model.generate(**UpperCAmelCase      )[0]







 def 	A_      ( self    : Tuple     ,	UpperCAmelCase    : List[Any]      )     ->      Union[str, Any]:
     return self.pre_processor.decode(UpperCAmelCase     ,	skip_special_tokens=UpperCAmelCase     ,	clean_up_tokenization_spaces=UpperCAmelCase      )





