




"""simple docstring"""







import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class       SCREAMING_SNAKE_CASE__					(					_a						,				unittest.TestCase					):
						_a    						=						RobertaTokenizer
						_a    						=						RobertaTokenizerFast
						_a    						=						True
						_a    						=						{'cls_token': '<s>'}


						def   __lowercase (							self				:			str					):
										super().setUp()

										# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
										lowerCAmelCase  =				[
										    """l""",
										    """o""",
										    """w""",
										    """e""",
										    """r""",
										    """s""",
										    """t""",
										    """i""",
										    """d""",
										    """n""",
										    """\u0120""",
										    """\u0120l""",
										    """\u0120n""",
										    """\u0120lo""",
										    """\u0120low""",
										    """er""",
										    """\u0120lowest""",
										    """\u0120newer""",
										    """\u0120wider""",
										    """<unk>""",
										]
										lowerCAmelCase  =				dict(zip(lowerCAmelCase						,						range(len(lowerCAmelCase					)					)					)					)
										lowerCAmelCase  =				["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
										lowerCAmelCase  =				{"""unk_token""": """<unk>"""}

										lowerCAmelCase  =				os.path.join(self.tmpdirname						,						VOCAB_FILES_NAMES["""vocab_file"""]					)
										lowerCAmelCase  =				os.path.join(self.tmpdirname						,						VOCAB_FILES_NAMES["""merges_file"""]					)
										with open(self.vocab_file						,						"""w"""						,						encoding="""utf-8"""					) as fp:
														fp.write(json.dumps(lowerCAmelCase					) + """\n"""					)
										with open(self.merges_file						,						"""w"""						,						encoding="""utf-8"""					) as fp:
														fp.write("""\n""".join(lowerCAmelCase					)					)


						def   __lowercase (							self				:			Optional[Any]						,						**lowerCAmelCase				:			List[Any]					):
										kwargs.update(self.special_tokens_map					)
										return self.tokenizer_class.from_pretrained(self.tmpdirname						,						**lowerCAmelCase					)


						def   __lowercase (							self				:			Dict						,						**lowerCAmelCase				:			List[str]					):
										kwargs.update(self.special_tokens_map					)
										return RobertaTokenizerFast.from_pretrained(self.tmpdirname						,						**lowerCAmelCase					)


						def   __lowercase (							self				:			Optional[int]						,						lowerCAmelCase				:			Dict					):
										lowerCAmelCase  =				"""lower newer"""
										lowerCAmelCase  =				"""lower newer"""
										return input_text, output_text


						def   __lowercase (							self				:			Any					):
										lowerCAmelCase  =				self.tokenizer_class(self.vocab_file						,						self.merges_file						,						**self.special_tokens_map					)
										lowerCAmelCase  =				"""lower newer"""
										lowerCAmelCase  =				["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
										lowerCAmelCase  =				tokenizer.tokenize(lowerCAmelCase					)  # , add_prefix_space=True)
										self.assertListEqual(lowerCAmelCase						,						lowerCAmelCase					)

										lowerCAmelCase  =				tokens + [tokenizer.unk_token]
										lowerCAmelCase  =				[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase					)						,						lowerCAmelCase					)


						def   __lowercase (							self				:			Union[str, Any]					):
										lowerCAmelCase  =				self.get_tokenizer()

										self.assertListEqual(tokenizer.encode("""Hello world!"""						,						add_special_tokens=lowerCAmelCase					)						,						[0, 3_1414, 232, 328, 2]					)
										self.assertListEqual(
										    tokenizer.encode("""Hello world! cécé herlolip 418"""						,						add_special_tokens=lowerCAmelCase					)						,						[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]						,						)


						@slow
						def   __lowercase (							self				:			int					):
										lowerCAmelCase  =				self.tokenizer_class.from_pretrained("""roberta-base"""					)

										lowerCAmelCase  =				tokenizer.encode("""sequence builders"""						,						add_special_tokens=lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.encode("""multi-sequence build"""						,						add_special_tokens=lowerCAmelCase					)

										lowerCAmelCase  =				tokenizer.encode(
										    """sequence builders"""						,						add_special_tokens=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.encode(
										    """sequence builders"""						,						"""multi-sequence build"""						,						add_special_tokens=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase					)

										lowerCAmelCase  =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase						,						lowerCAmelCase					)

										assert encoded_sentence == encoded_text_from_decode
										assert encoded_pair == encoded_pair_from_decode


						def   __lowercase (							self				:			int					):
										lowerCAmelCase  =				self.get_tokenizer()

										lowerCAmelCase  =				"""Encode this sequence."""
										lowerCAmelCase  =				tokenizer.byte_encoder[""" """.encode("""utf-8"""					)[0]]

										# Testing encoder arguments
										lowerCAmelCase  =				tokenizer.encode(lowerCAmelCase						,						add_special_tokens=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.convert_ids_to_tokens(encoded[0]					)[0]
										self.assertNotEqual(lowerCAmelCase						,						lowerCAmelCase					)

										lowerCAmelCase  =				tokenizer.encode(lowerCAmelCase						,						add_special_tokens=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.convert_ids_to_tokens(encoded[0]					)[0]
										self.assertEqual(lowerCAmelCase						,						lowerCAmelCase					)

										tokenizer.add_special_tokens({"""bos_token""": """<s>"""}					)
										lowerCAmelCase  =				tokenizer.encode(lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.convert_ids_to_tokens(encoded[1]					)[0]
										self.assertNotEqual(lowerCAmelCase						,						lowerCAmelCase					)

										# Testing spaces after special tokens
										lowerCAmelCase  =				"""<mask>"""
										tokenizer.add_special_tokens(
										    {"""mask_token""": AddedToken(lowerCAmelCase						,						lstrip=lowerCAmelCase						,						rstrip=lowerCAmelCase					)}					)  # mask token has a left space
										lowerCAmelCase  =				tokenizer.convert_tokens_to_ids(lowerCAmelCase					)

										lowerCAmelCase  =				"""Encode <mask> sequence"""
										lowerCAmelCase  =				"""Encode <mask>sequence"""

										lowerCAmelCase  =				tokenizer.encode(lowerCAmelCase					)
										lowerCAmelCase  =				encoded.index(lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]					)[0]
										self.assertEqual(lowerCAmelCase						,						lowerCAmelCase					)

										lowerCAmelCase  =				tokenizer.encode(lowerCAmelCase					)
										lowerCAmelCase  =				encoded.index(lowerCAmelCase					)
										lowerCAmelCase  =				tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]					)[0]
										self.assertNotEqual(lowerCAmelCase						,						lowerCAmelCase					)


						def   __lowercase (							self				:			List[str]					):
										pass


						def   __lowercase (							self				:			Any					):
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(lowerCAmelCase						,						**lowerCAmelCase					)
																		lowerCAmelCase  =				self.tokenizer_class.from_pretrained(lowerCAmelCase						,						**lowerCAmelCase					)
																		lowerCAmelCase  =				"""A, <mask> AllenNLP sentence."""
																		lowerCAmelCase  =				tokenizer_r.encode_plus(lowerCAmelCase						,						add_special_tokens=lowerCAmelCase						,						return_token_type_ids=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_p.encode_plus(lowerCAmelCase						,						add_special_tokens=lowerCAmelCase						,						return_token_type_ids=lowerCAmelCase					)

																		# token_type_ids should put 0 everywhere
																		self.assertEqual(sum(tokens_r["""token_type_ids"""]					)						,						sum(tokens_p["""token_type_ids"""]					)					)

																		# attention_mask should put 1 everywhere, so sum over length should be 1
																		self.assertEqual(
																		    sum(tokens_r["""attention_mask"""]					) / len(tokens_r["""attention_mask"""]					)						,						sum(tokens_p["""attention_mask"""]					) / len(tokens_p["""attention_mask"""]					)						,						)

																		lowerCAmelCase  =				tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]					)
																		lowerCAmelCase  =				tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]					)

																		# Rust correctly handles the space before the mask while python doesnt
																		self.assertSequenceEqual(tokens_p["""input_ids"""]						,						[0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]					)
																		self.assertSequenceEqual(tokens_r["""input_ids"""]						,						[0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]					)

																		self.assertSequenceEqual(
																		    lowerCAmelCase						,						["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]					)
																		self.assertSequenceEqual(
																		    lowerCAmelCase						,						["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]					)


						def   __lowercase (							self				:			Optional[Any]					):
										for trim_offsets, add_prefix_space in itertools.product([True, False]						,						repeat=2					):
														lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
														    self.tmpdirname						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)

														lowerCAmelCase  =				json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()					)
														lowerCAmelCase  =				json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()					)

														self.assertEqual(pre_tokenizer_state["""add_prefix_space"""]						,						lowerCAmelCase					)

														self.assertEqual(post_processor_state["""add_prefix_space"""]						,						lowerCAmelCase					)
														self.assertEqual(post_processor_state["""trim_offsets"""]						,						lowerCAmelCase					)




						def   __lowercase (							self				:			Optional[int]					):
										# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
										# `trim_offsets`
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
																		lowerCAmelCase  =				"""hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
																		lowerCAmelCase  =				f'''{text_of_1_token} {text_of_1_token}'''

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(len(lowerCAmelCase					) + 1, len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(len(lowerCAmelCase					) + 1, len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(len(lowerCAmelCase					), len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(len(lowerCAmelCase					), len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				f''' {text}'''

																		# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
																		#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
																		# )
																		# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
																		# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
																		# self.assertEqual(
																		#     encoding.offset_mapping[1],
																		#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
																		# )

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(1, 1 + len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(1 + len(lowerCAmelCase					) + 1, 1 + len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, 1 + len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(1 + len(lowerCAmelCase					), 1 + len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)

																		lowerCAmelCase  =				self.rust_tokenizer_class.from_pretrained(
																		    lowerCAmelCase						,						use_fast=lowerCAmelCase						,						add_prefix_space=lowerCAmelCase						,						trim_offsets=lowerCAmelCase					)
																		lowerCAmelCase  =				tokenizer_r(lowerCAmelCase						,						return_offsets_mapping=lowerCAmelCase						,						add_special_tokens=lowerCAmelCase					)
																		self.assertEqual(encoding.offset_mapping[0]						,						(0, 1 + len(lowerCAmelCase					))					)
																		self.assertEqual(
																		    encoding.offset_mapping[1]						,						(1 + len(lowerCAmelCase					), 1 + len(lowerCAmelCase					) + 1 + len(lowerCAmelCase					))						,						)









"""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       SCREAMING_SNAKE_CASE__					:


						def __init__(							self				:			List[Any]						,						lowerCAmelCase				:			Tuple						,						lowerCAmelCase				:			Optional[int]=13						,						lowerCAmelCase				:			List[str]=30						,						lowerCAmelCase				:			Dict=2						,						lowerCAmelCase				:			Any=3						,						lowerCAmelCase				:			str=True						,						lowerCAmelCase				:			List[Any]=True						,						lowerCAmelCase				:			Dict=32						,						lowerCAmelCase				:			Dict=5						,						lowerCAmelCase				:			str=4						,						lowerCAmelCase				:			List[Any]=37						,						lowerCAmelCase				:			List[Any]="gelu"						,						lowerCAmelCase				:			List[Any]=0.1						,						lowerCAmelCase				:			List[Any]=0.1						,						lowerCAmelCase				:			Optional[int]=10						,						lowerCAmelCase				:			List[str]=0.02						,						lowerCAmelCase				:			List[str]=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   __lowercase (							self				:			List[str]					):
										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   __lowercase (							self				:			Tuple					):
										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   __lowercase (							self				:			Any						,						lowerCAmelCase				:			Any						,						lowerCAmelCase				:			Tuple						,						lowerCAmelCase				:			Tuple					):
										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   __lowercase (							self				:			List[str]						,						lowerCAmelCase				:			int						,						lowerCAmelCase				:			str						,						lowerCAmelCase				:			int					):
										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   __lowercase (							self				:			Optional[Any]					):
										lowerCAmelCase  =				self.prepare_config_and_inputs()
										lowerCAmelCase ,						lowerCAmelCase ,						lowerCAmelCase  =				config_and_inputs
										lowerCAmelCase  =				{"""pixel_values""": pixel_values}
										return config, inputs_dict






@require_torch
class       SCREAMING_SNAKE_CASE__					(					_a						,				_a						,				unittest.TestCase					):
						_a    						=						(ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
						_a    						=						(
						    {'feature-extraction': ViTMSNModel, 'image-classification': ViTMSNForImageClassification}
						    if is_torch_available()
						    else {}
						)

						_a    						=						False
						_a    						=						False
						_a    						=						False
						_a    						=						False


						def   __lowercase (							self				:			Tuple					):
										lowerCAmelCase  =				ViTMSNModelTester(self					)
										lowerCAmelCase  =				ConfigTester(self						,						config_class=lowerCAmelCase						,						has_text_modality=lowerCAmelCase						,						hidden_size=37					)


						def   __lowercase (							self				:			Dict					):
										self.config_tester.run_common_tests()


						@unittest.skip(reason="""ViTMSN does not use inputs_embeds"""					)
						def   __lowercase (							self				:			Optional[Any]					):
										pass


						def   __lowercase (							self				:			int					):
										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   __lowercase (							self				:			Optional[int]					):
										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   __lowercase (							self				:			Union[str, Any]					):
										lowerCAmelCase  =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase					)


						def   __lowercase (							self				:			Union[str, Any]					):
										lowerCAmelCase  =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase					)




						@slow
						def   __lowercase (							self				:			Optional[Any]					):
										for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCAmelCase  =				ViTMSNModel.from_pretrained(lowerCAmelCase					)
														self.assertIsNotNone(lowerCAmelCase					)





def 							lowercase					()     ->  Dict:


				'''simple docstring'''






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






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


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




						@slow
						def   __lowercase (							self				:			Tuple					):
										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, 1000)					)
										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					)					)





