






'''simple docstring'''







import inspect
import unittest

from transformers import ViTMSNConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
							import torch
							from torch import nn

							from transformers import ViTMSNForImageClassification, ViTMSNModel
							from transformers.models.vit_msn.modeling_vit_msn import VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import ViTImageProcessor




class 		UpperCamelCase__     :




		'''simple docstring'''





		def __init__(   self ,_lowerCAmelCase ,_lowerCAmelCase=13 ,_lowerCAmelCase=30 ,_lowerCAmelCase=2 ,_lowerCAmelCase=3 ,_lowerCAmelCase=True ,_lowerCAmelCase=True ,_lowerCAmelCase=32 ,_lowerCAmelCase=5 ,_lowerCAmelCase=4 ,_lowerCAmelCase=37 ,_lowerCAmelCase="gelu" ,_lowerCAmelCase=0.1 ,_lowerCAmelCase=0.1 ,_lowerCAmelCase=10 ,_lowerCAmelCase=0.02 ,_lowerCAmelCase=None ,):
								lowerCamelCase__								=	parent
								lowerCamelCase__								=	batch_size
								lowerCamelCase__								=	image_size
								lowerCamelCase__								=	patch_size
								lowerCamelCase__								=	num_channels
								lowerCamelCase__								=	is_training
								lowerCamelCase__								=	use_labels
								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__								=	type_sequence_label_size
								lowerCamelCase__								=	initializer_range
								lowerCamelCase__								=	scope

								# in ViT MSN, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								lowerCamelCase__								=	(image_size // patch_size) ** 2
								lowerCamelCase__								=	num_patches + 1






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

								lowerCamelCase__								=	None
								if self.use_labels:
														lowerCamelCase__								=	ids_tensor([self.batch_size] ,self.type_sequence_label_size							)

								lowerCamelCase__								=	self.get_config()

								return config, pixel_values, labels






		def       UpperCamelCase_       (   self							):
								return ViTMSNConfig(
								    image_size=self.image_size ,patch_size=self.patch_size ,num_channels=self.num_channels ,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 ,initializer_range=self.initializer_range ,)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	ViTMSNModel(config=_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()
								lowerCamelCase__								=	model(_lowerCAmelCase							)
								self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size)							)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	self.type_sequence_label_size
								lowerCamelCase__								=	ViTMSNForImageClassification(_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()
								lowerCamelCase__								=	model(_lowerCAmelCase ,labels=_lowerCAmelCase							)
								print("""Pixel and labels shape: {pixel_values.shape}, {labels.shape}"""							)
								print("""Labels: {labels}"""							)
								self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size)							)

								# test greyscale images
								lowerCamelCase__								=	1
								lowerCamelCase__								=	ViTMSNForImageClassification(_lowerCAmelCase							)
								model.to(_lowerCAmelCase							)
								model.eval()

								lowerCamelCase__								=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
								lowerCamelCase__								=	model(_lowerCAmelCase							)
								self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size)							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.prepare_config_and_inputs()
								lowerCamelCase__							,      lowerCamelCase__							,      lowerCamelCase__								=	config_and_inputs
								lowerCamelCase__								=	{"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_torch
class 		UpperCamelCase__     (a ,a ,unittest.TestCase      ):




		'''simple docstring'''





		_UpperCamelCase						=       (ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
		_UpperCamelCase						=       (
		    {'feature-extraction': ViTMSNModel, 'image-classification': ViTMSNForImageClassification}
		    if is_torch_available()
		    else {}
		)

		_UpperCamelCase						=       False
		_UpperCamelCase						=       False
		_UpperCamelCase						=       False
		_UpperCamelCase						=       False






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	ViTMSNModelTester(self							)
								lowerCamelCase__								=	ConfigTester(self ,config_class=_lowerCAmelCase ,has_text_modality=_lowerCAmelCase ,hidden_size=37							)






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






		@unittest.skip(reason="""ViTMSN does not use inputs_embeds"""							)
		def       UpperCamelCase_       (   self							):
								pass






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCamelCase__								=	model_class(_lowerCAmelCase							)
														self.assertIsInstance(model.get_input_embeddings() ,(nn.Module)							)
														lowerCamelCase__								=	model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(_lowerCAmelCase ,nn.Linear							)							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCamelCase__								=	model_class(_lowerCAmelCase							)
														lowerCamelCase__								=	inspect.signature(model.forward							)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowerCamelCase__								=	[*signature.parameters.keys()]

														lowerCamelCase__								=	["""pixel_values"""]
														self.assertListEqual(arg_names[:1] ,_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase							)






		@slow
		def       UpperCamelCase_       (   self							):
								for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__								=	ViTMSNModel.from_pretrained(_lowerCAmelCase							)
														self.assertIsNotNone(_lowerCAmelCase							)



def     A__      (					):
						lowerCamelCase__								=	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
						return image





@require_torch
@require_vision
class 		UpperCamelCase__     (unittest.TestCase      ):




		'''simple docstring'''





		@cached_property
		def       UpperCamelCase_       (   self							):
								return ViTImageProcessor.from_pretrained("""facebook/vit-msn-small"""							) if is_vision_available() else None






		@slow
		def       UpperCamelCase_       (   self							):
								torch.manual_seed(2							)
								lowerCamelCase__								=	ViTMSNForImageClassification.from_pretrained("""facebook/vit-msn-small"""							).to(_lowerCAmelCase							)

								lowerCamelCase__								=	self.default_image_processor
								lowerCamelCase__								=	prepare_img()
								lowerCamelCase__								=	image_processor(images=_lowerCAmelCase ,return_tensors="""pt"""							).to(_lowerCAmelCase							)

								# forward pass
								with torch.no_grad():
														lowerCamelCase__								=	model(**_lowerCAmelCase							)

								# verify the logits
								lowerCamelCase__								=	torch.Size((1, 10_00)							)
								self.assertEqual(outputs.logits.shape ,_lowerCAmelCase							)

								lowerCamelCase__								=	torch.tensor([-0.0803, -0.4454, -0.2375]							).to(_lowerCAmelCase							)

								self.assertTrue(torch.allclose(outputs.logits[0, :3] ,_lowerCAmelCase ,atol=1E-4							)							)




def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      return int((input_a, input_a).count(0   ) != 0   )







def 							_lowerCamelCase   (			):
      '''simple docstring'''







      assert nand_gate(0		,				0   ) == 1
      assert nand_gate(0		,				1   ) == 1
      assert nand_gate(1		,				0   ) == 1
      assert nand_gate(1		,				1   ) == 0


if __name__ == "__main__":
      print(nand_gate(0, 0))
      print(nand_gate(0, 1))
      print(nand_gate(1, 0))
      print(nand_gate(1, 1))





