



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



       def __init__(							self      :  Union[str, Any]		,    _UpperCAmelCase      :  List[str]		,    _UpperCAmelCase      :  Any=13		,    _UpperCAmelCase      :  Optional[int]=32		,    _UpperCAmelCase      :  List[Any]=2		,    _UpperCAmelCase      :  Optional[Any]=3		,    _UpperCAmelCase      :  Dict=16		,    _UpperCAmelCase      :  Optional[Any]=[1, 2, 1]		,    _UpperCAmelCase      :  Optional[Any]=[2, 2, 4]		,    _UpperCAmelCase      :  Tuple=2		,    _UpperCAmelCase      :  Dict=2.0		,    _UpperCAmelCase      :  Any=True		,    _UpperCAmelCase      :  Dict=0.0		,    _UpperCAmelCase      :  Optional[int]=0.0		,    _UpperCAmelCase      :  Dict=0.1		,    _UpperCAmelCase      :  Tuple="gelu"		,    _UpperCAmelCase      :  Union[str, Any]=False		,    _UpperCAmelCase      :  List[str]=True		,    _UpperCAmelCase      :  List[str]=0.02		,    _UpperCAmelCase      :  Optional[Any]=1e-5		,    _UpperCAmelCase      :  Dict=True		,    _UpperCAmelCase      :  Tuple=None		,    _UpperCAmelCase      :  Any=True		,    _UpperCAmelCase      :  Any=10		,    _UpperCAmelCase      :  Tuple=8		,    )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							parent
             UpperCAmelCase_      			=							batch_size
             UpperCAmelCase_      			=							image_size
             UpperCAmelCase_      			=							patch_size
             UpperCAmelCase_      			=							num_channels
             UpperCAmelCase_      			=							embed_dim
             UpperCAmelCase_      			=							depths
             UpperCAmelCase_      			=							num_heads
             UpperCAmelCase_      			=							window_size
             UpperCAmelCase_      			=							mlp_ratio
             UpperCAmelCase_      			=							qkv_bias
             UpperCAmelCase_      			=							hidden_dropout_prob
             UpperCAmelCase_      			=							attention_probs_dropout_prob
             UpperCAmelCase_      			=							drop_path_rate
             UpperCAmelCase_      			=							hidden_act
             UpperCAmelCase_      			=							use_absolute_embeddings
             UpperCAmelCase_      			=							patch_norm
             UpperCAmelCase_      			=							layer_norm_eps
             UpperCAmelCase_      			=							initializer_range
             UpperCAmelCase_      			=							is_training
             UpperCAmelCase_      			=							scope
             UpperCAmelCase_      			=							use_labels
             UpperCAmelCase_      			=							type_sequence_label_size
             UpperCAmelCase_      			=							encoder_stride



       def 					lowercase__    (							self      :  int   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

             UpperCAmelCase_      			=							self.get_config()

             return config, pixel_values, labels



       def 					lowercase__    (							self      :  str   )			->						Optional[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 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  List[Any]		,    _UpperCAmelCase      :  List[str]		,    _UpperCAmelCase      :  List[str]   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							SwinvaModel(config=_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()
             UpperCAmelCase_      			=							model(_UpperCAmelCase   )

             UpperCAmelCase_      			=							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
             UpperCAmelCase_      			=							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 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  int		,    _UpperCAmelCase      :  Any		,    _UpperCAmelCase      :  Any   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							SwinvaForMaskedImageModeling(config=_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()
             UpperCAmelCase_      			=							model(_UpperCAmelCase   )
             self.parent.assertEqual(
                 result.logits.shape		,    (self.batch_size, self.num_channels, self.image_size, self.image_size)   )

             # test greyscale images
             UpperCAmelCase_      			=							1
             UpperCAmelCase_      			=							SwinvaForMaskedImageModeling(_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()

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



       def 					lowercase__    (							self      :  Dict		,    _UpperCAmelCase      :  Optional[Any]		,    _UpperCAmelCase      :  Tuple		,    _UpperCAmelCase      :  Any   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.type_sequence_label_size
             UpperCAmelCase_      			=							SwinvaForImageClassification(_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()
             UpperCAmelCase_      			=							model(_UpperCAmelCase		,    labels=_UpperCAmelCase   )
             self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)   )







       def 					lowercase__    (							self      :  Any   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.prepare_config_and_inputs()
             UpperCAmelCase_			,   UpperCAmelCase_			,   UpperCAmelCase_      			=							config_and_inputs
             UpperCAmelCase_      			=							{"pixel_values": pixel_values}
             return config, inputs_dict



@require_torch
class 				lowercase__       (   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 					lowercase__    (							self      :  Union[str, Any]   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							SwinvaModelTester(self   )
             UpperCAmelCase_      			=							ConfigTester(self		,    config_class=_UpperCAmelCase		,    embed_dim=37   )



       def 					lowercase__    (							self      :  str   )			->						Optional[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 					lowercase__    (							self      :  str   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							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 					lowercase__    (							self      :  Dict   )			->						Tuple:


             '''simple docstring'''




             pass



       @unittest.skip(reason="Swinv2 does not use inputs_embeds"   )
       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Dict:


             '''simple docstring'''




             pass



       def 					lowercase__    (							self      :  Any   )			->						Any:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

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



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

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

                   UpperCAmelCase_      			=							["pixel_values"]
                   self.assertListEqual(arg_names[:1]		,    _UpperCAmelCase   )



       def 					lowercase__    (							self      :  Dict   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()
             UpperCAmelCase_      			=							True

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

                   # check that output_attentions also work using config
                   del inputs_dict["output_attentions"]
                   UpperCAmelCase_      			=							True
                   UpperCAmelCase_      			=							config.window_size**2
                   UpperCAmelCase_      			=							model_class(_UpperCAmelCase   )
                   model.to(_UpperCAmelCase   )
                   model.eval()
                   with torch.no_grad():
                         UpperCAmelCase_      			=							model(**self._prepare_for_class(_UpperCAmelCase		,    _UpperCAmelCase   )   )
                   UpperCAmelCase_      			=							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]		,    )
                   UpperCAmelCase_      			=							len(_UpperCAmelCase   )

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

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

                   UpperCAmelCase_      			=							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 					lowercase__    (							self      :  List[str]		,    _UpperCAmelCase      :  List[str]		,    _UpperCAmelCase      :  Any		,    _UpperCAmelCase      :  Any		,    _UpperCAmelCase      :  Tuple   )			->						List[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							model_class(_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()

             with torch.no_grad():
                   UpperCAmelCase_      			=							model(**self._prepare_for_class(_UpperCAmelCase		,    _UpperCAmelCase   )   )

             UpperCAmelCase_      			=							outputs.hidden_states

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

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

             UpperCAmelCase_      			=							outputs.reshaped_hidden_states
             self.assertEqual(len(_UpperCAmelCase   )		,    _UpperCAmelCase   )

             UpperCAmelCase_			,   UpperCAmelCase_			,   UpperCAmelCase_			,   UpperCAmelCase_      			=							reshaped_hidden_states[0].shape
             UpperCAmelCase_      			=							(
                 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 					lowercase__    (							self      :  Any   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

             UpperCAmelCase_      			=							(
                 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:
                   UpperCAmelCase_      			=							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"]
                   UpperCAmelCase_      			=							True

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



       def 					lowercase__    (							self      :  Optional[Any]   )			->						int:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()
             UpperCAmelCase_      			=							3

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

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

             for model_class in self.all_model_classes:
                   UpperCAmelCase_      			=							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"]
                   UpperCAmelCase_      			=							True
                   self.check_hidden_states_output(_UpperCAmelCase		,    _UpperCAmelCase		,    _UpperCAmelCase		,    (padded_height, padded_width)   )



       def 					lowercase__    (							self      :  str   )			->						List[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase   )



       def 					lowercase__    (							self      :  Dict   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase   )



       @slow
       def 					lowercase__    (							self      :  Optional[Any]   )			->						Optional[int]:


             '''simple docstring'''




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







       def 					lowercase__    (							self      :  Optional[int]   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

             UpperCAmelCase_      			=							_config_zero_init(_UpperCAmelCase   )
             for model_class in self.all_model_classes:
                   UpperCAmelCase_      			=							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 				lowercase__       (   unittest.TestCase				):



       @cached_property
       def 					lowercase__    (							self      :  Any   )			->						Union[str, Any]:


             '''simple docstring'''




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







       @slow
       def 					lowercase__    (							self      :  Tuple   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							SwinvaForImageClassification.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256"   ).to(
                 _UpperCAmelCase   )
             UpperCAmelCase_      			=							self.default_image_processor

             UpperCAmelCase_      			=							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
             UpperCAmelCase_      			=							image_processor(images=_UpperCAmelCase		,    return_tensors="pt"   ).to(_UpperCAmelCase   )

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

             # verify the logits
             UpperCAmelCase_      			=							torch.Size((1, 1000)   )
             self.assertEqual(outputs.logits.shape		,    _UpperCAmelCase   )
             UpperCAmelCase_      			=							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 .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *




