
"""simple docstring"""



import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
	from PIL import Image
else:
	class        _SCREAMING_SNAKE_CASE  :






					'''simple docstring'''



					@staticmethod
					def 				__lowerCamelCase	(					*UpperCAmelCase_	:			Optional[int]				,     **UpperCAmelCase_	:			Tuple  )		->  str:







												"""simple docstring"""




												pass






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					Image						):






							"""simple docstring"""



							_lowerCAmelCase  	=			hashlib.mda(image.tobytes()						)
							return m.hexdigest()[:10]






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					Image						):






							"""simple docstring"""



							_lowerCAmelCase  	=			np.array(SCREAMING_SNAKE_CASE						)
							_lowerCAmelCase  	=			npimg.shape
							return {"hash": hashimage(SCREAMING_SNAKE_CASE						), "shape": shape}

@is_pipeline_test
@require_vision
@require_torch
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Union[str, Any]							=					dict(
				    (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()							) if MODEL_FOR_MASK_GENERATION_MAPPING else [])							)
				SCREAMING_SNAKE_CASE_:							Any							=					dict(
				    (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()							) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])							)


				def 				__lowerCamelCase	(					self	:			int				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[int]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MaskGenerationPipeline(model=UpperCAmelCase_				,     image_processor=UpperCAmelCase_  )
											return image_segmenter, [
											    "./tests/fixtures/tests_samples/COCO/000000039769.png",
											    "./tests/fixtures/tests_samples/COCO/000000039769.png",
											]


				def 				__lowerCamelCase	(					self	:			List[str]				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			Tuple  )		->  Optional[int]:







											"""simple docstring"""




											pass


				@require_tf
				@unittest.skip('Image segmentation not implemented in TF'  )
				def 				__lowerCamelCase	(					self	:			str  )		->  str:







											"""simple docstring"""




											pass


				@slow
				@require_torch
				def 				__lowerCamelCase	(					self	:			Tuple  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			pipeline('mask-generation'				,     model='facebook/sam-vit-huge'  )

											_lowerCAmelCase  	=			image_segmenter('http://images.cocodataset.org/val2017/000000039769.jpg'				,     points_per_batch=256  )

											# Shortening by hashing
											_lowerCAmelCase  	=			[]
											for i, o in enumerate(outputs['masks']  ):
																		new_outupt += [{"mask": mask_to_test_readable(UpperCAmelCase_  ), "scores": outputs["scores"][i]}]

											# fmt: off
											self.assertEqual(
											    nested_simplify(UpperCAmelCase_				,     decimals=4  )				,     [
											        {'mask': {'hash': '115ad19f5f', 'shape': (480, 640)}, 'scores': 1.0444},
											        {'mask': {'hash': '6affa964c6', 'shape': (480, 640)}, 'scores': 1.021},
											        {'mask': {'hash': 'dfe28a0388', 'shape': (480, 640)}, 'scores': 1.0167},
											        {'mask': {'hash': 'c0a5f4a318', 'shape': (480, 640)}, 'scores': 1.0132},
											        {'mask': {'hash': 'fe8065c197', 'shape': (480, 640)}, 'scores': 1.0053},
											        {'mask': {'hash': 'e2d0b7a0b7', 'shape': (480, 640)}, 'scores': 0.9967},
											        {'mask': {'hash': '453c7844bd', 'shape': (480, 640)}, 'scores': 0.993},
											        {'mask': {'hash': '3d44f2926d', 'shape': (480, 640)}, 'scores': 0.9909},
											        {'mask': {'hash': '64033ddc3f', 'shape': (480, 640)}, 'scores': 0.9879},
											        {'mask': {'hash': '801064ff79', 'shape': (480, 640)}, 'scores': 0.9834},
											        {'mask': {'hash': '6172f276ef', 'shape': (480, 640)}, 'scores': 0.9716},
											        {'mask': {'hash': 'b49e60e084', 'shape': (480, 640)}, 'scores': 0.9612},
											        {'mask': {'hash': 'a811e775fd', 'shape': (480, 640)}, 'scores': 0.9599},
											        {'mask': {'hash': 'a6a8ebcf4b', 'shape': (480, 640)}, 'scores': 0.9552},
											        {'mask': {'hash': '9d8257e080', 'shape': (480, 640)}, 'scores': 0.9532},
											        {'mask': {'hash': '32de6454a8', 'shape': (480, 640)}, 'scores': 0.9516},
											        {'mask': {'hash': 'af3d4af2c8', 'shape': (480, 640)}, 'scores': 0.9499},
											        {'mask': {'hash': '3c6db475fb', 'shape': (480, 640)}, 'scores': 0.9483},
											        {'mask': {'hash': 'c290813fb9', 'shape': (480, 640)}, 'scores': 0.9464},
											        {'mask': {'hash': 'b6f0b8f606', 'shape': (480, 640)}, 'scores': 0.943},
											        {'mask': {'hash': '92ce16bfdf', 'shape': (480, 640)}, 'scores': 0.943},
											        {'mask': {'hash': 'c749b25868', 'shape': (480, 640)}, 'scores': 0.9408},
											        {'mask': {'hash': 'efb6cab859', 'shape': (480, 640)}, 'scores': 0.9335},
											        {'mask': {'hash': '1ff2eafb30', 'shape': (480, 640)}, 'scores': 0.9326},
											        {'mask': {'hash': '788b798e24', 'shape': (480, 640)}, 'scores': 0.9262},
											        {'mask': {'hash': 'abea804f0e', 'shape': (480, 640)}, 'scores': 0.8999},
											        {'mask': {'hash': '7b9e8ddb73', 'shape': (480, 640)}, 'scores': 0.8986},
											        {'mask': {'hash': 'cd24047c8a', 'shape': (480, 640)}, 'scores': 0.8984},
											        {'mask': {'hash': '6943e6bcbd', 'shape': (480, 640)}, 'scores': 0.8873},
											        {'mask': {'hash': 'b5f47c9191', 'shape': (480, 640)}, 'scores': 0.8871}
											    ]				,     )
											# fmt: on







				@require_torch
				@slow
				def 				__lowerCamelCase	(					self	:			str  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			'facebook/sam-vit-huge'
											_lowerCAmelCase  	=			pipeline('mask-generation'				,     model=UpperCAmelCase_  )

											_lowerCAmelCase  	=			image_segmenter(
											    'http://images.cocodataset.org/val2017/000000039769.jpg'				,     pred_iou_thresh=1				,     points_per_batch=256  )

											# Shortening by hashing
											_lowerCAmelCase  	=			[]
											for i, o in enumerate(outputs['masks']  ):
																		new_outupt += [{"mask": mask_to_test_readable(UpperCAmelCase_  ), "scores": outputs["scores"][i]}]

											self.assertEqual(
											    nested_simplify(UpperCAmelCase_				,     decimals=4  )				,     [
											        {'mask': {'hash': '115ad19f5f', 'shape': (480, 640)}, 'scores': 1.0444},
											        {'mask': {'hash': '6affa964c6', 'shape': (480, 640)}, 'scores': 1.0210},
											        {'mask': {'hash': 'dfe28a0388', 'shape': (480, 640)}, 'scores': 1.0167},
											        {'mask': {'hash': 'c0a5f4a318', 'shape': (480, 640)}, 'scores': 1.0132},
											        {'mask': {'hash': 'fe8065c197', 'shape': (480, 640)}, 'scores': 1.0053},
											    ]				,     )








"""simple docstring"""



import unittest

from transformers import MPNetConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MPNetForMaskedLM,
	    MPNetForMultipleChoice,
	    MPNetForQuestionAnswering,
	    MPNetForSequenceClassification,
	    MPNetForTokenClassification,
	    MPNetModel,
	)
class        _SCREAMING_SNAKE_CASE  :






				'''simple docstring'''



				def __init__(					self	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			str=13				,     UpperCAmelCase_	:			Dict=7				,     UpperCAmelCase_	:			Tuple=True				,     UpperCAmelCase_	:			Any=True				,     UpperCAmelCase_	:			Optional[int]=False				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Optional[Any]=99				,     UpperCAmelCase_	:			int=64				,     UpperCAmelCase_	:			Union[str, Any]=5				,     UpperCAmelCase_	:			Union[str, Any]=4				,     UpperCAmelCase_	:			List[Any]=64				,     UpperCAmelCase_	:			List[str]="gelu"				,     UpperCAmelCase_	:			Optional[Any]=0.1				,     UpperCAmelCase_	:			Dict=0.1				,     UpperCAmelCase_	:			Tuple=512				,     UpperCAmelCase_	:			Optional[Any]=16				,     UpperCAmelCase_	:			str=2				,     UpperCAmelCase_	:			int=0.02				,     UpperCAmelCase_	:			List[str]=3				,     UpperCAmelCase_	:			int=4				,     UpperCAmelCase_	:			Tuple=None				,     )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase  	=			parent
											_lowerCAmelCase  	=			batch_size
											_lowerCAmelCase  	=			seq_length
											_lowerCAmelCase  	=			is_training
											_lowerCAmelCase  	=			use_input_mask
											_lowerCAmelCase  	=			use_token_type_ids
											_lowerCAmelCase  	=			use_labels
											_lowerCAmelCase  	=			vocab_size
											_lowerCAmelCase  	=			hidden_size
											_lowerCAmelCase  	=			num_hidden_layers
											_lowerCAmelCase  	=			num_attention_heads
											_lowerCAmelCase  	=			intermediate_size
											_lowerCAmelCase  	=			hidden_act
											_lowerCAmelCase  	=			hidden_dropout_prob
											_lowerCAmelCase  	=			attention_probs_dropout_prob
											_lowerCAmelCase  	=			max_position_embeddings
											_lowerCAmelCase  	=			type_vocab_size
											_lowerCAmelCase  	=			type_sequence_label_size
											_lowerCAmelCase  	=			initializer_range
											_lowerCAmelCase  	=			num_labels
											_lowerCAmelCase  	=			num_choices
											_lowerCAmelCase  	=			scope


				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Any:







											"""simple docstring"""




											return MPNetConfig.from_pretrained('microsoft/mpnet-base'  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size  )

											_lowerCAmelCase  	=			None
											if self.use_input_mask:
																		_lowerCAmelCase  	=			random_attention_mask([self.batch_size, self.seq_length]  )

											_lowerCAmelCase  	=			None
											_lowerCAmelCase  	=			None
											_lowerCAmelCase  	=			None
											if self.use_labels:
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels  )
																		_lowerCAmelCase  	=			ids_tensor([self.batch_size]				,     self.num_choices  )

											_lowerCAmelCase  	=			self.get_config()
											return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


				def 				__lowerCamelCase	(					self	:			Any  )		->  Tuple:







											"""simple docstring"""




											return MPNetConfig(
											    vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     initializer_range=self.initializer_range				,     )


				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[int]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModel(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     UpperCAmelCase_  )
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)  )
											self.parent.assertEqual(result.pooler_output.shape				,     (self.batch_size, self.hidden_size)  )


				def 				__lowerCamelCase	(					self	:			List[str]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[Any]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			int  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetForQuestionAnswering(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(
											    UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     start_positions=UpperCAmelCase_				,     end_positions=UpperCAmelCase_				,     )
											self.parent.assertEqual(result.start_logits.shape				,     (self.batch_size, self.seq_length)  )
											self.parent.assertEqual(result.end_logits.shape				,     (self.batch_size, self.seq_length)  )


				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			MPNetForSequenceClassification(UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)  )


				def 				__lowerCamelCase	(					self	:			int				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			List[Any]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_choices
											_lowerCAmelCase  	=			MPNetForMultipleChoice(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			input_ids.unsqueeze(1  ).expand(-1				,     self.num_choices				,     -1  ).contiguous()
											_lowerCAmelCase  	=			input_mask.unsqueeze(1  ).expand(-1				,     self.num_choices				,     -1  ).contiguous()
											_lowerCAmelCase  	=			model(
											    UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_				,     )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)  )


				def 				__lowerCamelCase	(					self	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[str]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			MPNetForTokenClassification(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)  )







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







											"""simple docstring"""




											_lowerCAmelCase  	=			self.prepare_config_and_inputs()
											((_lowerCAmelCase)	,		(_lowerCAmelCase)	,		(_lowerCAmelCase)	,		(_lowerCAmelCase)	,		(_lowerCAmelCase)	,		(_lowerCAmelCase))  	=			config_and_inputs
											_lowerCAmelCase  	=			{'input_ids': input_ids, 'attention_mask': input_mask}
											return config, inputs_dict






@require_torch
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Union[str, Any]							=					(
				    (
				        MPNetForMaskedLM,
				        MPNetForMultipleChoice,
				        MPNetForQuestionAnswering,
				        MPNetForSequenceClassification,
				        MPNetForTokenClassification,
				        MPNetModel,
				    )
				    if is_torch_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_:							int							=					(
				    {
				        "feature-extraction": MPNetModel,
				        "fill-mask": MPNetForMaskedLM,
				        "question-answering": MPNetForQuestionAnswering,
				        "text-classification": MPNetForSequenceClassification,
				        "token-classification": MPNetForTokenClassification,
				        "zero-shot": MPNetForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				SCREAMING_SNAKE_CASE_:							Optional[Any]							=					False
				SCREAMING_SNAKE_CASE_:							Dict							=					True


				def 				__lowerCamelCase	(					self	:			str  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModelTester(self  )
											_lowerCAmelCase  	=			ConfigTester(self				,     config_class=UpperCAmelCase_				,     hidden_size=37  )


				def 				__lowerCamelCase	(					self	:			Dict  )		->  Dict:







											"""simple docstring"""




											self.config_tester.run_common_tests()


				def 				__lowerCamelCase	(					self	:			Tuple  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_model(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_sequence_classification(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_multiple_choice(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Any  )		->  List[str]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_token_classification(*UpperCAmelCase_  )







				def 				__lowerCamelCase	(					self	:			Any  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_question_answering(*UpperCAmelCase_  )






@require_torch
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				@slow
				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModel.from_pretrained('microsoft/mpnet-base'  )
											_lowerCAmelCase  	=			torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]  )
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )[0]
											_lowerCAmelCase  	=			torch.Size((1, 11, 768)  )
											self.assertEqual(output.shape				,     UpperCAmelCase_  )
											_lowerCAmelCase  	=			torch.tensor(
											    [[[-0.0550, 0.1943, -0.0740], [-0.0562, 0.2211, -0.0579], [-0.0437, 0.3337, -0.0641]]]  )
											# compare the actual values for a slice.
											self.assertTrue(torch.allclose(output[:, :3, :3]				,     UpperCAmelCase_				,     atol=1E-4  )  )






