





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 			UpperCamelCase_		:




     def __init__(		self				,						lowerCAmelCase_				,						lowerCAmelCase_=13				,						lowerCAmelCase_=32				,						lowerCAmelCase_=2				,						lowerCAmelCase_=3				,						lowerCAmelCase_=16				,						lowerCAmelCase_=[1, 2, 1]				,						lowerCAmelCase_=[2, 2, 4]				,						lowerCAmelCase_=2				,						lowerCAmelCase_=2.0				,						lowerCAmelCase_=True				,						lowerCAmelCase_=0.0				,						lowerCAmelCase_=0.0				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_="gelu"				,						lowerCAmelCase_=False				,						lowerCAmelCase_=True				,						lowerCAmelCase_=0.02				,						lowerCAmelCase_=1E-5				,						lowerCAmelCase_=True				,						lowerCAmelCase_=None				,						lowerCAmelCase_=True				,						lowerCAmelCase_=10				,						lowerCAmelCase_=8				,						)		->							Tuple:
          _snake_case									=				parent
          _snake_case									=				batch_size
          _snake_case									=				image_size
          _snake_case									=				patch_size
          _snake_case									=				num_channels
          _snake_case									=				embed_dim
          _snake_case									=				depths
          _snake_case									=				num_heads
          _snake_case									=				window_size
          _snake_case									=				mlp_ratio
          _snake_case									=				qkv_bias
          _snake_case									=				hidden_dropout_prob
          _snake_case									=				attention_probs_dropout_prob
          _snake_case									=				drop_path_rate
          _snake_case									=				hidden_act
          _snake_case									=				use_absolute_embeddings
          _snake_case									=				patch_norm
          _snake_case									=				layer_norm_eps
          _snake_case									=				initializer_range
          _snake_case									=				is_training
          _snake_case									=				scope
          _snake_case									=				use_labels
          _snake_case									=				type_sequence_label_size
          _snake_case									=				encoder_stride




     def 	lowerCAmelCase			(		self  )		->							Optional[int]:
          _snake_case									=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

          _snake_case									=				self.get_config()

          return config, pixel_values, labels




     def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
          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 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Union[str, Any]:
          _snake_case									=				SwinvaModel(config=lowerCAmelCase_  )
          model.to(lowerCAmelCase_  )
          model.eval()
          _snake_case									=				model(lowerCAmelCase_  )

          _snake_case									=				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
          _snake_case									=				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				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							List[Any]:
          _snake_case									=				SwinvaForMaskedImageModeling(config=lowerCAmelCase_  )
          model.to(lowerCAmelCase_  )
          model.eval()
          _snake_case									=				model(lowerCAmelCase_  )
          self.parent.assertEqual(
              result.logits.shape				,						(self.batch_size, self.num_channels, self.image_size, self.image_size)  )

          # test greyscale images
          _snake_case									=				1
          _snake_case									=				SwinvaForMaskedImageModeling(lowerCAmelCase_  )
          model.to(lowerCAmelCase_  )
          model.eval()

          _snake_case									=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
          _snake_case									=				model(lowerCAmelCase_  )
          self.parent.assertEqual(result.logits.shape				,						(self.batch_size, 1, self.image_size, self.image_size)  )




     def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Optional[int]:
          _snake_case									=				self.type_sequence_label_size
          _snake_case									=				SwinvaForImageClassification(lowerCAmelCase_  )
          model.to(lowerCAmelCase_  )
          model.eval()
          _snake_case									=				model(lowerCAmelCase_				,						labels=lowerCAmelCase_  )
          self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)  )






     def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
          _snake_case									=				self.prepare_config_and_inputs()
          _snake_case							,     _snake_case							,     _snake_case									=				config_and_inputs
          _snake_case									=				{'pixel_values': pixel_values}
          return config, inputs_dict





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

     lowerCAmelCase_							=	False
     lowerCAmelCase_							=	False
     lowerCAmelCase_							=	False
     lowerCAmelCase_							=	False




     def 	lowerCAmelCase			(		self  )		->							Any:
          _snake_case									=				SwinvaModelTester(self  )
          _snake_case									=				ConfigTester(self				,						config_class=lowerCAmelCase_				,						embed_dim=37  )




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




     @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'  )
     def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
          pass




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




     def 	lowerCAmelCase			(		self  )		->							Dict:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

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




     def 	lowerCAmelCase			(		self  )		->							Optional[int]:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

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

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




     def 	lowerCAmelCase			(		self  )		->							Dict:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case									=				True

          for model_class in self.all_model_classes:
               _snake_case									=				True
               _snake_case									=				False
               _snake_case									=				True
               _snake_case									=				model_class(lowerCAmelCase_  )
               model.to(lowerCAmelCase_  )
               model.eval()
               with torch.no_grad():
                    _snake_case									=				model(**self._prepare_for_class(lowerCAmelCase_				,						lowerCAmelCase_  )  )
               _snake_case									=				outputs.attentions
               _snake_case									=				len(self.model_tester.depths  )
               self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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

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

               # Check attention is always last and order is fine
               _snake_case									=				True
               _snake_case									=				True
               _snake_case									=				model_class(lowerCAmelCase_  )
               model.to(lowerCAmelCase_  )
               model.eval()
               with torch.no_grad():
                    _snake_case									=				model(**self._prepare_for_class(lowerCAmelCase_				,						lowerCAmelCase_  )  )

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

               _snake_case									=				outputs.attentions

               self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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




     def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Any:
          _snake_case									=				model_class(lowerCAmelCase_  )
          model.to(lowerCAmelCase_  )
          model.eval()

          with torch.no_grad():
               _snake_case									=				model(**self._prepare_for_class(lowerCAmelCase_				,						lowerCAmelCase_  )  )

          _snake_case									=				outputs.hidden_states

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

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

          _snake_case									=				(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									=				outputs.reshaped_hidden_states
          self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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




     def 	lowerCAmelCase			(		self  )		->							Tuple:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

          _snake_case									=				(
              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									=				True
               self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )

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

               self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )




     def 	lowerCAmelCase			(		self  )		->							Tuple:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case									=				3

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

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

          for model_class in self.all_model_classes:
               _snake_case									=				True
               self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						(padded_height, padded_width)  )

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




     def 	lowerCAmelCase			(		self  )		->							Tuple:
          _snake_case									=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_  )




     def 	lowerCAmelCase			(		self  )		->							Dict:
          _snake_case									=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_  )




     @slow
     def 	lowerCAmelCase			(		self  )		->							int:
          for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _snake_case									=				SwinvaModel.from_pretrained(lowerCAmelCase_  )
               self.assertIsNotNone(lowerCAmelCase_  )






     def 	lowerCAmelCase			(		self  )		->							str:
          _snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

          _snake_case									=				_config_zero_init(lowerCAmelCase_  )
          for model_class in self.all_model_classes:
               _snake_case									=				model_class(config=lowerCAmelCase_  )
               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 			UpperCamelCase_		(  unittest.TestCase					):




     @cached_property
     def 	lowerCAmelCase			(		self  )		->							Dict:
          return (
              AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'  )
              if is_vision_available()
              else None
          )






     @slow
     def 	lowerCAmelCase			(		self  )		->							List[str]:
          _snake_case									=				SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'  ).to(
              lowerCAmelCase_  )
          _snake_case									=				self.default_image_processor

          _snake_case									=				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
          _snake_case									=				image_processor(images=lowerCAmelCase_				,						return_tensors='pt'  ).to(lowerCAmelCase_  )

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

          # verify the logits
          _snake_case									=				torch.Size((1, 1000)  )
          self.assertEqual(outputs.logits.shape				,						lowerCAmelCase_  )
          _snake_case									=				torch.tensor([-0.39_47, -0.43_06, 0.00_26]  ).to(lowerCAmelCase_  )
          self.assertTrue(torch.allclose(outputs.logits[0, :3]				,						lowerCAmelCase_				,						atol=1E-4  )  )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_      							=     {
    """configuration_bigbird_pegasus""": [
        """BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BigBirdPegasusConfig""",
        """BigBirdPegasusOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase_      							=     [
					    """BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """BigBirdPegasusForCausalLM""",
					    """BigBirdPegasusForConditionalGeneration""",
					    """BigBirdPegasusForQuestionAnswering""",
					    """BigBirdPegasusForSequenceClassification""",
					    """BigBirdPegasusModel""",
					    """BigBirdPegasusPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_bigbird_pegasus import (
					    BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    BigBirdPegasusConfig,
					    BigBirdPegasusOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_bigbird_pegasus import (
										    BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
										    BigBirdPegasusForCausalLM,
										    BigBirdPegasusForConditionalGeneration,
										    BigBirdPegasusForQuestionAnswering,
										    BigBirdPegasusForSequenceClassification,
										    BigBirdPegasusModel,
										    BigBirdPegasusPreTrainedModel,
										)


else:
					import sys

					UpperCAmelCase_      							=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



