



"""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						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__=13						,	SCREAMING_SNAKE_CASE__=30						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=3						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=32						,	SCREAMING_SNAKE_CASE__=5						,	SCREAMING_SNAKE_CASE__=4						,	SCREAMING_SNAKE_CASE__=37						,	SCREAMING_SNAKE_CASE__="gelu"						,	SCREAMING_SNAKE_CASE__=0.1						,	SCREAMING_SNAKE_CASE__=0.1						,	SCREAMING_SNAKE_CASE__=10						,	SCREAMING_SNAKE_CASE__=0.0_2						,	SCREAMING_SNAKE_CASE__=None						,	)      ->	List[str]:
				A__											=					parent
				A__											=					batch_size
				A__											=					image_size
				A__											=					patch_size
				A__											=					num_channels
				A__											=					is_training
				A__											=					use_labels
				A__											=					hidden_size
				A__											=					num_hidden_layers
				A__											=					num_attention_heads
				A__											=					intermediate_size
				A__											=					hidden_act
				A__											=					hidden_dropout_prob
				A__											=					attention_probs_dropout_prob
				A__											=					type_sequence_label_size
				A__											=					initializer_range
				A__											=					scope

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


			def   snake_case__	(      self		)      ->	List[Any]:
				A__											=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

				A__											=					self.get_config()

				return config, pixel_values, labels


			def   snake_case__	(      self		)      ->	List[Any]:
				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   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)      ->	Dict:
				A__											=					ViTMSNModel(config=SCREAMING_SNAKE_CASE__		)
				model.to(SCREAMING_SNAKE_CASE__		)
				model.eval()
				A__											=					model(SCREAMING_SNAKE_CASE__		)
				self.parent.assertEqual(result.last_hidden_state.shape						,	(self.batch_size, self.seq_length, self.hidden_size)		)


			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)      ->	Any:
				A__											=					self.type_sequence_label_size
				A__											=					ViTMSNForImageClassification(SCREAMING_SNAKE_CASE__		)
				model.to(SCREAMING_SNAKE_CASE__		)
				model.eval()
				A__											=					model(SCREAMING_SNAKE_CASE__						,	labels=SCREAMING_SNAKE_CASE__		)
				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
				A__											=					1
				A__											=					ViTMSNForImageClassification(SCREAMING_SNAKE_CASE__		)
				model.to(SCREAMING_SNAKE_CASE__		)
				model.eval()

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







			def   snake_case__	(      self		)      ->	Optional[Any]:
				A__											=					self.prepare_config_and_inputs()
				A__							,							A__							,							A__											=					config_and_inputs
				A__											=					{"pixel_values": pixel_values}
				return config, inputs_dict






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

			"""simple docstring"""


			A__	:					List[str]							  =     (ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
			A__	:					List[Any]							  =     (
			    {"feature-extraction": ViTMSNModel, "image-classification": ViTMSNForImageClassification}
			    if is_torch_available()
			    else {}
			)

			A__	:					Dict							  =     False
			A__	:					Optional[int]							  =     False
			A__	:					Union[str, Any]							  =     False
			A__	:					int							  =     False


			def   snake_case__	(      self		)      ->	List[Any]:
				A__											=					ViTMSNModelTester(self		)
				A__											=					ConfigTester(self						,	config_class=SCREAMING_SNAKE_CASE__						,	has_text_modality=SCREAMING_SNAKE_CASE__						,	hidden_size=37		)


			def   snake_case__	(      self		)      ->	Dict:
				self.config_tester.run_common_tests()


			@unittest.skip(reason="ViTMSN does not use inputs_embeds"		)
			def   snake_case__	(      self		)      ->	List[Any]:
				pass


			def   snake_case__	(      self		)      ->	List[str]:
				A__							,							A__											=					self.model_tester.prepare_config_and_inputs_for_common()

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


			def   snake_case__	(      self		)      ->	Tuple:
				A__							,							A__											=					self.model_tester.prepare_config_and_inputs_for_common()

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

					A__											=					["pixel_values"]
					self.assertListEqual(arg_names[:1]						,	SCREAMING_SNAKE_CASE__		)


			def   snake_case__	(      self		)      ->	Any:
				A__											=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__		)


			def   snake_case__	(      self		)      ->	List[Any]:
				A__											=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__		)







			@slow
			def   snake_case__	(      self		)      ->	Tuple:
				for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					A__											=					ViTMSNModel.from_pretrained(SCREAMING_SNAKE_CASE__		)
					self.assertIsNotNone(SCREAMING_SNAKE_CASE__		)



def       _lowerCamelCase				(							)	-> str:






	"""simple docstring"""





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






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

			"""simple docstring"""


			@cached_property
			def   snake_case__	(      self		)      ->	List[Any]:
				return ViTImageProcessor.from_pretrained("facebook/vit-msn-small"		) if is_vision_available() else None







			@slow
			def   snake_case__	(      self		)      ->	Any:
				torch.manual_seed(2		)
				A__											=					ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-small"		).to(SCREAMING_SNAKE_CASE__		)

				A__											=					self.default_image_processor
				A__											=					prepare_img()
				A__											=					image_processor(images=SCREAMING_SNAKE_CASE__						,	return_tensors="pt"		).to(SCREAMING_SNAKE_CASE__		)

				# forward pass
				with torch.no_grad():
					A__											=					model(**SCREAMING_SNAKE_CASE__		)

				# verify the logits
				A__											=					torch.Size((1, 1000)		)
				self.assertEqual(outputs.logits.shape						,	SCREAMING_SNAKE_CASE__		)

				A__											=					torch.tensor([-0.0_8_0_3, -0.4_4_5_4, -0.2_3_7_5]		).to(SCREAMING_SNAKE_CASE__		)

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









"""simple docstring"""







import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class       UpperCamelCase__			(   unittest.TestCase      ):

			"""simple docstring"""


			def   snake_case__	(      self		)      ->	Dict:
				A__											=					["a", "b", "c"]

				# Defaults to last layer if both are None
				A__							,							A__											=					get_aligned_output_features_output_indices(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	["c"]		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	[2]		)

				# Out indices set to match out features
				A__							,							A__											=					get_aligned_output_features_output_indices(["a", "c"]						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	["a", "c"]		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	[0, 2]		)

				# Out features set to match out indices
				A__							,							A__											=					get_aligned_output_features_output_indices(SCREAMING_SNAKE_CASE__						,	[0, 2]						,	SCREAMING_SNAKE_CASE__		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	["a", "c"]		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	[0, 2]		)

				# Out features selected from negative indices
				A__							,							A__											=					get_aligned_output_features_output_indices(SCREAMING_SNAKE_CASE__						,	[-3, -1]						,	SCREAMING_SNAKE_CASE__		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	["a", "c"]		)
				self.assertEqual(SCREAMING_SNAKE_CASE__						,	[-3, -1]		)


			def   snake_case__	(      self		)      ->	Dict:
				# Stage names must be set
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(["a", "b"]						,	(0, 1)						,	SCREAMING_SNAKE_CASE__		)

				# Out features must be a list
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(("a", "b")						,	(0, 1)						,	["a", "b"]		)

				# Out features must be a subset of stage names
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(["a", "b"]						,	(0, 1)						,	["a"]		)

				# Out indices must be a list or tuple
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(SCREAMING_SNAKE_CASE__						,	0						,	["a", "b"]		)

				# Out indices must be a subset of stage names
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(SCREAMING_SNAKE_CASE__						,	(0, 1)						,	["a"]		)

				# Out features and out indices must be the same length
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(["a", "b"]						,	(0,)						,	["a", "b", "c"]		)

				# Out features should match out indices
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(["a", "b"]						,	(0, 2)						,	["a", "b", "c"]		)

				# Out features and out indices should be in order
				with self.assertRaises(SCREAMING_SNAKE_CASE__		):
					verify_out_features_out_indices(["b", "a"]						,	(0, 1)						,	["a", "b"]		)

				# Check passes with valid inputs
				verify_out_features_out_indices(["a", "b", "d"]						,	(0, 1, -1)						,	["a", "b", "c", "d"]		)







			def   snake_case__	(      self		)      ->	List[Any]:
				A__											=					BackboneMixin()

				A__											=					["a", "b", "c"]
				A__											=					["a", "c"]
				A__											=					[0, 2]

				# Check that the output features and indices are set correctly
				self.assertEqual(backbone.out_features						,	["a", "c"]		)
				self.assertEqual(backbone.out_indices						,	[0, 2]		)

				# Check out features and indices are updated correctly
				A__											=					["a", "b"]
				self.assertEqual(backbone.out_features						,	["a", "b"]		)
				self.assertEqual(backbone.out_indices						,	[0, 1]		)

				A__											=					[-3, -1]
				self.assertEqual(backbone.out_features						,	["a", "c"]		)
				self.assertEqual(backbone.out_indices						,	[-3, -1]		)




