


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


     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.0_2							,					A_=1e-5							,					A_=True							,					A_=None							,					A_=True							,					A_=10							,					A_=8							,					):
       _UpperCAmelCase		:							List[str]							=     parent
       _UpperCAmelCase		:							List[Any]							=     batch_size
       _UpperCAmelCase		:							Optional[Any]							=     image_size
       _UpperCAmelCase		:							Any							=     patch_size
       _UpperCAmelCase		:							Dict							=     num_channels
       _UpperCAmelCase		:							List[str]							=     embed_dim
       _UpperCAmelCase		:							Union[str, Any]							=     depths
       _UpperCAmelCase		:							int							=     num_heads
       _UpperCAmelCase		:							int							=     window_size
       _UpperCAmelCase		:							Tuple							=     mlp_ratio
       _UpperCAmelCase		:							Union[str, Any]							=     qkv_bias
       _UpperCAmelCase		:							str							=     hidden_dropout_prob
       _UpperCAmelCase		:							Optional[Any]							=     attention_probs_dropout_prob
       _UpperCAmelCase		:							List[Any]							=     drop_path_rate
       _UpperCAmelCase		:							Dict							=     hidden_act
       _UpperCAmelCase		:							Optional[int]							=     use_absolute_embeddings
       _UpperCAmelCase		:							str							=     patch_norm
       _UpperCAmelCase		:							List[Any]							=     layer_norm_eps
       _UpperCAmelCase		:							int							=     initializer_range
       _UpperCAmelCase		:							List[Any]							=     is_training
       _UpperCAmelCase		:							str							=     scope
       _UpperCAmelCase		:							int							=     use_labels
       _UpperCAmelCase		:							Optional[int]							=     type_sequence_label_size
       _UpperCAmelCase		:							int							=     encoder_stride


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Union[str, Any]							=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

       _UpperCAmelCase		:							int							=     None
       if self.use_labels:
         _UpperCAmelCase		:							Optional[int]							=     ids_tensor([self.batch_size]							,					self.type_sequence_label_size    )

       _UpperCAmelCase		:							int							=     self.get_config()

       return config, pixel_values, labels


     def        __snake_case(  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        __snake_case(  self							,					A_							,					A_							,					A_    ):
       _UpperCAmelCase		:							List[Any]							=     SwinvaModel(config=A_    )
       model.to(A_    )
       model.eval()
       _UpperCAmelCase		:							str							=     model(A_    )

       _UpperCAmelCase		:							Union[str, Any]							=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
       _UpperCAmelCase		:							Dict							=     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        __snake_case(  self							,					A_							,					A_							,					A_    ):
       _UpperCAmelCase		:							str							=     SwinvaForMaskedImageModeling(config=A_    )
       model.to(A_    )
       model.eval()
       _UpperCAmelCase		:							Optional[int]							=     model(A_    )
       self.parent.assertEqual(
           result.logits.shape							,					(self.batch_size, self.num_channels, self.image_size, self.image_size)    )

       # test greyscale images
       _UpperCAmelCase		:							str							=     1
       _UpperCAmelCase		:							Optional[int]							=     SwinvaForMaskedImageModeling(A_    )
       model.to(A_    )
       model.eval()

       _UpperCAmelCase		:							Optional[Any]							=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
       _UpperCAmelCase		:							Tuple							=     model(A_    )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, 1, self.image_size, self.image_size)    )


     def        __snake_case(  self							,					A_							,					A_							,					A_    ):
       _UpperCAmelCase		:							Tuple							=     self.type_sequence_label_size
       _UpperCAmelCase		:							str							=     SwinvaForImageClassification(A_    )
       model.to(A_    )
       model.eval()
       _UpperCAmelCase		:							Tuple							=     model(A_							,					labels=A_    )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)    )




     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Any							=     self.prepare_config_and_inputs()
       _UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase		:							List[Any]							=     config_and_inputs
       _UpperCAmelCase		:							List[Any]							=     {"""pixel_values""": pixel_values}
       return config, inputs_dict


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

     __SCREAMING_SNAKE_CASE     					=    False
     __SCREAMING_SNAKE_CASE     					=    False
     __SCREAMING_SNAKE_CASE     					=    False
     __SCREAMING_SNAKE_CASE     					=    False


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Any							=     SwinvaModelTester(self    )
       _UpperCAmelCase		:							Any							=     ConfigTester(self							,					config_class=A_							,					embed_dim=37    )


     def        __snake_case(  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        __snake_case(  self    ):
       _UpperCAmelCase		:							str							=     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        __snake_case(  self    ):
       pass


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


     def        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							Dict							=     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         _UpperCAmelCase		:							Dict							=     model_class(A_    )
         self.assertIsInstance(model.get_input_embeddings()							,					(nn.Module)    )
         _UpperCAmelCase		:							List[str]							=     model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(A_							,					nn.Linear    )    )


     def        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							str							=     self.model_tester.prepare_config_and_inputs_for_common()

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

         _UpperCAmelCase		:							Optional[int]							=     ["""pixel_values"""]
         self.assertListEqual(arg_names[:1]							,					A_    )


     def        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							Any							=     self.model_tester.prepare_config_and_inputs_for_common()
       _UpperCAmelCase		:							Tuple							=     True

       for model_class in self.all_model_classes:
         _UpperCAmelCase		:							str							=     True
         _UpperCAmelCase		:							str							=     False
         _UpperCAmelCase		:							Optional[int]							=     True
         _UpperCAmelCase		:							Any							=     model_class(A_    )
         model.to(A_    )
         model.eval()
         with torch.no_grad():
           _UpperCAmelCase		:							int							=     model(**self._prepare_for_class(A_							,					A_    )    )
         _UpperCAmelCase		:							List[Any]							=     outputs.attentions
         _UpperCAmelCase		:							str							=     len(self.model_tester.depths    )
         self.assertEqual(len(A_    )							,					A_    )

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

         # Check attention is always last and order is fine
         _UpperCAmelCase		:							List[Any]							=     True
         _UpperCAmelCase		:							Any							=     True
         _UpperCAmelCase		:							Tuple							=     model_class(A_    )
         model.to(A_    )
         model.eval()
         with torch.no_grad():
           _UpperCAmelCase		:							int							=     model(**self._prepare_for_class(A_							,					A_    )    )

         if hasattr(self.model_tester							,					"""num_hidden_states_types"""    ):
           _UpperCAmelCase		:							List[Any]							=     self.model_tester.num_hidden_states_types
         else:
           # also another +1 for reshaped_hidden_states
           _UpperCAmelCase		:							Union[str, Any]							=     2
         self.assertEqual(out_len + added_hidden_states							,					len(A_    )    )

         _UpperCAmelCase		:							str							=     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        __snake_case(  self							,					A_							,					A_							,					A_							,					A_    ):
       _UpperCAmelCase		:							List[Any]							=     model_class(A_    )
       model.to(A_    )
       model.eval()

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

       _UpperCAmelCase		:							Union[str, Any]							=     outputs.hidden_states

       _UpperCAmelCase		:							Optional[Any]							=     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
       _UpperCAmelCase		:							List[Any]							=     (
           config.patch_size
           if isinstance(config.patch_size							,					collections.abc.Iterable    )
           else (config.patch_size, config.patch_size)
       )

       _UpperCAmelCase		:							Any							=     (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		:							Dict							=     outputs.reshaped_hidden_states
       self.assertEqual(len(A_    )							,					A_    )

       _UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase		:							int							=     reshaped_hidden_states[0].shape
       _UpperCAmelCase		:							Optional[Any]							=     (
           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        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							Union[str, Any]							=     self.model_tester.prepare_config_and_inputs_for_common()

       _UpperCAmelCase		:							Any							=     (
           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		:							Union[str, Any]							=     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"]
         _UpperCAmelCase		:							Tuple							=     True

         self.check_hidden_states_output(A_							,					A_							,					A_							,					A_    )


     def        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							int							=     self.model_tester.prepare_config_and_inputs_for_common()
       _UpperCAmelCase		:							Optional[Any]							=     3

       _UpperCAmelCase		:							Optional[int]							=     (
           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		:							str							=     (
           config.patch_size
           if isinstance(config.patch_size							,					collections.abc.Iterable    )
           else (config.patch_size, config.patch_size)
       )

       _UpperCAmelCase		:							Optional[int]							=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       _UpperCAmelCase		:							Dict							=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[int]							=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*A_    )


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							List[Any]							=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*A_    )


     @slow
     def        __snake_case(  self    ):
       for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _UpperCAmelCase		:							Any							=     SwinvaModel.from_pretrained(A_    )
         self.assertIsNotNone(A_    )




     def        __snake_case(  self    ):
       _UpperCAmelCase,_UpperCAmelCase		:							List[str]							=     self.model_tester.prepare_config_and_inputs_for_common()

       _UpperCAmelCase		:							List[Any]							=     _config_zero_init(A_    )
       for model_class in self.all_model_classes:
         _UpperCAmelCase		:							Optional[int]							=     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 		_SCREAMING_SNAKE_CASE     (						unittest.TestCase     ):


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




     @slow
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[int]							=     SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""    ).to(
           A_    )
       _UpperCAmelCase		:							Any							=     self.default_image_processor

       _UpperCAmelCase		:							str							=     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
       _UpperCAmelCase		:							List[Any]							=     image_processor(images=A_							,					return_tensors="""pt"""    ).to(A_    )

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

       # verify the logits
       _UpperCAmelCase		:							Any							=     torch.Size((1, 10_00)    )
       self.assertEqual(outputs.logits.shape							,					A_    )
       _UpperCAmelCase		:							Any							=     torch.tensor([-0.3_9_4_7, -0.4_3_0_6, 0.0_0_2_6]    ).to(A_    )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]							,					A_							,					atol=1e-4    )    )









import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Image
from .base import TaskTemplate


@dataclass(frozen=A     )
class 		_SCREAMING_SNAKE_CASE     (						A     ):
     __SCREAMING_SNAKE_CASE     					=    field(default='''image-classification'''							,	metadata={'''include_in_asdict_even_if_is_default''': True}     )
     __SCREAMING_SNAKE_CASE     					=    Features({'''image''': Image()}     )
     __SCREAMING_SNAKE_CASE     					=    Features({'''labels''': ClassLabel}     )
     __SCREAMING_SNAKE_CASE     					=    "image"
     __SCREAMING_SNAKE_CASE     					=    "labels"


     def        __snake_case(  self							,					A_    ):
       if self.label_column not in features:
         raise ValueError(F'''Column {self.label_column} is not present in features.'''    )
       if not isinstance(features[self.label_column]							,					A_    ):
         raise ValueError(F'''Column {self.label_column} is not a ClassLabel.'''    )
       _UpperCAmelCase		:							Tuple							=     copy.deepcopy(self    )
       _UpperCAmelCase		:							str							=     self.label_schema.copy()
       _UpperCAmelCase		:							Optional[Any]							=     features[self.label_column]
       _UpperCAmelCase		:							int							=     label_schema
       return task_template




     @property
     def        __snake_case(  self    ):
       return {
           self.image_column: "image",
           self.label_column: "labels",
       }





