


"""simple docstring"""


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     _UpperCamelCase    :
							'''simple docstring'''







							def __init__(	self       ,  __a       ,  __a=13       ,  __a=7       ,  __a=True       ,  __a=True       ,  __a=True       ,  __a=True       ,  __a=99       ,  __a=32       ,  __a=5       ,  __a=4       ,  __a=37       ,  __a="gelu"       ,  __a=0.1       ,  __a=0.1       ,  __a=5_12       ,  __a=16       ,  __a=2       ,  __a=0.0_2       ,  __a=3       ,  __a=4       ,  __a=None       ,  ):
										__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      snake_case							(	self      ):
										__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
										if self.use_token_type_ids:
													__lowerCAmelCase							       =     ids_tensor([self.batch_size, self.seq_length]       ,  self.type_vocab_size      )

										__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, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

							def      snake_case							(	self      ):
										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=__a       ,  initializer_range=self.initializer_range       ,  )

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

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

							def      snake_case							(	self       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a      ):
										__lowerCAmelCase							       =     NystromformerForQuestionAnswering(config=__a      )
										model.to(__a      )
										model.eval()
										__lowerCAmelCase							       =     model(
										    __a       ,  attention_mask=__a       ,  token_type_ids=__a       ,  start_positions=__a       ,  end_positions=__a       ,  )
										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       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a       ,  __a      ):
										__lowerCAmelCase							       =     self.num_labels
										__lowerCAmelCase							       =     NystromformerForSequenceClassification(__a      )
										model.to(__a      )
										model.eval()
										__lowerCAmelCase							       =     model(__a       ,  attention_mask=__a       ,  token_type_ids=__a       ,  labels=__a      )
										self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels)      )

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

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



							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.prepare_config_and_inputs()
										(
										    (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      (
										    __lowerCAmelCase
										)       ,      
										)							       =     config_and_inputs
										__lowerCAmelCase							       =     {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
										return config, inputs_dict
@require_torch
class     _UpperCamelCase    (  lowerCAmelCase__			,lowerCAmelCase__			,unittest.TestCase						):
							'''simple docstring'''







							__UpperCAmelCase		:       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		:       str							 =False
							__UpperCAmelCase		:       Dict							 =False

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     NystromformerModelTester(self      )
										__lowerCAmelCase							       =     ConfigTester(self       ,  config_class=__a       ,  hidden_size=37      )

							def      snake_case							(	self      ):
										self.config_tester.run_common_tests()

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__a      )

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

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*__a      )

							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*__a      )



							@slow
							def      snake_case							(	self      ):
										for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowerCAmelCase							       =     NystromformerModel.from_pretrained(__a      )
													self.assertIsNotNone(__a      )
@require_torch
class     _UpperCamelCase    (  unittest.TestCase						):
							'''simple docstring'''







							@slow
							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     NystromformerModel.from_pretrained("uw-madison/nystromformer-512"      )
										__lowerCAmelCase							       =     torch.tensor([[0, 1, 2, 3, 4, 5]]      )

										with torch.no_grad():
													__lowerCAmelCase							       =     model(__a      )[0]

										__lowerCAmelCase							       =     torch.Size((1, 6, 7_68)      )
										self.assertEqual(output.shape       ,  __a      )

										__lowerCAmelCase							       =     torch.tensor(
										    [[[-0.4_5_3_2, -0.0_9_3_6, 0.5_1_3_7], [-0.2_6_7_6, 0.0_6_2_8, 0.6_1_8_6], [-0.3_6_2_9, -0.1_7_2_6, 0.4_7_1_6]]]      )

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



							@slow
							def      snake_case							(	self      ):
										__lowerCAmelCase							       =     "the [MASK] of Belgium is Brussels"

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

										__lowerCAmelCase							       =     tokenizer(__a       ,  return_tensors="pt"      )

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

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

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








"""simple docstring"""


import warnings

from ...utils import logging
from .image_processing_yolos import YolosImageProcessor


A	:  Optional[Any]            =     logging.get_logger(__name__)
class     _UpperCamelCase    (  lowerCAmelCase__						):
							'''simple docstring'''







							def __init__(	self       ,  *__a       ,  **__a      ):
										warnings.warn(
										    "The class YolosFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
										    " use YolosImageProcessor instead."       ,  __a       ,  )
										super().__init__(*__a       ,  **__a      )




