


import unittest

from transformers import AutoTokenizer, NystromformerConfig, 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 (
						    NystromformerForMaskedLM,
						    NystromformerForMultipleChoice,
						    NystromformerForQuestionAnswering,
						    NystromformerForSequenceClassification,
						    NystromformerForTokenClassification,
						    NystromformerModel,
						)
						from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST







class        lowerCamelCase__	:






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=13      ,						snake_case=7      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=99      ,						snake_case=32      ,						snake_case=5      ,						snake_case=4      ,						snake_case=37      ,						snake_case="gelu"      ,						snake_case=0.1      ,						snake_case=0.1      ,						snake_case=512      ,						snake_case=16      ,						snake_case=2      ,						snake_case=0.02      ,						snake_case=3      ,						snake_case=4      ,						snake_case=None      ,						):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


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

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

						UpperCamelCase__					=       None
						if self.use_token_type_ids:
									UpperCamelCase__					=       ids_tensor([self.batch_size, self.seq_length]      ,						self.type_vocab_size     )

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

						UpperCamelCase__					=       self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return NystromformerConfig(
						    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      ,						type_vocab_size=self.type_vocab_size      ,						is_decoder=snake_case      ,						initializer_range=self.initializer_range      ,						)




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       NystromformerModel(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case     )
						UpperCamelCase__					=       model(snake_case      ,						token_type_ids=snake_case     )
						UpperCamelCase__					=       model(snake_case     )
						self.parent.assertEqual(result.last_hidden_state.shape      ,						(self.batch_size, self.seq_length, self.hidden_size)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       NystromformerForMaskedLM(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						labels=snake_case     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.vocab_size)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       NystromformerForQuestionAnswering(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(
						    snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						start_positions=snake_case      ,						end_positions=snake_case      ,						)
						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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_labels
						UpperCamelCase__					=       NystromformerForSequenceClassification(snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						labels=snake_case     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.num_labels)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_labels
						UpperCamelCase__					=       NystromformerForTokenClassification(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						labels=snake_case     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.num_labels)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_choices
						UpperCamelCase__					=       NystromformerForMultipleChoice(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       input_ids.unsqueeze(1     ).expand(-1      ,						self.num_choices      ,						-1     ).contiguous()
						UpperCamelCase__					=       token_type_ids.unsqueeze(1     ).expand(-1      ,						self.num_choices      ,						-1     ).contiguous()
						UpperCamelCase__					=       input_mask.unsqueeze(1     ).expand(-1      ,						self.num_choices      ,						-1     ).contiguous()
						UpperCamelCase__					=       model(
						    snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						labels=snake_case      ,						)
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.num_choices)     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.prepare_config_and_inputs()
						(
						    (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      
						)					=       config_and_inputs
						UpperCamelCase__					=       {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
						return config, inputs_dict







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






			"""simple docstring"""






			_UpperCamelCase		:					Optional[int]    =		(
			    (
			        NystromformerModel,
			        NystromformerForMaskedLM,
			        NystromformerForMultipleChoice,
			        NystromformerForQuestionAnswering,
			        NystromformerForSequenceClassification,
			        NystromformerForTokenClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			_UpperCamelCase		:					Union[str, Any]    =		(
			    {
			        'feature-extraction': NystromformerModel,
			        'fill-mask': NystromformerForMaskedLM,
			        'question-answering': NystromformerForQuestionAnswering,
			        'text-classification': NystromformerForSequenceClassification,
			        'token-classification': NystromformerForTokenClassification,
			        'zero-shot': NystromformerForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			_UpperCamelCase		:					Any    =		False
			_UpperCamelCase		:					Union[str, Any]    =		False




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       NystromformerModelTester(self     )
						UpperCamelCase__					=       ConfigTester(self      ,						config_class=snake_case      ,						hidden_size=37     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
									UpperCamelCase__					=       type
									self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*snake_case     )







			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCamelCase__					=       NystromformerModel.from_pretrained(snake_case     )
									self.assertIsNotNone(snake_case     )







@require_torch
class        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       NystromformerModel.from_pretrained("uw-madison/nystromformer-512"     )
						UpperCamelCase__					=       torch.tensor([[0, 1, 2, 3, 4, 5]]     )

						with torch.no_grad():
									UpperCamelCase__					=       model(snake_case     )[0]

						UpperCamelCase__					=       torch.Size((1, 6, 768)     )
						self.assertEqual(output.shape      ,						snake_case     )

						UpperCamelCase__					=       torch.tensor(
						    [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]]     )

						self.assertTrue(torch.allclose(output[:, :3, :3]      ,						snake_case      ,						atol=1E-4     )     )







			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       "the [MASK] of Belgium is Brussels"

						UpperCamelCase__					=       AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"     )
						UpperCamelCase__					=       NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"     )

						UpperCamelCase__					=       tokenizer(snake_case      ,						return_tensors="pt"     )

						with torch.no_grad():
									UpperCamelCase__					=       model(encoding.input_ids     ).logits

						UpperCamelCase__					=       token_logits[:, 2, :].argmax(-1     )[0]

						self.assertEqual(tokenizer.decode(snake_case     )      ,						"capital"     )






def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number < 0 or shift_amount < 0:
						raise ValueError("both inputs must be positive integers"  )

			UpperCamelCase__					=       str(bin(_A  )  )
			binary_number += "0" * shift_amount
			return binary_number
def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number < 0 or shift_amount < 0:
						raise ValueError("both inputs must be positive integers"  )

			UpperCamelCase__					=       str(bin(_A  )  )[2:]
			if shift_amount >= len(_A  ):
						return "0b0"
			UpperCamelCase__					=       binary_number[: len(_A  ) - shift_amount]
			return "0b" + shifted_binary_number
def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number >= 0:  # Get binary representation of positive number
						UpperCamelCase__					=       "0" + str(bin(_A  )  ).strip("-"  )[2:]
			else:  # Get binary (2's complement) representation of negative number
						UpperCamelCase__					=       len(bin(_A  )[3:]  )  # Find 2's complement of number
						UpperCamelCase__					=       bin(abs(_A  ) - (1 << binary_number_length)  )[3:]
						UpperCamelCase__					=       (
						    "1" + "0" * (binary_number_length - len(_A  )) + binary_number
						)

			if shift_amount >= len(_A  ):
						return "0b" + binary_number[0] * len(_A  )
			return (
			    "0b"
			    + binary_number[0] * shift_amount
			    + binary_number[: len(_A  ) - shift_amount]
			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()


