



"""simple docstring"""
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_UpperCAmelCase     =			logging.get_logger(__name__)

_UpperCAmelCase     =			{
    """google/mobilenet_v1_1.0_224""": """https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json""",
    """google/mobilenet_v1_0.75_192""": """https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json""",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}
class 					a	(  UpperCAmelCase__       ):

  '''simple docstring'''





  UpperCamelCase	:				Optional[Any]     						=					'mobilenet_v1'



  def __init__(						self :					int       ,		lowerCAmelCase :					List[str]=3       ,		lowerCAmelCase :					Dict=224       ,		lowerCAmelCase :					Tuple=1.0       ,		lowerCAmelCase :					int=8       ,		lowerCAmelCase :					Any="relu6"       ,		lowerCAmelCase :					Any=True       ,		lowerCAmelCase :					List[str]=0.9_9_9       ,		lowerCAmelCase :					Union[str, Any]=0.0_2       ,		lowerCAmelCase :					Tuple=0.0_0_1       ,		**lowerCAmelCase :					List[Any]       ,		)     ->					Union[str, Any]:


     '''simple docstring'''




     super().__init__(**lowerCAmelCase		)

     if depth_multiplier <= 0:
        raise ValueError("""depth_multiplier must be greater than zero."""		)

     SCREAMING_SNAKE_CASE_: List[str]     			=num_channels
     SCREAMING_SNAKE_CASE_: List[Any]     			=image_size
     SCREAMING_SNAKE_CASE_: List[str]     			=depth_multiplier
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=min_depth
     SCREAMING_SNAKE_CASE_: Tuple     			=hidden_act
     SCREAMING_SNAKE_CASE_: List[str]     			=tf_padding
     SCREAMING_SNAKE_CASE_: int     			=classifier_dropout_prob
     SCREAMING_SNAKE_CASE_: Any     			=initializer_range
     SCREAMING_SNAKE_CASE_: Dict     			=layer_norm_eps







class 					a	(  UpperCAmelCase__       ):

  '''simple docstring'''





  UpperCamelCase	:				int     						=					version.parse('1.11'       )



  @property
  def 	lowerCamelCase__       (						self :					List[str]		)     ->					Mapping[str, Mapping[int, str]]:


     '''simple docstring'''




     return OrderedDict([("""pixel_values""", {0: """batch"""})]		)



  @property
  def 	lowerCamelCase__       (						self :					Optional[int]		)     ->					Mapping[str, Mapping[int, str]]:


     '''simple docstring'''




     if self.task == "image-classification":
        return OrderedDict([("""logits""", {0: """batch"""})]		)
     else:
        return OrderedDict([("""last_hidden_state""", {0: """batch"""}), ("""pooler_output""", {0: """batch"""})]		)





  @property
  def 	lowerCamelCase__       (						self :					Tuple		)     ->					float:


     '''simple docstring'''




     return 1E-4








"""simple docstring"""
import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import SwiftFormerForImageClassification, SwiftFormerModel
   from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import ViTImageProcessor
class 					a	:



  def __init__(						self :					Any       ,		lowerCAmelCase :					Any       ,		lowerCAmelCase :					List[str]=13       ,		lowerCAmelCase :					Dict=3       ,		lowerCAmelCase :					Optional[Any]=True       ,		lowerCAmelCase :					Dict=True       ,		lowerCAmelCase :					Dict=0.1       ,		lowerCAmelCase :					str=0.1       ,		lowerCAmelCase :					List[str]=224       ,		lowerCAmelCase :					List[str]=1000       ,		lowerCAmelCase :					Optional[Any]=[3, 3, 6, 4]       ,		lowerCAmelCase :					int=[48, 56, 112, 220]       ,		)     ->					List[str]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Optional[int]     			=parent
     SCREAMING_SNAKE_CASE_: Any     			=batch_size
     SCREAMING_SNAKE_CASE_: Tuple     			=num_channels
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=is_training
     SCREAMING_SNAKE_CASE_: Tuple     			=use_labels
     SCREAMING_SNAKE_CASE_: Optional[int]     			=hidden_dropout_prob
     SCREAMING_SNAKE_CASE_: Tuple     			=attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE_: List[Any]     			=num_labels
     SCREAMING_SNAKE_CASE_: int     			=image_size
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=layer_depths
     SCREAMING_SNAKE_CASE_: List[Any]     			=embed_dims



  def 	lowerCamelCase__       (						self :					List[Any]		)     ->					int:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: List[str]     			=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

     SCREAMING_SNAKE_CASE_: List[Any]     			=None
     if self.use_labels:
        SCREAMING_SNAKE_CASE_: List[str]     			=ids_tensor([self.batch_size]       ,		self.num_labels		)

     SCREAMING_SNAKE_CASE_: Tuple     			=self.get_config()

     return config, pixel_values, labels



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


     '''simple docstring'''




     return SwiftFormerConfig(
         depths=self.layer_depths       ,		embed_dims=self.embed_dims       ,		mlp_ratio=4       ,		downsamples=[True, True, True, True]       ,		hidden_act="""gelu"""       ,		num_labels=self.num_labels       ,		down_patch_size=3       ,		down_stride=2       ,		down_pad=1       ,		drop_rate=0.0       ,		drop_path_rate=0.0       ,		use_layer_scale=lowerCAmelCase       ,		layer_scale_init_value=1E-5       ,		)



  def 	lowerCamelCase__       (						self :					Any       ,		lowerCAmelCase :					Union[str, Any]       ,		lowerCAmelCase :					Optional[Any]       ,		lowerCAmelCase :					Optional[int]		)     ->					Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: List[str]     			=SwiftFormerModel(config=lowerCAmelCase		)
     model.to(lowerCAmelCase		)
     model.eval()
     SCREAMING_SNAKE_CASE_: Any     			=model(lowerCAmelCase		)
     self.parent.assertEqual(result.last_hidden_state.shape       ,		(self.batch_size, self.embed_dims[-1], 7, 7)		)



  def 	lowerCamelCase__       (						self :					Union[str, Any]       ,		lowerCAmelCase :					List[Any]       ,		lowerCAmelCase :					Optional[int]       ,		lowerCAmelCase :					Union[str, Any]		)     ->					Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: List[Any]     			=self.num_labels
     SCREAMING_SNAKE_CASE_: Dict     			=SwiftFormerForImageClassification(lowerCAmelCase		)
     model.to(lowerCAmelCase		)
     model.eval()
     SCREAMING_SNAKE_CASE_: Dict     			=model(lowerCAmelCase       ,		labels=lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)		)

     SCREAMING_SNAKE_CASE_: int     			=SwiftFormerForImageClassification(lowerCAmelCase		)
     model.to(lowerCAmelCase		)
     model.eval()

     SCREAMING_SNAKE_CASE_: Tuple     			=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
     SCREAMING_SNAKE_CASE_: Dict     			=model(lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)		)





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


     '''simple docstring'''




     ((SCREAMING_SNAKE_CASE_)			,		(SCREAMING_SNAKE_CASE_)			,		(SCREAMING_SNAKE_CASE_)): str     			=self.prepare_config_and_inputs()
     SCREAMING_SNAKE_CASE_: Tuple     			={"""pixel_values""": pixel_values}
     return config, inputs_dict







@require_torch
class 					a	(  UpperCAmelCase__	,      UpperCAmelCase__	,      unittest.TestCase       ):
  UpperCamelCase	:				Optional[int]     						=					(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
  UpperCamelCase	:				Tuple     						=					(
      {'feature-extraction': SwiftFormerModel, 'image-classification': SwiftFormerForImageClassification}
      if is_torch_available()
      else {}
  )

  UpperCamelCase	:				Any     						=					False
  UpperCamelCase	:				Optional[int]     						=					False
  UpperCamelCase	:				Optional[Any]     						=					False
  UpperCamelCase	:				Dict     						=					False
  UpperCamelCase	:				List[str]     						=					False



  def 	lowerCamelCase__       (						self :					Dict		)     ->					Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Dict     			=SwiftFormerModelTester(self		)
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=ConfigTester(
         self       ,		config_class=lowerCAmelCase       ,		has_text_modality=lowerCAmelCase       ,		hidden_size=37       ,		num_attention_heads=12       ,		num_hidden_layers=12       ,		)



  def 	lowerCamelCase__       (						self :					Tuple		)     ->					int:


     '''simple docstring'''




     self.config_tester.run_common_tests()



  @unittest.skip(reason="""SwiftFormer does not use inputs_embeds"""		)
  def 	lowerCamelCase__       (						self :					Tuple		)     ->					List[str]:


     '''simple docstring'''




     pass



  def 	lowerCamelCase__       (						self :					Optional[int]		)     ->					Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_			,		SCREAMING_SNAKE_CASE_: List[str]     			=self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        SCREAMING_SNAKE_CASE_: Any     			=model_class(lowerCAmelCase		)
        SCREAMING_SNAKE_CASE_: List[Any]     			=model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(lowerCAmelCase       ,		nn.Linear		)		)



  def 	lowerCamelCase__       (						self :					str		)     ->					Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_			,		SCREAMING_SNAKE_CASE_: List[Any]     			=self.model_tester.prepare_config_and_inputs_for_common()

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

        SCREAMING_SNAKE_CASE_: Tuple     			=["""pixel_values"""]
        self.assertListEqual(arg_names[:1]       ,		lowerCAmelCase		)



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


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Dict     			=self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase		)



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


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: int     			=self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase		)



  @slow
  def 	lowerCamelCase__       (						self :					Optional[Any]		)     ->					List[str]:


     '''simple docstring'''




     for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=SwiftFormerModel.from_pretrained(lowerCAmelCase		)
        self.assertIsNotNone(lowerCAmelCase		)



  @unittest.skip(reason="""SwiftFormer does not output attentions"""		)
  def 	lowerCamelCase__       (						self :					Optional[int]		)     ->					str:


     '''simple docstring'''




     pass



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


     '''simple docstring'''




     def check_hidden_states_output(lowerCAmelCase :					Optional[int]       ,		lowerCAmelCase :					str       ,		lowerCAmelCase :					Optional[int]		):
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=model_class(lowerCAmelCase		)
        model.to(lowerCAmelCase		)
        model.eval()

        with torch.no_grad():
           SCREAMING_SNAKE_CASE_: List[str]     			=model(**self._prepare_for_class(lowerCAmelCase       ,		lowerCAmelCase		)		)

        SCREAMING_SNAKE_CASE_: Dict     			=outputs.hidden_states

        SCREAMING_SNAKE_CASE_: List[Any]     			=8
        self.assertEqual(len(lowerCAmelCase		)       ,		lowerCAmelCase		)  # TODO

        # SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
        # with the width and height being successively divided by 2, after every 2 blocks
        for i in range(len(lowerCAmelCase		)		):
           self.assertEqual(
               hidden_states[i].shape       ,		torch.Size(
                   [
                       self.model_tester.batch_size,
                       self.model_tester.embed_dims[i // 2],
                       (self.model_tester.image_size // 4) // 2 ** (i // 2),
                       (self.model_tester.image_size // 4) // 2 ** (i // 2),
                   ]		)       ,		)

     SCREAMING_SNAKE_CASE_			,		SCREAMING_SNAKE_CASE_: int     			=self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        SCREAMING_SNAKE_CASE_: Dict     			=True
        check_hidden_states_output(lowerCAmelCase       ,		lowerCAmelCase       ,		lowerCAmelCase		)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        SCREAMING_SNAKE_CASE_: Any     			=True

        check_hidden_states_output(lowerCAmelCase       ,		lowerCAmelCase       ,		lowerCAmelCase		)



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


     '''simple docstring'''




     def _config_zero_init(lowerCAmelCase :					str		):
        SCREAMING_SNAKE_CASE_: Dict     			=copy.deepcopy(lowerCAmelCase		)
        for key in configs_no_init.__dict__.keys():
           if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
              setattr(lowerCAmelCase       ,		lowerCAmelCase       ,		1E-10		)
           if isinstance(getattr(lowerCAmelCase       ,		lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		):
              SCREAMING_SNAKE_CASE_: Tuple     			=_config_zero_init(getattr(lowerCAmelCase       ,		lowerCAmelCase		)		)
              setattr(lowerCAmelCase       ,		lowerCAmelCase       ,		lowerCAmelCase		)
        return configs_no_init

     SCREAMING_SNAKE_CASE_			,		SCREAMING_SNAKE_CASE_: Optional[Any]     			=self.model_tester.prepare_config_and_inputs_for_common()

     SCREAMING_SNAKE_CASE_: List[Any]     			=_config_zero_init(lowerCAmelCase		)
     for model_class in self.all_model_classes:
        SCREAMING_SNAKE_CASE_: Any     			=model_class(config=lowerCAmelCase		)
        for name, param in model.named_parameters():
           if param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1E9) / 1E9).round().item()       ,		[0.0, 1.0]       ,		msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''       ,		)





  @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""		)
  def 	lowerCamelCase__       (						self :					List[str]		)     ->					List[str]:


     '''simple docstring'''




     pass







def      __magic_name__				(							):
   SCREAMING_SNAKE_CASE_: List[Any]     			=Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
   return image
@require_torch
@require_vision
class 					a	(  unittest.TestCase       ):



  @cached_property
  def 	lowerCamelCase__       (						self :					str		)     ->					str:


     '''simple docstring'''




     return ViTImageProcessor.from_pretrained("""MBZUAI/swiftformer-xs"""		) if is_vision_available() else None





  @slow
  def 	lowerCamelCase__       (						self :					Union[str, Any]		)     ->					Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: str     			=SwiftFormerForImageClassification.from_pretrained("""MBZUAI/swiftformer-xs"""		).to(lowerCAmelCase		)

     SCREAMING_SNAKE_CASE_: str     			=self.default_image_processor
     SCREAMING_SNAKE_CASE_: int     			=prepare_img()
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=image_processor(images=lowerCAmelCase       ,		return_tensors="""pt"""		).to(lowerCAmelCase		)

     # forward pass
     with torch.no_grad():
        SCREAMING_SNAKE_CASE_: Dict     			=model(**lowerCAmelCase		)

     # verify the logits
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=torch.Size((1, 1000)		)
     self.assertEqual(outputs.logits.shape       ,		lowerCAmelCase		)

     SCREAMING_SNAKE_CASE_: List[str]     			=torch.tensor([[-2.1_703E00, 2.1_107E00, -2.0_811E00]]		).to(lowerCAmelCase		)
     self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,		lowerCAmelCase       ,		atol=1E-4		)		)



