



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





 """simple docstring"""



 def __init__(    self						,     a						,     a=1_3						,     a=3_2						,     a=2						,     a=3						,     a=1_6						,     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=1_0						,     a=8						,     )						->				Any:




   """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 lowercase_		(    self       )						->				List[Any]:




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




   """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 lowercase_		(    self						,     a						,     a						,     a       )						->				Optional[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 lowercase_		(    self						,     a						,     a						,     a       )						->				int:




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




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





 """simple docstring"""



 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 lowercase_		(    self       )						->				Dict:




   """simple docstring"""







   _A							     =     SwinvaModelTester(self       )
   _A							     =     ConfigTester(self						,     config_class=a						,     embed_dim=3_7       )
 def lowercase_		(    self       )						->				Union[str, 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       )						->				Dict:




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




   """simple docstring"""







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




   """simple docstring"""







   pass
 def lowercase_		(    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 lowercase_		(    self       )						->				Any:




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




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




   """simple docstring"""







   _A							     =     self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*a       )
 def lowercase_		(    self       )						->				str:




   """simple docstring"""







   _A							     =     self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*a       )
 @slow
 def lowercase_		(    self       )						->				Optional[int]:




   """simple docstring"""







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



 def lowercase_		(    self       )						->				Dict:




   """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 		_snake_case   (      unittest.TestCase					):





 """simple docstring"""



 @cached_property
 def lowercase_		(    self       )						->				Optional[Any]:




   """simple docstring"""







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



 @slow
 def lowercase_		(    self       )						->				Tuple:




   """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_0_0_0)       )
   self.assertEqual(outputs.logits.shape						,     a       )
   _A							     =     torch.tensor([-0.3_947, -0.4_306, 0.0_026]       ).to(a       )
   self.assertTrue(torch.allclose(outputs.logits[0, :3]						,     a						,     atol=1e-4       )       )






'''simple docstring'''

import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


a   	=    logging.get_logger(__name__)

def     __magic_name__							(				__UpperCAmelCase=None				,						__UpperCAmelCase=None   )    ->       Dict:

   '''simple docstring'''







   return field(default_factory=lambda: default				,						metadata=__UpperCAmelCase   )







@dataclass
class __a			:
   __UpperCamelCase :			List[str]						   =						list_field(
       default=[], metadata={
           'help': (
               'Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version'
               ' of all available models'
           )
       }, )

   __UpperCamelCase :			List[int]						   =						list_field(
       default=[8], metadata={'help': 'List of batch sizes for which memory and time performance will be evaluated'}      )

   __UpperCamelCase :			List[int]						   =						list_field(
       default=[8, 32, 128, 512], metadata={'help': 'List of sequence lengths for which memory and time performance will be evaluated'}, )

   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={'help': 'Whether to benchmark inference of model. Inference can be disabled via --no-inference.'}, )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={'help': 'Whether to run on available cuda devices. Cuda can be disabled via --no-cuda.'}, )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={'help': 'Whether to run on available tpu devices. TPU can be disabled via --no-tpu.'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Use FP16 to accelerate inference.'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Benchmark training of model'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Verbose memory tracing'}      )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={'help': 'Whether to perform speed measurements. Speed measurements can be disabled via --no-speed.'}, )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={
           'help': 'Whether to perform memory measurements. Memory measurements can be disabled via --no-memory'
       }, )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Trace memory line by line'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Save result to a CSV file'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Save all print statements in a log file'}      )
   __UpperCamelCase :			bool						   =						field(default=_snake_case, metadata={'help': 'Whether to print environment information'}      )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={
           'help': (
               'Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use'
               ' multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled'
               ' for debugging / testing and on TPU.'
           )
       }, )
   __UpperCamelCase :			str						   =						field(
       default=F'inference_time_{round(time()      )}.csv', metadata={'help': 'CSV filename used if saving time results to csv.'}, )
   __UpperCamelCase :			str						   =						field(
       default=F'inference_memory_{round(time()      )}.csv', metadata={'help': 'CSV filename used if saving memory results to csv.'}, )
   __UpperCamelCase :			str						   =						field(
       default=F'train_time_{round(time()      )}.csv', metadata={'help': 'CSV filename used if saving time results to csv for training.'}, )
   __UpperCamelCase :			str						   =						field(
       default=F'train_memory_{round(time()      )}.csv', metadata={'help': 'CSV filename used if saving memory results to csv for training.'}, )
   __UpperCamelCase :			str						   =						field(
       default=F'env_info_{round(time()      )}.csv', metadata={'help': 'CSV filename used if saving environment information.'}, )
   __UpperCamelCase :			str						   =						field(
       default=F'log_{round(time()      )}.csv', metadata={'help': 'Log filename used if print statements are saved in log.'}, )
   __UpperCamelCase :			int						   =						field(default=3, metadata={'help': 'Times an experiment will be run.'}      )
   __UpperCamelCase :			bool						   =						field(
       default=_snake_case, metadata={
           'help': (
               'Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain'
               ' model weights.'
           )
       }, )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      warnings.warn(
          f"""The class {self.__class__} is deprecated. Hugging Face Benchmarking utils"""
          """ are deprecated in general and it is advised to use external Benchmarking libraries """
          """ to benchmark Transformer models."""					,lowerCamelCase					,)





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      return json.dumps(dataclasses.asdict(self     )					,indent=2     )





   @property
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      if len(self.models     ) <= 0:
         raise ValueError(
             """Please make sure you provide at least one model name / model identifier, *e.g.* `--models"""
             """ bert-base-cased` or `args.models = ['bert-base-cased']."""     )
      return self.models





   @property
   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      if not self.multi_process:
         return False
      elif self.is_tpu:
         logger.info("""Multiprocessing is currently not possible on TPU."""     )
         return False
      else:
         return True





