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			:



 '''simple docstring'''




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


   """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 		__UpperCAmelCase				(		self				:   Optional[Any])						->	Optional[int]:


   """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 		__UpperCAmelCase				(		self				:   List[str])						->	Tuple:


   """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 		__UpperCAmelCase				(		self				:   int							, lowercase_				:   List[Any]							, lowercase_				:   Dict							, lowercase_				:   Union[str, Any])						->	Optional[int]:


   """simple docstring"""







   _UpperCamelCase           =    SwinvaModel(config=lowercase_)
   model.to(lowercase_)
   model.eval()
   _UpperCamelCase           =    model(lowercase_)

   _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 		__UpperCAmelCase				(		self				:   List[str]							, lowercase_				:   Union[str, Any]							, lowercase_				:   str							, lowercase_				:   List[Any])						->	int:


   """simple docstring"""







   _UpperCamelCase           =    SwinvaForMaskedImageModeling(config=lowercase_)
   model.to(lowercase_)
   model.eval()
   _UpperCamelCase           =    model(lowercase_)
   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(lowercase_)
   model.to(lowercase_)
   model.eval()

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







 def 		__UpperCAmelCase				(		self				:   Optional[Any]							, lowercase_				:   int							, lowercase_				:   Union[str, Any]							, lowercase_				:   Optional[int])						->	Optional[Any]:


   """simple docstring"""







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







 def 		__UpperCAmelCase				(		self				:   List[str])						->	int:


   """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 					_UpperCAmelCase			(     lowerCAmelCase,			lowerCAmelCase,			unittest.TestCase  ):



 '''simple docstring'''




 __A			       =					(
     (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
 )
 __A			       =					(
     {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
     if is_torch_available()
     else {}
 )

 __A			       =					False
 __A			       =					False
 __A			       =					False
 __A			       =					False







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


   """simple docstring"""







   _UpperCamelCase           =    SwinvaModelTester(self)
   _UpperCamelCase           =    ConfigTester(self							, config_class=lowercase_							, embed_dim=37)







 def 		__UpperCAmelCase				(		self				:   Union[str, Any])						->	int:


   """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 		__UpperCAmelCase				(		self				:   List[str])						->	int:


   """simple docstring"""







   _UpperCamelCase           =    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*lowercase_)







 @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0.")
 def 		__UpperCAmelCase				(		self				:   Optional[int])						->	Optional[int]:


   """simple docstring"""







   pass







 @unittest.skip(reason="Swinv2 does not use inputs_embeds")
 def 		__UpperCAmelCase				(		self				:   Any)						->	List[Any]:


   """simple docstring"""







   pass







 def 		__UpperCAmelCase				(		self				:   str)						->	Union[str, 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(lowercase_)
     self.assertIsInstance(model.get_input_embeddings()							, (nn.Module))
     _UpperCamelCase           =    model.get_output_embeddings()
     self.assertTrue(x is None or isinstance(lowercase_							, nn.Linear))







 def 		__UpperCAmelCase				(		self				:   int)						->	int:


   """simple docstring"""







   _UpperCamelCase      ,						_UpperCamelCase           =    self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _UpperCamelCase           =    model_class(lowercase_)
     _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]							, lowercase_)







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


   """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(lowercase_)
     model.to(lowercase_)
     model.eval()
     with torch.no_grad():
       _UpperCamelCase           =    model(**self._prepare_for_class(lowercase_							, lowercase_))
     _UpperCamelCase           =    outputs.attentions
     _UpperCamelCase           =    len(self.model_tester.depths)
     self.assertEqual(len(lowercase_)							, lowercase_)

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

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

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

     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(lowercase_))

     _UpperCamelCase           =    outputs.attentions

     self.assertEqual(len(lowercase_)							, lowercase_)

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







 def 		__UpperCAmelCase				(		self				:   Any							, lowercase_				:   str							, lowercase_				:   Optional[int]							, lowercase_				:   str							, lowercase_				:   List[str])						->	Any:


   """simple docstring"""







   _UpperCamelCase           =    model_class(lowercase_)
   model.to(lowercase_)
   model.eval()

   with torch.no_grad():
     _UpperCamelCase           =    model(**self._prepare_for_class(lowercase_							, lowercase_))

   _UpperCamelCase           =    outputs.hidden_states

   _UpperCamelCase           =    getattr(
       self.model_tester							, "expected_num_hidden_layers"							, len(self.model_tester.depths) + 1)
   self.assertEqual(len(lowercase_)							, lowercase_)

   # 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(lowercase_)							, lowercase_)

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







 def 		__UpperCAmelCase				(		self				:   Any)						->	str:


   """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(lowercase_							, lowercase_							, lowercase_							, lowercase_)

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

     self.check_hidden_states_output(lowercase_							, lowercase_							, lowercase_							, lowercase_)







 def 		__UpperCAmelCase				(		self				:   Any)						->	Tuple:


   """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(lowercase_							, lowercase_							, lowercase_							, (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(lowercase_							, lowercase_							, lowercase_							, (padded_height, padded_width))







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


   """simple docstring"""







   _UpperCamelCase           =    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_)







 def 		__UpperCAmelCase				(		self				:   Tuple)						->	Union[str, Any]:


   """simple docstring"""







   _UpperCamelCase           =    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*lowercase_)







 @slow
 def 		__UpperCAmelCase				(		self				:   List[str])						->	int:


   """simple docstring"""







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







 def 		__UpperCAmelCase				(		self				:   Dict)						->	List[str]:


   """simple docstring"""







   _UpperCamelCase      ,						_UpperCamelCase           =    self.model_tester.prepare_config_and_inputs_for_common()

   _UpperCamelCase           =    _config_zero_init(lowercase_)
   for model_class in self.all_model_classes:
     _UpperCamelCase           =    model_class(config=lowercase_)
     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  ):



 '''simple docstring'''




 @cached_property
 def 		__UpperCAmelCase				(		self				:   List[str])						->	Dict:


   """simple docstring"""







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







 @slow
 def 		__UpperCAmelCase				(		self				:   str)						->	str:


   """simple docstring"""







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

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

   # forward pass
   with torch.no_grad():
     _UpperCamelCase           =    model(**lowercase_)

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





from __future__ import annotations


def 				lowerCAmelCase__       (			a__    ,     a__ )      ->bool:




  '''simple docstring'''

  _UpperCamelCase           =    get_failure_array(a__ )

  # 2) Step through text searching for pattern
  _UpperCamelCase      ,						_UpperCamelCase           =    0, 0  # index into text, pattern
  while i < len(a__ ):
    if pattern[j] == text[i]:
      if j == (len(a__ ) - 1):
        return True
      j += 1

    # if this is a prefix in our pattern
    # just go back far enough to continue
    elif j > 0:
      _UpperCamelCase           =    failure[j - 1]
      continue
    i += 1
  return False


def 				lowerCAmelCase__       (			a__ )      ->list[int]:




  '''simple docstring'''

  _UpperCamelCase           =    [0]
  _UpperCamelCase           =    0
  _UpperCamelCase           =    1
  while j < len(a__ ):
    if pattern[i] == pattern[j]:
      i += 1
    elif i > 0:
      _UpperCamelCase           =    failure[i - 1]
      continue
    j += 1
    failure.append(a__ )
  return failure


if __name__ == "__main__":
   # Test 1)
   lowerCamelCase__  =					'''abc1abc12'''
   lowerCamelCase__  =					'''alskfjaldsabc1abc1abc12k23adsfabcabc'''
   lowerCamelCase__  =					'''alskfjaldsk23adsfabcabc'''
   assert kmp(pattern, texta) and not kmp(pattern, texta)

   # Test 2)
   lowerCamelCase__  =					'''ABABX'''
   lowerCamelCase__  =					'''ABABZABABYABABX'''
   assert kmp(pattern, text)

   # Test 3)
   lowerCamelCase__  =					'''AAAB'''
   lowerCamelCase__  =					'''ABAAAAAB'''
   assert kmp(pattern, text)

   # Test 4)
   lowerCamelCase__  =					'''abcdabcy'''
   lowerCamelCase__  =					'''abcxabcdabxabcdabcdabcy'''
   assert kmp(pattern, text)

   # Test 5)
   lowerCamelCase__  =					'''aabaabaaa'''
   assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]




