





import collections
import inspect
import unittest

from transformers import SwinvaConfig
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, _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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
   from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor

class 					A     :



      def __init__(       self  ,	lowercase_  ,	lowercase_=13  ,	lowercase_=32  ,	lowercase_=2  ,	lowercase_=3  ,	lowercase_=16  ,	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  ,	)   -> List[Any]:



             '''simple docstring'''

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



      def  __a			(       self       )   -> str:



             '''simple docstring'''

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

             _snake_case   :				Optional[int]  					=    None
             if self.use_labels:
                    _snake_case   :				Tuple  					=    ids_tensor([self.batch_size]  ,	self.type_sequence_label_size       )

             _snake_case   :				int  					=    self.get_config()

             return config, pixel_values, labels



      def  __a			(       self       )   -> List[Any]:



             '''simple docstring'''

             return SwinvaConfig(
                 image_size=self.image_size  ,	patch_size=self.patch_size  ,	num_channels=self.num_channels  ,	embed_dim=self.embed_dim  ,	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  ,	)



      def  __a			(       self  ,	lowercase_  ,	lowercase_  ,	lowercase_       )   -> List[Any]:



             '''simple docstring'''

             _snake_case   :				Optional[Any]  					=    SwinvaModel(config=_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             _snake_case   :				List[str]  					=    model(_UpperCAmelCase       )

             _snake_case   :				Union[str, Any]  					=    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths       ) - 1))
             _snake_case   :				List[Any]  					=    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  __a			(       self  ,	lowercase_  ,	lowercase_  ,	lowercase_       )   -> List[Any]:



             '''simple docstring'''

             _snake_case   :				int  					=    SwinvaForMaskedImageModeling(config=_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             _snake_case   :				Optional[int]  					=    model(_UpperCAmelCase       )
             self.parent.assertEqual(
                 result.logits.shape  ,	(self.batch_size, self.num_channels, self.image_size, self.image_size)       )

             # test greyscale images
             _snake_case   :				str  					=    1
             _snake_case   :				Any  					=    SwinvaForMaskedImageModeling(_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()

             _snake_case   :				Optional[Any]  					=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
             _snake_case   :				int  					=    model(_UpperCAmelCase       )
             self.parent.assertEqual(result.logits.shape  ,	(self.batch_size, 1, self.image_size, self.image_size)       )



      def  __a			(       self  ,	lowercase_  ,	lowercase_  ,	lowercase_       )   -> Union[str, Any]:



             '''simple docstring'''

             _snake_case   :				List[Any]  					=    self.type_sequence_label_size
             _snake_case   :				Dict  					=    SwinvaForImageClassification(_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             _snake_case   :				List[Any]  					=    model(_UpperCAmelCase  ,	labels=_UpperCAmelCase       )
             self.parent.assertEqual(result.logits.shape  ,	(self.batch_size, self.type_sequence_label_size)       )



      def  __a			(       self       )   -> Optional[int]:



             '''simple docstring'''

             _snake_case   :				str  					=    self.prepare_config_and_inputs()
             _snake_case					,     _snake_case					,     _snake_case   :				Tuple  					=    config_and_inputs
             _snake_case   :				Tuple  					=    {'''pixel_values''': pixel_values}
             return config, inputs_dict


@require_torch
class 					A     (snake_case__							,snake_case__							,unittest.TestCase					):
      _SCREAMING_SNAKE_CASE       =				(
          (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
      )
      _SCREAMING_SNAKE_CASE       =				(
          {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
          if is_torch_available()
          else {}
      )

      _SCREAMING_SNAKE_CASE       =				False
      _SCREAMING_SNAKE_CASE       =				False
      _SCREAMING_SNAKE_CASE       =				False
      _SCREAMING_SNAKE_CASE       =				False



      def  __a			(       self       )   -> List[str]:



             '''simple docstring'''

             _snake_case   :				Tuple  					=    SwinvaModelTester(self       )
             _snake_case   :				str  					=    ConfigTester(self  ,	config_class=_UpperCAmelCase  ,	embed_dim=37       )



      def  __a			(       self       )   -> Any:



             '''simple docstring'''

             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  __a			(       self       )   -> Tuple:



             '''simple docstring'''

             _snake_case   :				List[Any]  					=    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*_UpperCAmelCase       )



      @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''       )
      def  __a			(       self       )   -> List[str]:



             '''simple docstring'''

             pass



      @unittest.skip(reason='''Swinv2 does not use inputs_embeds'''       )
      def  __a			(       self       )   -> Optional[Any]:



             '''simple docstring'''

             pass



      def  __a			(       self       )   -> str:



             '''simple docstring'''

             _snake_case					,     _snake_case   :				Optional[int]  					=    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    _snake_case   :				Dict  					=    model_class(_UpperCAmelCase       )
                    self.assertIsInstance(model.get_input_embeddings()  ,	(nn.Module)       )
                    _snake_case   :				List[Any]  					=    model.get_output_embeddings()
                    self.assertTrue(x is None or isinstance(_UpperCAmelCase  ,	nn.Linear       )       )



      def  __a			(       self       )   -> List[str]:



             '''simple docstring'''

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

             for model_class in self.all_model_classes:
                    _snake_case   :				Optional[int]  					=    model_class(_UpperCAmelCase       )
                    _snake_case   :				str  					=    inspect.signature(model.forward       )
                    # signature.parameters is an OrderedDict => so arg_names order is deterministic
                    _snake_case   :				Union[str, Any]  					=    [*signature.parameters.keys()]

                    _snake_case   :				Dict  					=    ['''pixel_values''']
                    self.assertListEqual(arg_names[:1]  ,	_UpperCAmelCase       )



      def  __a			(       self       )   -> List[Any]:



             '''simple docstring'''

             _snake_case					,     _snake_case   :				Tuple  					=    self.model_tester.prepare_config_and_inputs_for_common()
             _snake_case   :				str  					=    True

             for model_class in self.all_model_classes:
                    _snake_case   :				Union[str, Any]  					=    True
                    _snake_case   :				Optional[int]  					=    False
                    _snake_case   :				Any  					=    True
                    _snake_case   :				str  					=    model_class(_UpperCAmelCase       )
                    model.to(_UpperCAmelCase       )
                    model.eval()
                    with torch.no_grad():
                           _snake_case   :				Tuple  					=    model(**self._prepare_for_class(_UpperCAmelCase  ,	_UpperCAmelCase       )       )
                    _snake_case   :				Tuple  					=    outputs.attentions
                    _snake_case   :				List[str]  					=    len(self.model_tester.depths       )
                    self.assertEqual(len(_UpperCAmelCase       )  ,	_UpperCAmelCase       )

                    # check that output_attentions also work using config
                    del inputs_dict["output_attentions"]
                    _snake_case   :				Optional[int]  					=    True
                    _snake_case   :				List[str]  					=    config.window_size**2
                    _snake_case   :				Dict  					=    model_class(_UpperCAmelCase       )
                    model.to(_UpperCAmelCase       )
                    model.eval()
                    with torch.no_grad():
                           _snake_case   :				Optional[Any]  					=    model(**self._prepare_for_class(_UpperCAmelCase  ,	_UpperCAmelCase       )       )
                    _snake_case   :				str  					=    outputs.attentions
                    self.assertEqual(len(_UpperCAmelCase       )  ,	_UpperCAmelCase       )

                    self.assertListEqual(
                        list(attentions[0].shape[-3:]       )  ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,	)
                    _snake_case   :				Tuple  					=    len(_UpperCAmelCase       )

                    # Check attention is always last and order is fine
                    _snake_case   :				Tuple  					=    True
                    _snake_case   :				Any  					=    True
                    _snake_case   :				Optional[Any]  					=    model_class(_UpperCAmelCase       )
                    model.to(_UpperCAmelCase       )
                    model.eval()
                    with torch.no_grad():
                           _snake_case   :				int  					=    model(**self._prepare_for_class(_UpperCAmelCase  ,	_UpperCAmelCase       )       )

                    if hasattr(self.model_tester  ,	'''num_hidden_states_types'''       ):
                           _snake_case   :				List[str]  					=    self.model_tester.num_hidden_states_types
                    else:
                           # also another +1 for reshaped_hidden_states
                           _snake_case   :				str  					=    2
                    self.assertEqual(out_len + added_hidden_states  ,	len(_UpperCAmelCase       )       )

                    _snake_case   :				Optional[int]  					=    outputs.attentions

                    self.assertEqual(len(_UpperCAmelCase       )  ,	_UpperCAmelCase       )

                    self.assertListEqual(
                        list(self_attentions[0].shape[-3:]       )  ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,	)



      def  __a			(       self  ,	lowercase_  ,	lowercase_  ,	lowercase_  ,	lowercase_       )   -> List[Any]:



             '''simple docstring'''

             _snake_case   :				str  					=    model_class(_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()

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

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

             _snake_case   :				Any  					=    getattr(
                 self.model_tester  ,	'''expected_num_hidden_layers'''  ,	len(self.model_tester.depths       ) + 1       )
             self.assertEqual(len(_UpperCAmelCase       )  ,	_UpperCAmelCase       )

             # Swinv2 has a different seq_length
             _snake_case   :				List[str]  					=    (
                 config.patch_size
                 if isinstance(config.patch_size  ,	collections.abc.Iterable       )
                 else (config.patch_size, config.patch_size)
             )

             _snake_case   :				Union[str, Any]  					=    (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]  ,	)

             _snake_case   :				Optional[int]  					=    outputs.reshaped_hidden_states
             self.assertEqual(len(_UpperCAmelCase       )  ,	_UpperCAmelCase       )

             _snake_case					,     _snake_case					,     _snake_case					,     _snake_case   :				str  					=    reshaped_hidden_states[0].shape
             _snake_case   :				Optional[int]  					=    (
                 reshaped_hidden_states[0].view(_UpperCAmelCase  ,	_UpperCAmelCase  ,	height * width       ).permute(0  ,	2  ,	1       )
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-2:]       )  ,	[num_patches, self.model_tester.embed_dim]  ,	)



      def  __a			(       self       )   -> List[str]:



             '''simple docstring'''

             _snake_case					,     _snake_case   :				str  					=    self.model_tester.prepare_config_and_inputs_for_common()

             _snake_case   :				int  					=    (
                 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:
                    _snake_case   :				Optional[Any]  					=    True
                    self.check_hidden_states_output(_UpperCAmelCase  ,	_UpperCAmelCase  ,	_UpperCAmelCase  ,	_UpperCAmelCase       )

                    # check that output_hidden_states also work using config
                    del inputs_dict["output_hidden_states"]
                    _snake_case   :				Optional[int]  					=    True

                    self.check_hidden_states_output(_UpperCAmelCase  ,	_UpperCAmelCase  ,	_UpperCAmelCase  ,	_UpperCAmelCase       )



      def  __a			(       self       )   -> str:



             '''simple docstring'''

             _snake_case					,     _snake_case   :				Dict  					=    self.model_tester.prepare_config_and_inputs_for_common()
             _snake_case   :				Optional[Any]  					=    3

             _snake_case   :				Optional[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)
             )
             _snake_case   :				str  					=    (
                 config.patch_size
                 if isinstance(config.patch_size  ,	collections.abc.Iterable       )
                 else (config.patch_size, config.patch_size)
             )

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

             for model_class in self.all_model_classes:
                    _snake_case   :				Optional[int]  					=    True
                    self.check_hidden_states_output(_UpperCAmelCase  ,	_UpperCAmelCase  ,	_UpperCAmelCase  ,	(padded_height, padded_width)       )

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



      def  __a			(       self       )   -> Optional[int]:



             '''simple docstring'''

             _snake_case   :				Union[str, Any]  					=    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase       )



      def  __a			(       self       )   -> Any:



             '''simple docstring'''

             _snake_case   :				Optional[Any]  					=    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase       )



      @slow
      def  __a			(       self       )   -> Dict:



             '''simple docstring'''

             for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _snake_case   :				Optional[Any]  					=    SwinvaModel.from_pretrained(_UpperCAmelCase       )
                    self.assertIsNotNone(_UpperCAmelCase       )



      def  __a			(       self       )   -> List[str]:



             '''simple docstring'''

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

             _snake_case   :				Union[str, Any]  					=    _config_zero_init(_UpperCAmelCase       )
             for model_class in self.all_model_classes:
                    _snake_case   :				Union[str, Any]  					=    model_class(config=_UpperCAmelCase       )
                    for name, param in model.named_parameters():
                           if "embeddings" not in name and "logit_scale" 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 					A     (unittest.TestCase					):



      @cached_property
      def  __a			(       self       )   -> List[Any]:



             '''simple docstring'''

             return (
                 AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''       )
                 if is_vision_available()
                 else None
             )



      @slow
      def  __a			(       self       )   -> List[Any]:



             '''simple docstring'''

             _snake_case   :				Dict  					=    SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''       ).to(
                 _UpperCAmelCase       )
             _snake_case   :				Dict  					=    self.default_image_processor

             _snake_case   :				Tuple  					=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
             _snake_case   :				List[Any]  					=    image_processor(images=_UpperCAmelCase  ,	return_tensors='''pt'''       ).to(_UpperCAmelCase       )

             # forward pass
             with torch.no_grad():
                    _snake_case   :				Dict  					=    model(**_UpperCAmelCase       )

             # verify the logits
             _snake_case   :				Optional[int]  					=    torch.Size((1, 1000)       )
             self.assertEqual(outputs.logits.shape  ,	_UpperCAmelCase       )
             _snake_case   :				int  					=    torch.tensor([-0.3947, -0.4306, 0.0026]       ).to(_UpperCAmelCase       )
             self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,	_UpperCAmelCase  ,	atol=1E-4       )       )











'''simple docstring'''

from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


SCREAMING_SNAKE_CASE__     :						Tuple	=  {'''configuration_van''': ['''VAN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VanConfig''']}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			SCREAMING_SNAKE_CASE__     :						List[str]	=  [
			    '''VAN_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''VanForImageClassification''',
			    '''VanModel''',
			    '''VanPreTrainedModel''',
			]

if TYPE_CHECKING:
			from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_van import (
						    VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
						    VanForImageClassification,
						    VanModel,
						    VanPreTrainedModel,
						)

else:
			import sys

			SCREAMING_SNAKE_CASE__     :						Dict	=  _LazyModule(__name__, globals()['''__file__'''], _import_structure)




