

'''simple docstring'''
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 						__magic_name__   :







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







 def 						_A(       self   ):
   lowercase									=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

   lowercase									=self.get_config()

   return config, pixel_values, labels







 def 						_A(       self   ):
   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  , snake_case_  , snake_case_  , snake_case_   ):
   lowercase									=SwinvaModel(config=snake_case_   )
   model.to(snake_case_   )
   model.eval()
   lowercase									=model(snake_case_   )

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

   # test greyscale images
   lowercase									=1
   lowercase									=SwinvaForMaskedImageModeling(snake_case_   )
   model.to(snake_case_   )
   model.eval()

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







 def 						_A(       self  , snake_case_  , snake_case_  , snake_case_   ):
   lowercase									=self.type_sequence_label_size
   lowercase									=SwinvaForImageClassification(snake_case_   )
   model.to(snake_case_   )
   model.eval()
   lowercase									=model(snake_case_  , labels=snake_case_   )
   self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.type_sequence_label_size)   )







 def 						_A(       self   ):
   lowercase									=self.prepare_config_and_inputs()
   lowercase							, lowercase							, lowercase									=config_and_inputs
   lowercase									={'''pixel_values''': pixel_values}
   return config, inputs_dict

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

 UpperCamelCase__     =       False
 UpperCamelCase__     =       False
 UpperCamelCase__     =       False
 UpperCamelCase__     =       False







 def 						_A(       self   ):
   lowercase									=SwinvaModelTester(self   )
   lowercase									=ConfigTester(self  , config_class=snake_case_  , embed_dim=37   )







 def 						_A(       self   ):
   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   ):
   lowercase									=self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*snake_case_   )







 @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''   )
 def 						_A(       self   ):
   pass







 @unittest.skip(reason='''Swinv2 does not use inputs_embeds'''   )
 def 						_A(       self   ):
   pass







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()

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







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()

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

     lowercase									=['''pixel_values''']
     self.assertListEqual(arg_names[:1]  , snake_case_   )







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()
   lowercase									=True

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

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

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

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

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

     lowercase									=outputs.attentions

     self.assertEqual(len(snake_case_   )  , snake_case_   )

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







 def 						_A(       self  , snake_case_  , snake_case_  , snake_case_  , snake_case_   ):
   lowercase									=model_class(snake_case_   )
   model.to(snake_case_   )
   model.eval()

   with torch.no_grad():
     lowercase									=model(**self._prepare_for_class(snake_case_  , snake_case_   )   )

   lowercase									=outputs.hidden_states

   lowercase									=getattr(
       self.model_tester  , '''expected_num_hidden_layers'''  , len(self.model_tester.depths   ) + 1   )
   self.assertEqual(len(snake_case_   )  , snake_case_   )

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

   lowercase									=(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]  , )

   lowercase									=outputs.reshaped_hidden_states
   self.assertEqual(len(snake_case_   )  , snake_case_   )

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







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()

   lowercase									=(
       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:
     lowercase									=True
     self.check_hidden_states_output(snake_case_  , snake_case_  , snake_case_  , snake_case_   )

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

     self.check_hidden_states_output(snake_case_  , snake_case_  , snake_case_  , snake_case_   )







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()
   lowercase									=3

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

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

   for model_class in self.all_model_classes:
     lowercase									=True
     self.check_hidden_states_output(snake_case_  , snake_case_  , snake_case_  , (padded_height, padded_width)   )

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







 def 						_A(       self   ):
   lowercase									=self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_   )







 def 						_A(       self   ):
   lowercase									=self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*snake_case_   )







 @slow
 def 						_A(       self   ):
   for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowercase									=SwinvaModel.from_pretrained(snake_case_   )
     self.assertIsNotNone(snake_case_   )







 def 						_A(       self   ):
   lowercase							, lowercase									=self.model_tester.prepare_config_and_inputs_for_common()

   lowercase									=_config_zero_init(snake_case_   )
   for model_class in self.all_model_classes:
     lowercase									=model_class(config=snake_case_   )
     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 						__magic_name__   (							unittest.TestCase ):







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







 @slow
 def 						_A(       self   ):
   lowercase									=SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''   ).to(
       snake_case_   )
   lowercase									=self.default_image_processor

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

   # forward pass
   with torch.no_grad():
     lowercase									=model(**snake_case_   )

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








"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__    						=			logging.get_logger(__name__)

lowerCAmelCase__    						=			{
    'caidas/swin2sr-classicalsr-x2-64': (
        'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json'
    ),
}


class _lowerCAmelCase						(    __UpperCAmelCase       ):
						SCREAMING_SNAKE_CASE_:					Any 					=				'swin2sr'

						SCREAMING_SNAKE_CASE_:					Dict 					=				{
						    'hidden_size': 'embed_dim',
						    'num_attention_heads': 'num_heads',
						    'num_hidden_layers': 'num_layers',
						}







						def __init__(    self   ,				lowerCAmelCase_=6_4   ,				lowerCAmelCase_=1   ,				lowerCAmelCase_=3   ,				lowerCAmelCase_=1_8_0   ,				lowerCAmelCase_=[6, 6, 6, 6, 6, 6]   ,				lowerCAmelCase_=[6, 6, 6, 6, 6, 6]   ,				lowerCAmelCase_=8   ,				lowerCAmelCase_=2.0   ,				lowerCAmelCase_=True   ,				lowerCAmelCase_=0.0   ,				lowerCAmelCase_=0.0   ,				lowerCAmelCase_=0.1   ,				lowerCAmelCase_="gelu"   ,				lowerCAmelCase_=False   ,				lowerCAmelCase_=0.02   ,				lowerCAmelCase_=1e-5   ,				lowerCAmelCase_=2   ,				lowerCAmelCase_=1.0   ,				lowerCAmelCase_="1conv"   ,				lowerCAmelCase_="pixelshuffle"   ,				**lowerCAmelCase_   ,				)		->							Dict:
										super().__init__(**lowerCAmelCase_							)

										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    image_size
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    patch_size
										_SCREAMING_SNAKE_CASE   :		str       		=    num_channels
										_SCREAMING_SNAKE_CASE   :		Any       		=    embed_dim
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    depths
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    len(lowerCAmelCase_							)
										_SCREAMING_SNAKE_CASE   :		Tuple       		=    num_heads
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    window_size
										_SCREAMING_SNAKE_CASE   :		List[str]       		=    mlp_ratio
										_SCREAMING_SNAKE_CASE   :		List[str]       		=    qkv_bias
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    hidden_dropout_prob
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    drop_path_rate
										_SCREAMING_SNAKE_CASE   :		int       		=    hidden_act
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    use_absolute_embeddings
										_SCREAMING_SNAKE_CASE   :		str       		=    layer_norm_eps
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    initializer_range
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    upscale
										_SCREAMING_SNAKE_CASE   :		str       		=    img_range
										_SCREAMING_SNAKE_CASE   :		Any       		=    resi_connection
										_SCREAMING_SNAKE_CASE   :		Tuple       		=    upsampler

