



'''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 __A    :



 '''simple docstring'''







 def __init__(self				,     A				,     A=13				,     A=32				,     A=2				,     A=3				,     A=16				,     A=[1, 2, 1]				,     A=[2, 2, 4]				,     A=2				,     A=2.0				,     A=True				,     A=0.0				,     A=0.0				,     A=0.1				,     A="gelu"				,     A=False				,     A=True				,     A=0.02				,     A=1E-5				,     A=True				,     A=None				,     A=True				,     A=10				,     A=8				,     )					->  str:


      """simple docstring"""



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



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


      """simple docstring"""



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

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

      _a											=						self.get_config()

      return config, pixel_values, labels



 def       a__						(self )					->  str:


      """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				,     A				,     A				,     A )					->  Tuple:


      """simple docstring"""



      _a											=						SwinvaModel(config=A )
      model.to(A )
      model.eval()
      _a											=						model(A )

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


      """simple docstring"""



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

      # test greyscale images
      _a											=						1
      _a											=						SwinvaForMaskedImageModeling(A )
      model.to(A )
      model.eval()

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



 def       a__						(self				,     A				,     A				,     A )					->  str:


      """simple docstring"""



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



 def       a__						(self )					->  Dict:


      """simple docstring"""



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






@require_torch
class __A    (						A     ,     A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: str    = (
     (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
 )
 __lowerCamelCase					: Optional[int]    = (
     {'feature-extraction': SwinvaModel, 'image-classification': SwinvaForImageClassification}
     if is_torch_available()
     else {}
 )

 __lowerCamelCase					: List[str]    = False
 __lowerCamelCase					: Any    = False
 __lowerCamelCase					: Union[str, Any]    = False
 __lowerCamelCase					: Union[str, Any]    = False



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						SwinvaModelTester(self )
      _a											=						ConfigTester(self				,     config_class=A				,     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 )					->  Union[str, Any]:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A )



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


      """simple docstring"""



      pass



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


      """simple docstring"""



      pass



 def       a__						(self )					->  str:


      """simple docstring"""



      _a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_common()

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



 def       a__						(self )					->  str:


      """simple docstring"""



      _a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_common()

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

           _a											=						['''pixel_values''']
           self.assertListEqual(arg_names[:1]				,     A )



 def       a__						(self )					->  str:


      """simple docstring"""



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

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

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

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

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

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

           _a											=						outputs.attentions

           self.assertEqual(len(A )				,     A )

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



 def       a__						(self				,     A				,     A				,     A				,     A )					->  Optional[int]:


      """simple docstring"""



      _a											=						model_class(A )
      model.to(A )
      model.eval()

      with torch.no_grad():
           _a											=						model(**self._prepare_for_class(A				,     A ) )

      _a											=						outputs.hidden_states

      _a											=						getattr(
          self.model_tester				,     '''expected_num_hidden_layers'''				,     len(self.model_tester.depths ) + 1 )
      self.assertEqual(len(A )				,     A )

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

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

      _a											=						outputs.reshaped_hidden_states
      self.assertEqual(len(A )				,     A )

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



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


      """simple docstring"""



      _a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_common()

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

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

           self.check_hidden_states_output(A				,     A				,     A				,     A )



 def       a__						(self )					->  int:


      """simple docstring"""



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

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

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

      for model_class in self.all_model_classes:
           _a											=						True
           self.check_hidden_states_output(A				,     A				,     A				,     (padded_height, padded_width) )

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



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


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*A )



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*A )



 @slow
 def       a__						(self )					->  int:


      """simple docstring"""



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



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_common()

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



 '''simple docstring'''







 @cached_property
 def       a__						(self )					->  Optional[int]:


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



      _a											=						SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''' ).to(
          A )
      _a											=						self.default_image_processor

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

      # forward pass
      with torch.no_grad():
           _a											=						model(**A )

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








'''simple docstring'''





import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
  import torch

  from transformers.generation import DisjunctiveConstraint






@require_torch
class __A    (						unittest.TestCase		):



 '''simple docstring'''







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


      """simple docstring"""



      _a											=						[[1, 2, 4], [1, 2, 3, 4]]
      _a											=						DisjunctiveConstraint(A )
      self.assertTrue(isinstance(dc.token_ids				,     A ) )

      with self.assertRaises(A ):
           DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]] ) )

      with self.assertRaises(A ):
           DisjunctiveConstraint([torch.LongTensor([1, 2, 4] ), torch.LongTensor([1, 2, 3, 4, 5] )] )



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						[[1, 2], [1, 2, 3, 4]]

      with self.assertRaises(A ):
           DisjunctiveConstraint(A )  # fails here



 def       a__						(self )					->  Dict:


      """simple docstring"""



      _a											=						[[1, 2, 3], [1, 2, 4]]

      _a											=						DisjunctiveConstraint(A )

      _a						,					_a						,					_a											=						dc.update(1 )
      _a											=						stepped is True and completed is False and reset is False
      self.assertTrue(A )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      _a											=						stepped is True and completed is False and reset is False
      self.assertTrue(A )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(3 )
      _a											=						stepped is True and completed is True and reset is False
      self.assertTrue(A )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.current_seq == [1, 2, 3] )



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


      """simple docstring"""



      _a											=						[[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

      _a											=						DisjunctiveConstraint(A )

      _a						,					_a						,					_a											=						dc.update(1 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(4 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2, 4] )

      _a						,					_a						,					_a											=						dc.update(5 )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.current_seq == [1, 2, 4, 5] )

      dc.reset()

      _a						,					_a						,					_a											=						dc.update(1 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.remaining() == 3 )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.remaining() == 2 )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(5 )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.remaining() == 0 )
      self.assertTrue(dc.current_seq == [1, 2, 5] )



