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






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





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



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

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

         __lowerCamelCase            =    self.get_config()

         return config, pixel_values, labels






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





         """simple docstring"""



         __lowerCamelCase            =    SwinvaModel(config=a       )
         model.to(a       )
         model.eval()
         __lowerCamelCase            =    model(a       )

         __lowerCamelCase            =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths       ) - 1))
         __lowerCamelCase            =    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   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						Dict    ,							a						:						Union[str, Any]    ,							a						:						List[str]       ):





         """simple docstring"""



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

         # test greyscale images
         __lowerCamelCase            =    1
         __lowerCamelCase            =    SwinvaForMaskedImageModeling(a       )
         model.to(a       )
         model.eval()

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						Any    ,							a						:						int    ,							a						:						Any       ):





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



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




@require_torch
class        a__ (  UpperCAmelCase__				,  UpperCAmelCase__				,  unittest.TestCase					):
     lowerCamelCase    :	Optional[Any]				=(
         (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
     )
     lowerCamelCase    :	Union[str, Any]				=(
         {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
         if is_torch_available()
         else {}
     )

     lowerCamelCase    :	Union[str, Any]				=False
     lowerCamelCase    :	int				=False
     lowerCamelCase    :	int				=False
     lowerCamelCase    :	Union[str, Any]				=False






     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         __lowerCamelCase            =    SwinvaModelTester(self       )
         __lowerCamelCase            =    ConfigTester(self    ,							config_class=a    ,							embed_dim=37       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





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





         """simple docstring"""



         __lowerCamelCase            =    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   SCREAMING_SNAKE_CASE__  (					self						:						List[str]       ):





         """simple docstring"""



         pass






     @unittest.skip(reason='''Swinv2 does not use inputs_embeds'''       )
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         pass






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs_for_common()

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs_for_common()

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

             __lowerCamelCase            =    ['''pixel_values''']
             self.assertListEqual(arg_names[:1]    ,							a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



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

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

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

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

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

             __lowerCamelCase            =    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   SCREAMING_SNAKE_CASE__  (					self						:						int    ,							a						:						List[Any]    ,							a						:						Optional[int]    ,							a						:						int    ,							a						:						Optional[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    model_class(a       )
         model.to(a       )
         model.eval()

         with torch.no_grad():
             __lowerCamelCase            =    model(**self._prepare_for_class(a    ,							a       )       )

         __lowerCamelCase            =    outputs.hidden_states

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

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

         __lowerCamelCase            =    outputs.reshaped_hidden_states
         self.assertEqual(len(a       )    ,							a       )

         __lowerCamelCase      ,    __lowerCamelCase      ,    __lowerCamelCase      ,    __lowerCamelCase            =    reshaped_hidden_states[0].shape
         __lowerCamelCase            =    (
             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   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs_for_common()

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

             self.check_hidden_states_output(a    ,							a    ,							a    ,							a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]       ):





         """simple docstring"""



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

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

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

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*a       )






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs_for_common()

         __lowerCamelCase            =    _config_zero_init(a       )
         for model_class in self.all_model_classes:
             __lowerCamelCase            =    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					):






     @cached_property
     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



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






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



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

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

         # forward pass
         with torch.no_grad():
             __lowerCamelCase            =    model(**a       )

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

'''simple docstring'''




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__UpperCAmelCase					={
    "configuration_efficientnet": [
        "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientNetConfig",
        "EfficientNetOnnxConfig",
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=["EfficientNetImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=[
      "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST",
      "EfficientNetForImageClassification",
      "EfficientNetModel",
      "EfficientNetPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_efficientnet import (
      EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
      EfficientNetConfig,
      EfficientNetOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_efficientnet import EfficientNetImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_efficientnet import (
        EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
        EfficientNetForImageClassification,
        EfficientNetModel,
        EfficientNetPreTrainedModel,
    )

else:
  import sys

  __UpperCAmelCase					=_LazyModule(__name__, globals()["__file__"], _import_structure)
