"""simple docstring"""




import comet  # From: unbabel-comet
import torch

import datasets


__lowerCamelCase							 =     datasets.logging.get_logger(__name__)

__lowerCamelCase							 =     "\\n@inproceedings{rei-EtAl:2020:WMT,\n   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},\n   title     = {Unbabel's Participation in the WMT20 Metrics Shared Task},\n   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},\n   month          = {November},\n   year           = {2020},\n   address        = {Online},\n   publisher      = {Association for Computational Linguistics},\n   pages     = {909--918},\n}\n@inproceedings{rei-etal-2020-comet,\n   title = \"{COMET}: A Neural Framework for {MT} Evaluation\",\n   author = \"Rei, Ricardo  and\n      Stewart, Craig  and\n      Farinha, Ana C  and\n      Lavie, Alon\",\n   booktitle = \"Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)\",\n   month = nov,\n   year = \"2020\",\n   address = \"Online\",\n   publisher = \"Association for Computational Linguistics\",\n   url = \"https://www.aclweb.org/anthology/2020.emnlp-main.213\",\n   pages = \"2685--2702\",\n}\n"

__lowerCamelCase							 =     "\\nCrosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA's or MQM).\nWith the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.\n\nSee the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.\n"

__lowerCamelCase							 =     "\nCOMET score.\n\nArgs:\n\n`sources` (list of str): Source sentences\n`predictions` (list of str): candidate translations\n`references` (list of str): reference translations\n`cuda` (bool): If set to True, runs COMET using GPU\n`show_progress` (bool): Shows progress\n`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.\n\nReturns:\n    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.\n    `scores`: List of scores.\n\nExamples:\n\n    >>> comet_metric = datasets.load_metric('comet')\n    >>> # comet_metric = load_metric('comet', 'wmt20-comet-da')  # you can also choose which model to use\n    >>> source = [\"Dem Feuer konnte Einhalt geboten werden\", \"Schulen und Kindergärten wurden eröffnet.\"]\n    >>> hypothesis = [\"The fire could be stopped\", \"Schools and kindergartens were open\"]\n    >>> reference = [\"They were able to control the fire.\", \"Schools and kindergartens opened\"]\n    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)\n    >>> print([round(v, 2) for v in results[\"scores\"]])\n    [0.19, 0.92]\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,  _KWARGS_DESCRIPTION       )
class 			UpperCamelCase__(	datasets.Metric       ):





						def  snake_case__		(				self   )    -> Optional[Any]:
													return datasets.MetricInfo(
													    description=_DESCRIPTION						,citation=_CITATION						,homepage='https://unbabel.github.io/COMET/html/index.html'						,inputs_description=_KWARGS_DESCRIPTION						,features=datasets.Features(
													        {
													            'sources': datasets.Value('string'						,id='sequence'   ),
													            'predictions': datasets.Value('string'						,id='sequence'   ),
													            'references': datasets.Value('string'						,id='sequence'   ),
													        }   )						,codebase_urls=['https://github.com/Unbabel/COMET']						,reference_urls=[
													        'https://github.com/Unbabel/COMET',
													        'https://www.aclweb.org/anthology/2020.emnlp-main.213/',
													        'http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6',
													    ]						,)





						def  snake_case__		(				self						,__UpperCAmelCase   )    -> Union[str, Any]:
													if self.config_name == "default":
																				A__		   =							comet.load_from_checkpoint(comet.download_model('wmt20-comet-da'   )   )
													else:
																				A__		   =							comet.load_from_checkpoint(comet.download_model(self.config_name   )   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase=None						,__UpperCAmelCase=False   )    -> Union[str, Any]:
													if gpus is None:
																				A__		   =							1 if torch.cuda.is_available() else 0
													A__		   =							{'src': sources, 'mt': predictions, 'ref': references}
													A__		   =							[dict(zip(__UpperCAmelCase						,__UpperCAmelCase   )   ) for t in zip(*data.values()   )]
													A__   ,     A__		   =							self.scorer.predict(__UpperCAmelCase						,gpus=__UpperCAmelCase						,progress_bar=__UpperCAmelCase   )
													return {"mean_score": mean_score, "scores": scores}






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





						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.0_2						,__UpperCAmelCase=["stage2", "stage3", "stage4"]						,__UpperCAmelCase=3						,__UpperCAmelCase=None						,)    -> Optional[int]:
													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   )    -> List[Any]:
													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   )    -> str:
													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:
													return UperNetConfig(
													    backbone_config=self.get_backbone_config()						,hidden_size=5_12						,pool_scales=[1, 2, 3, 6]						,use_auxiliary_head=__UpperCAmelCase						,auxiliary_loss_weight=0.4						,auxiliary_in_channels=40						,auxiliary_channels=2_56						,auxiliary_num_convs=1						,auxiliary_concat_input=__UpperCAmelCase						,loss_ignore_index=2_55						,num_labels=self.num_labels						,)





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							UperNetForSemanticSegmentation(config=__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase   )
													self.parent.assertEqual(
													    result.logits.shape						,(self.batch_size, self.num_labels, self.image_size, self.image_size)   )





						def  snake_case__		(				self   )    -> str:
													A__		   =							self.prepare_config_and_inputs()
													(
													    (
													    A__
													)   ,     (
													    A__
													)   ,     (
													    A__
													)   ,     
													)		   =							config_and_inputs
													A__		   =							{'pixel_values': pixel_values}
													return config, inputs_dict






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





						def  snake_case__		(				self   )    -> Union[str, Any]:
													A__		   =							UperNetModelTester(self   )
													A__		   =							ConfigTester(self						,config_class=__UpperCAmelCase						,has_text_modality=__UpperCAmelCase						,hidden_size=37   )





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





						def  snake_case__		(				self   )    -> List[Any]:
													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

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





						def  snake_case__		(				self   )    -> Tuple:
													A__		   =							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  snake_case__		(				self   )    -> Optional[int]:
													pass





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





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





						@unittest.skip(reason='UperNet does not have a base model'   )
						def  snake_case__		(				self   )    -> Dict:
													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   )    -> Any:
													pass





						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'   )
						def  snake_case__		(				self   )    -> Dict:
													pass





						def  snake_case__		(				self   )    -> Optional[int]:
													def check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   ):
																				A__		   =							model_class(__UpperCAmelCase   )
																				model.to(__UpperCAmelCase   )
																				model.eval()

																				with torch.no_grad():
																											A__		   =							model(**self._prepare_for_class(__UpperCAmelCase						,__UpperCAmelCase   )   )

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

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

													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__		   =							True
																				check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )

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

																				check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Optional[Any]:
													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													A__		   =							_config_zero_init(__UpperCAmelCase   )
													A__		   =							_config_zero_init(configs_no_init.backbone_config   )
													for model_class in self.all_model_classes:
																				A__		   =							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  snake_case__		(				self   )    -> str:
													pass





						@slow
						def  snake_case__		(				self   )    -> List[str]:
													for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__		   =							UperNetForSemanticSegmentation.from_pretrained(__UpperCAmelCase   )
																				self.assertIsNotNone(__UpperCAmelCase   )






def      UpperCAmelCase    (		):






							"""simple docstring"""





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





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'   )
													A__		   =							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'   ).to(__UpperCAmelCase   )

													A__		   =							prepare_img()
													A__		   =							processor(images=__UpperCAmelCase						,return_tensors='pt'   ).to(__UpperCAmelCase   )

													with torch.no_grad():
																				A__		   =							model(**__UpperCAmelCase   )

													A__		   =							torch.Size((1, model.config.num_labels, 5_12, 5_12)   )
													self.assertEqual(outputs.logits.shape						,__UpperCAmelCase   )

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





						def  snake_case__		(				self   )    -> str:
													A__		   =							AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'   )
													A__		   =							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'   ).to(__UpperCAmelCase   )

													A__		   =							prepare_img()
													A__		   =							processor(images=__UpperCAmelCase						,return_tensors='pt'   ).to(__UpperCAmelCase   )

													with torch.no_grad():
																				A__		   =							model(**__UpperCAmelCase   )

													A__		   =							torch.Size((1, model.config.num_labels, 5_12, 5_12)   )
													self.assertEqual(outputs.logits.shape						,__UpperCAmelCase   )

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





