



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






			def __init__(     self					,   _UpperCAmelCase					,   _UpperCAmelCase=13					,   _UpperCAmelCase=7					,   _UpperCAmelCase=True					,   _UpperCAmelCase=True					,   _UpperCAmelCase=False					,   _UpperCAmelCase=True					,   _UpperCAmelCase=99					,   _UpperCAmelCase=64					,   _UpperCAmelCase=5					,   _UpperCAmelCase=4					,   _UpperCAmelCase=64					,   _UpperCAmelCase="gelu"					,   _UpperCAmelCase=0.1					,   _UpperCAmelCase=0.1					,   _UpperCAmelCase=512					,   _UpperCAmelCase=16					,   _UpperCAmelCase=2					,   _UpperCAmelCase=0.02					,   _UpperCAmelCase=3					,   _UpperCAmelCase=4					,   _UpperCAmelCase=None					,   )							->							Dict:
					snake_case__	     =parent
					snake_case__	     =batch_size
					snake_case__	     =seq_length
					snake_case__	     =is_training
					snake_case__	     =use_input_mask
					snake_case__	     =use_token_type_ids
					snake_case__	     =use_labels
					snake_case__	     =vocab_size
					snake_case__	     =hidden_size
					snake_case__	     =num_hidden_layers
					snake_case__	     =num_attention_heads
					snake_case__	     =intermediate_size
					snake_case__	     =hidden_act
					snake_case__	     =hidden_dropout_prob
					snake_case__	     =attention_probs_dropout_prob
					snake_case__	     =max_position_embeddings
					snake_case__	     =type_vocab_size
					snake_case__	     =type_sequence_label_size
					snake_case__	     =initializer_range
					snake_case__	     =num_labels
					snake_case__	     =num_choices
					snake_case__	     =scope






			def 						_lowercase  (     self						)							->							Optional[Any]:
					return MPNetConfig.from_pretrained('microsoft/mpnet-base'						)






			def 						_lowercase  (     self						)							->							Optional[int]:
					snake_case__	     =ids_tensor([self.batch_size, self.seq_length]					,   self.vocab_size						)

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

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

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






			def 						_lowercase  (     self						)							->							Optional[Any]:
					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 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Dict:
					snake_case__	     =MPNetModel(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   _UpperCAmelCase						)
					snake_case__	     =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 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Union[str, Any]:
					snake_case__	     =MPNetForQuestionAnswering(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =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 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Optional[Any]:
					snake_case__	     =self.num_labels
					snake_case__	     =MPNetForSequenceClassification(_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_labels)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Union[str, Any]:
					snake_case__	     =self.num_choices
					snake_case__	     =MPNetForMultipleChoice(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =input_ids.unsqueeze(1						).expand(-1					,   self.num_choices					,   -1						).contiguous()
					snake_case__	     =input_mask.unsqueeze(1						).expand(-1					,   self.num_choices					,   -1						).contiguous()
					snake_case__	     =model(
					    _UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   labels=_UpperCAmelCase					,   )
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_choices)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Any:
					snake_case__	     =self.num_labels
					snake_case__	     =MPNetForTokenClassification(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.num_labels)						)






			def 						_lowercase  (     self						)							->							Optional[Any]:
					snake_case__	     =self.prepare_config_and_inputs()
					((snake_case__)     ,	(snake_case__)     ,	(snake_case__)     ,	(snake_case__)     ,	(snake_case__)     ,	(snake_case__))	     =config_and_inputs
					snake_case__	     ={'input_ids': input_ids, 'attention_mask': input_mask}
					return config, inputs_dict





@require_torch
class 							a__( snake_case__   ,      snake_case__   ,      unittest.TestCase     ):
			a_	: Optional[int]									=      (
			    (
			        MPNetForMaskedLM,
			        MPNetForMultipleChoice,
			        MPNetForQuestionAnswering,
			        MPNetForSequenceClassification,
			        MPNetForTokenClassification,
			        MPNetModel,
			    )
			    if is_torch_available()
			    else ()
			)
			a_	: int									=      (
			    {
			        '''feature-extraction''': MPNetModel,
			        '''fill-mask''': MPNetForMaskedLM,
			        '''question-answering''': MPNetForQuestionAnswering,
			        '''text-classification''': MPNetForSequenceClassification,
			        '''token-classification''': MPNetForTokenClassification,
			        '''zero-shot''': MPNetForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			a_	: Any									=      False
			a_	: int									=      True






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__	     =MPNetModelTester(self						)
					snake_case__	     =ConfigTester(self					,   config_class=_UpperCAmelCase					,   hidden_size=37						)






			def 						_lowercase  (     self						)							->							Any:
					self.config_tester.run_common_tests()






			def 						_lowercase  (     self						)							->							Any:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_mpnet_model(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Dict:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_mpnet_for_sequence_classification(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							int:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_mpnet_for_multiple_choice(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Any:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_mpnet_for_token_classification(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Any:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_mpnet_for_question_answering(*_UpperCAmelCase						)





@require_torch
class 							a__( unittest.TestCase     ):






			@slow
			def 						_lowercase  (     self						)							->							Dict:
					snake_case__	     =MPNetModel.from_pretrained('microsoft/mpnet-base'						)
					snake_case__	     =torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]						)
					snake_case__	     =model(_UpperCAmelCase						)[0]
					snake_case__	     =torch.Size((1, 11, 768)						)
					self.assertEqual(output.shape					,   _UpperCAmelCase						)
					snake_case__	     =torch.tensor(
					    [[[-0.0_550, 0.1_943, -0.0_740], [-0.0_562, 0.2_211, -0.0_579], [-0.0_437, 0.3_337, -0.0_641]]]						)
					# compare the actual values for a slice.
					self.assertTrue(torch.allclose(output[:, :3, :3]					,   _UpperCAmelCase					,   atol=1E-4						)						)









'''simple docstring'''

from timeit import timeit






def 				a  (     UpperCamelCase_    :    int			)       ->	int:
		if number < 0:
				raise ValueError('the value of input must not be negative'			)
		snake_case__	     =0
		while number:
				number &= number - 1
				result += 1
		return result






def 				a  (     UpperCamelCase_    :    int			)       ->	int:
		if number < 0:
				raise ValueError('the value of input must not be negative'			)
		snake_case__	     =0
		while number:
				if number % 2 == 1:
						result += 1
				number >>= 1
		return result






def 				a  (     )       ->	None:

		def do_benchmark(UpperCamelCase_    :    int			) -> None:
				snake_case__	     ='import __main__ as z'
				print(f"""Benchmark when {number = }:"""			)
				print(f"""{get_set_bits_count_using_modulo_operator(UpperCamelCase_			) = }"""			)
				snake_case__	     =timeit('z.get_set_bits_count_using_modulo_operator(25)'      ,					setup=UpperCamelCase_			)
				print(f"""timeit() runs in {timing} seconds"""			)
				print(f"""{get_set_bits_count_using_brian_kernighans_algorithm(UpperCamelCase_			) = }"""			)
				snake_case__	     =timeit(
				    'z.get_set_bits_count_using_brian_kernighans_algorithm(25)'      ,					setup=UpperCamelCase_      ,					)
				print(f"""timeit() runs in {timing} seconds"""			)

		for number in (25, 37, 58, 0):
				do_benchmark(UpperCamelCase_			)
				print()


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			benchmark()




