



"""simple docstring"""

import collections
import inspect
import unittest

from transformers import FocalNetConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import (
							    FocalNetBackbone,
							    FocalNetForImageClassification,
							    FocalNetForMaskedImageModeling,
							    FocalNetModel,
							)
							from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor




class SCREAMING_SNAKE_CASE__					:



						def __init__(self						,     _lowercase						,     _lowercase=13						,     _lowercase=32						,     _lowercase=2						,     _lowercase=3						,     _lowercase=16						,     _lowercase=[32, 64, 128]						,     _lowercase=[1, 2, 1]						,     _lowercase=[2, 2, 4]						,     _lowercase=2						,     _lowercase=2.0						,     _lowercase=True						,     _lowercase=0.0						,     _lowercase=0.0						,     _lowercase=0.1						,     _lowercase="gelu"						,     _lowercase=False						,     _lowercase=True						,     _lowercase=0.02						,     _lowercase=1e-5						,     _lowercase=True						,     _lowercase=None						,     _lowercase=True						,     _lowercase=10						,     _lowercase=8						,     _lowercase=["stage1", "stage2"]						,     _lowercase=[1, 2]						,     ):





													'''simple docstring'''

													__a		:		Any									=       parent
													__a		:		Optional[Any]									=       batch_size
													__a		:		Tuple									=       image_size
													__a		:		Union[str, Any]									=       patch_size
													__a		:		Tuple									=       num_channels
													__a		:		Tuple									=       embed_dim
													__a		:		List[str]									=       hidden_sizes
													__a		:		int									=       depths
													__a		:		str									=       num_heads
													__a		:		Union[str, Any]									=       window_size
													__a		:		Tuple									=       mlp_ratio
													__a		:		List[Any]									=       qkv_bias
													__a		:		List[str]									=       hidden_dropout_prob
													__a		:		int									=       attention_probs_dropout_prob
													__a		:		Optional[int]									=       drop_path_rate
													__a		:		Optional[Any]									=       hidden_act
													__a		:		Any									=       use_absolute_embeddings
													__a		:		Dict									=       patch_norm
													__a		:		int									=       layer_norm_eps
													__a		:		Union[str, Any]									=       initializer_range
													__a		:		int									=       is_training
													__a		:		Optional[int]									=       scope
													__a		:		Any									=       use_labels
													__a		:		List[str]									=       type_sequence_label_size
													__a		:		List[Any]									=       encoder_stride
													__a		:		Union[str, Any]									=       out_features
													__a		:		Tuple									=       out_indices



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

													__a		:		Any									=       None
													if self.use_labels:
																				__a		:		str									=       ids_tensor([self.batch_size]						,     self.type_sequence_label_size							)

													__a		:		int									=       self.get_config()

													return config, pixel_values, labels



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return FocalNetConfig(
													    image_size=self.image_size						,     patch_size=self.patch_size						,     num_channels=self.num_channels						,     embed_dim=self.embed_dim						,     hidden_sizes=self.hidden_sizes						,     depths=self.depths						,     num_heads=self.num_heads						,     window_size=self.window_size						,     mlp_ratio=self.mlp_ratio						,     qkv_bias=self.qkv_bias						,     hidden_dropout_prob=self.hidden_dropout_prob						,     attention_probs_dropout_prob=self.attention_probs_dropout_prob						,     drop_path_rate=self.drop_path_rate						,     hidden_act=self.hidden_act						,     use_absolute_embeddings=self.use_absolute_embeddings						,     path_norm=self.patch_norm						,     layer_norm_eps=self.layer_norm_eps						,     initializer_range=self.initializer_range						,     encoder_stride=self.encoder_stride						,     out_features=self.out_features						,     out_indices=self.out_indices						,     )



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		str									=       FocalNetModel(config=__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()
													__a		:		str									=       model(__SCREAMING_SNAKE_CASE							)

													__a		:		List[Any]									=       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
													__a		:		str									=       int(config.embed_dim * 2 ** (len(config.depths							) - 1)							)

													self.parent.assertEqual(result.last_hidden_state.shape						,     (self.batch_size, expected_seq_len, expected_dim)							)



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		List[Any]									=       FocalNetBackbone(config=__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()
													__a		:		Optional[int]									=       model(__SCREAMING_SNAKE_CASE							)

													# verify feature maps
													self.parent.assertEqual(len(result.feature_maps							)						,     len(config.out_features							)							)
													self.parent.assertListEqual(list(result.feature_maps[0].shape							)						,     [self.batch_size, self.image_size, 8, 8]							)

													# verify channels
													self.parent.assertEqual(len(model.channels							)						,     len(config.out_features							)							)
													self.parent.assertListEqual(model.channels						,     config.hidden_sizes[:-1]							)

													# verify backbone works with out_features=None
													__a		:		List[str]									=       None
													__a		:		Optional[int]									=       FocalNetBackbone(config=__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()
													__a		:		List[str]									=       model(__SCREAMING_SNAKE_CASE							)

													# verify feature maps
													self.parent.assertEqual(len(result.feature_maps							)						,     1							)
													self.parent.assertListEqual(list(result.feature_maps[0].shape							)						,     [self.batch_size, self.image_size * 2, 4, 4]							)

													# verify channels
													self.parent.assertEqual(len(model.channels							)						,     1							)
													self.parent.assertListEqual(model.channels						,     [config.hidden_sizes[-1]]							)



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		Any									=       FocalNetForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()
													__a		:		List[Any]									=       model(__SCREAMING_SNAKE_CASE							)
													self.parent.assertEqual(
													    result.reconstruction.shape						,     (self.batch_size, self.num_channels, self.image_size, self.image_size)							)

													# test greyscale images
													__a		:		Optional[Any]									=       1
													__a		:		Union[str, Any]									=       FocalNetForMaskedImageModeling(__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()

													__a		:		str									=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
													__a		:		Union[str, Any]									=       model(__SCREAMING_SNAKE_CASE							)
													self.parent.assertEqual(result.reconstruction.shape						,     (self.batch_size, 1, self.image_size, self.image_size)							)



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		str									=       self.type_sequence_label_size
													__a		:		int									=       FocalNetForImageClassification(__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()
													__a		:		Optional[Any]									=       model(__SCREAMING_SNAKE_CASE						,     labels=__SCREAMING_SNAKE_CASE							)
													self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.type_sequence_label_size)							)

													# test greyscale images
													__a		:		Dict									=       1
													__a		:		Optional[int]									=       FocalNetForImageClassification(__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()

													__a		:		List[str]									=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
													__a		:		Optional[Any]									=       model(__SCREAMING_SNAKE_CASE							)
													self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.type_sequence_label_size)							)





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Optional[Any]									=       self.prepare_config_and_inputs()

													__a							,     __a							,     __a		:		Dict									=       config_and_inputs
													__a		:		Tuple									=       {"""pixel_values""": pixel_values}
													return config, inputs_dict







@require_torch
class SCREAMING_SNAKE_CASE__					(		__UpperCAmelCase     ,					__UpperCAmelCase     ,					unittest.TestCase      ):
						_lowerCAmelCase							=					(
						    (
						        FocalNetModel,
						        FocalNetForImageClassification,
						        FocalNetForMaskedImageModeling,
						        FocalNetBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						_lowerCAmelCase							=					(
						    {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
						    if is_torch_available()
						    else {}
						)
						_lowerCAmelCase							=					False

						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Union[str, Any]									=       FocalNetModelTester(self							)
													__a		:		Union[str, Any]									=       ConfigTester(self						,     config_class=__SCREAMING_SNAKE_CASE						,     embed_dim=37						,     has_text_modality=__SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													self.create_and_test_config_common_properties()
													self.config_tester.create_and_test_config_to_json_string()
													self.config_tester.create_and_test_config_to_json_file()
													self.config_tester.create_and_test_config_from_and_save_pretrained()
													self.config_tester.create_and_test_config_with_num_labels()
													self.config_tester.check_config_can_be_init_without_params()
													self.config_tester.check_config_arguments_init()



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Any									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		str									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[Any]									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Optional[Any]									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE							)



						@unittest.skip(reason="""FocalNet does not use inputs_embeds"""							)
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													pass



						@unittest.skip(reason="""FocalNet does not use feedforward chunking"""							)
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													pass



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		int									=       self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes[:-1]:
																				__a		:		str									=       model_class(__SCREAMING_SNAKE_CASE							)
																				self.assertIsInstance(model.get_input_embeddings()						,     (nn.Module)							)
																				__a		:		List[str]									=       model.get_output_embeddings()
																				self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE						,     nn.Linear							)							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Union[str, Any]									=       self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes[:-1]:
																				__a		:		List[str]									=       model_class(__SCREAMING_SNAKE_CASE							)
																				__a		:		Optional[int]									=       inspect.signature(model.forward							)
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				__a		:		Optional[Any]									=       [*signature.parameters.keys()]

																				__a		:		Optional[Any]									=       ["""pixel_values"""]
																				self.assertListEqual(arg_names[:1]						,     __SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		int									=       model_class(__SCREAMING_SNAKE_CASE							)
													model.to(__SCREAMING_SNAKE_CASE							)
													model.eval()

													with torch.no_grad():
																				__a		:		List[str]									=       model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE							)							)

													__a		:		Union[str, Any]									=       outputs.hidden_states

													__a		:		List[str]									=       getattr(
													    self.model_tester						,     """expected_num_hidden_layers"""						,     len(self.model_tester.depths							) + 1							)
													self.assertEqual(len(__SCREAMING_SNAKE_CASE							)						,     __SCREAMING_SNAKE_CASE							)

													# FocalNet has a different seq_length
													__a		:		Tuple									=       (
													    config.patch_size
													    if isinstance(config.patch_size						,     collections.abc.Iterable							)
													    else (config.patch_size, config.patch_size)
													)

													__a		:		Tuple									=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]							)						,     [num_patches, self.model_tester.embed_dim]						,     )

													__a		:		Dict									=       outputs.reshaped_hidden_states
													self.assertEqual(len(__SCREAMING_SNAKE_CASE							)						,     __SCREAMING_SNAKE_CASE							)

													__a							,     __a							,     __a							,     __a		:		Dict									=       reshaped_hidden_states[0].shape
													__a		:		List[Any]									=       (
													    reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     height * width							).permute(0						,     2						,     1							)
													)
													self.assertListEqual(
													    list(reshaped_hidden_states.shape[-2:]							)						,     [num_patches, self.model_tester.embed_dim]						,     )



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Optional[Any]									=       self.model_tester.prepare_config_and_inputs_for_common()

													__a		:		Dict									=       (
													    self.model_tester.image_size
													    if isinstance(self.model_tester.image_size						,     collections.abc.Iterable							)
													    else (self.model_tester.image_size, self.model_tester.image_size)
													)

													for model_class in self.all_model_classes[:-1]:
																				__a		:		Dict									=       True
																				self.check_hidden_states_output(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE							)

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				__a		:		Any									=       True

																				self.check_hidden_states_output(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Tuple									=       self.model_tester.prepare_config_and_inputs_for_common()
													__a		:		Optional[int]									=       3

													__a		:		Union[str, Any]									=       (
													    self.model_tester.image_size
													    if isinstance(self.model_tester.image_size						,     collections.abc.Iterable							)
													    else (self.model_tester.image_size, self.model_tester.image_size)
													)
													__a		:		List[Any]									=       (
													    config.patch_size
													    if isinstance(config.patch_size						,     collections.abc.Iterable							)
													    else (config.patch_size, config.patch_size)
													)

													__a		:		Dict									=       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
													__a		:		List[str]									=       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

													for model_class in self.all_model_classes[:-1]:
																				__a		:		Dict									=       True
																				self.check_hidden_states_output(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     (padded_height, padded_width)							)

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				__a		:		List[Any]									=       True
																				self.check_hidden_states_output(__SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     __SCREAMING_SNAKE_CASE						,     (padded_height, padded_width)							)



						@slow
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__a		:		List[str]									=       FocalNetModel.from_pretrained(__SCREAMING_SNAKE_CASE							)
																				self.assertIsNotNone(__SCREAMING_SNAKE_CASE							)





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Dict									=       self.model_tester.prepare_config_and_inputs_for_common()

													__a		:		List[Any]									=       _config_zero_init(__SCREAMING_SNAKE_CASE							)
													for model_class in self.all_model_classes:
																				__a		:		int									=       model_class(config=__SCREAMING_SNAKE_CASE							)
																				for name, param in model.named_parameters():
																											if "embeddings" not in name and param.requires_grad:
																																		self.assertIn(
																																		    ((param.data.mean() * 1e9).round() / 1e9).item()						,     [0.0, 1.0]						,     msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''						,     )







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



						@cached_property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""							) if is_vision_available() else None





						@slow
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Any									=       FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""							).to(__SCREAMING_SNAKE_CASE							)
													__a		:		Any									=       self.default_image_processor

													__a		:		List[str]									=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
													__a		:		Any									=       image_processor(images=__SCREAMING_SNAKE_CASE						,     return_tensors="""pt"""							).to(__SCREAMING_SNAKE_CASE							)

													# forward pass
													with torch.no_grad():
																				__a		:		Optional[Any]									=       model(**__SCREAMING_SNAKE_CASE							)

													# verify the logits
													__a		:		int									=       torch.Size((1, 1000)							)
													self.assertEqual(outputs.logits.shape						,     __SCREAMING_SNAKE_CASE							)
													__a		:		int									=       torch.tensor([0.2166, -0.4368, 0.2191]							).to(__SCREAMING_SNAKE_CASE							)
													self.assertTrue(torch.allclose(outputs.logits[0, :3]						,     __SCREAMING_SNAKE_CASE						,     atol=1e-4							)							)
													self.assertTrue(outputs.logits.argmax(dim=-1							).item()						,     281							)







@require_torch
class SCREAMING_SNAKE_CASE__					(		__UpperCAmelCase     ,					unittest.TestCase      ):
						_lowerCAmelCase							=					(FocalNetBackbone,) if is_torch_available() else ()
						_lowerCAmelCase							=					FocalNetConfig

						_lowerCAmelCase							=					False



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Optional[Any]									=       FocalNetModelTester(self							)






"""simple docstring"""

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__			   =  logging.get_logger(__name__)

lowercase__			   =  {
    "sayakpaul/vit-msn-base": "https://huggingface.co/sayakpaul/vit-msn-base/resolve/main/config.json",
    # See all ViT MSN models at https://huggingface.co/models?filter=vit_msn
}




class SCREAMING_SNAKE_CASE__					(		__snake_case      ):
						_lowerCAmelCase							=					"vit_msn"



						def __init__(self						,     _lowercase=768						,     _lowercase=12						,     _lowercase=12						,     _lowercase=3072						,     _lowercase="gelu"						,     _lowercase=0.0						,     _lowercase=0.0						,     _lowercase=0.02						,     _lowercase=1e-06						,     _lowercase=224						,     _lowercase=16						,     _lowercase=3						,     _lowercase=True						,     **_lowercase						,     ):





													'''simple docstring'''

													super().__init__(**_lowercase							)

													__a		:		int									=       hidden_size
													__a		:		str									=       num_hidden_layers
													__a		:		str									=       num_attention_heads
													__a		:		Optional[Any]									=       intermediate_size
													__a		:		Union[str, Any]									=       hidden_act
													__a		:		Tuple									=       hidden_dropout_prob
													__a		:		Any									=       attention_probs_dropout_prob
													__a		:		List[Any]									=       initializer_range
													__a		:		Any									=       layer_norm_eps
													__a		:		Dict									=       image_size
													__a		:		List[Any]									=       patch_size
													__a		:		Dict									=       num_channels
													__a		:		Optional[Any]									=       qkv_bias

