



"""simple docstring"""
from sklearn.metrics import mean_squared_error

import datasets


_UpperCAmelCase     =			"\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n"

_UpperCAmelCase     =			"\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n"


_UpperCAmelCase     =			"\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {\"raw_values\", \"uniform_average\"} or array-like of shape (n_outputs,), default=\"uniform_average\"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        \"raw_values\" : Returns a full set of errors in case of multioutput input.\n\n        \"uniform_average\" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric(\"mse\")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'mse': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {'mse': 0.6123724356957945}\n\n    If you're using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric(\"mse\", \"multilist\")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'mse': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput='raw_values')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {'mse': array([0.41666667, 1. ])}\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	,      _KWARGS_DESCRIPTION       )
class 					a	(  datasets.Metric       ):

  '''simple docstring'''





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


     '''simple docstring'''




     return datasets.MetricInfo(
         description=_DESCRIPTION       ,		citation=_CITATION       ,		inputs_description=_KWARGS_DESCRIPTION       ,		features=datasets.Features(self._get_feature_types()		)       ,		reference_urls=[
             """https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html"""
         ]       ,		)



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


     '''simple docstring'''




     if self.config_name == "multilist":
        return {
            "predictions": datasets.Sequence(datasets.Value("""float"""		)		),
            "references": datasets.Sequence(datasets.Value("""float"""		)		),
        }
     else:
        return {
            "predictions": datasets.Value("""float"""		),
            "references": datasets.Value("""float"""		),
        }





  def 	lowerCamelCase__       (						self :					Union[str, Any]       ,		lowerCAmelCase :					Union[str, Any]       ,		lowerCAmelCase :					Tuple       ,		lowerCAmelCase :					Any=None       ,		lowerCAmelCase :					Optional[Any]="uniform_average"       ,		lowerCAmelCase :					Any=True		)     ->					Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: str     			=mean_squared_error(
         __lowerCamelCase       ,		__lowerCamelCase       ,		sample_weight=__lowerCamelCase       ,		multioutput=__lowerCamelCase       ,		squared=__lowerCamelCase		)

     return {"mse": mse}








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



