



'''simple docstring'''





from sklearn.metrics import mean_squared_error

import datasets


lowercase_									=    "\\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"

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


lowercase_									=    "\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    a__    (self			)       ->	str:


      """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    a__    (self			)       ->	int:


      """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    a__    (self					,  A					,  A					,  A=None					,  A="uniform_average"					,  A=True			)       ->	str:


      """simple docstring"""



      _a           =    mean_squared_error(
          A					,  A					,  sample_weight=A					,  multioutput=A					,  squared=A			)

      return {"mse": mse}










"""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 						lowercase   :





      def __init__(			self ,		lowercase ,		lowercase=13 ,		lowercase=32 ,		lowercase=2 ,		lowercase=3 ,		lowercase=16 ,		lowercase=[1, 2, 1] ,		lowercase=[2, 2, 4] ,		lowercase=2 ,		lowercase=2.0 ,		lowercase=True ,		lowercase=0.0 ,		lowercase=0.0 ,		lowercase=0.1 ,		lowercase="gelu" ,		lowercase=False ,		lowercase=True ,		lowercase=0.02 ,		lowercase=1e-5 ,		lowercase=True ,		lowercase=None ,		lowercase=True ,		lowercase=10 ,		lowercase=8 ,		)						->	Union[str, Any]:
            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        _snake_case     (			self					)						->	Tuple:
            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        _snake_case     (			self					)						->	str:
            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 ,		lowercase ,		lowercase ,		lowercase					)						->	Tuple:
            lowerCAmelCase    		=			SwinvaModel(config=lowercase					)
            model.to(lowercase					)
            model.eval()
            lowerCAmelCase    		=			model(lowercase					)

            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        _snake_case     (			self ,		lowercase ,		lowercase ,		lowercase					)						->	str:
            lowerCAmelCase    		=			SwinvaForMaskedImageModeling(config=lowercase					)
            model.to(lowercase					)
            model.eval()
            lowerCAmelCase    		=			model(lowercase					)
            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(lowercase					)
            model.to(lowercase					)
            model.eval()

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





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		lowercase					)						->	Dict:
            lowerCAmelCase    		=			self.type_sequence_label_size
            lowerCAmelCase    		=			SwinvaForImageClassification(lowercase					)
            model.to(lowercase					)
            model.eval()
            lowerCAmelCase    		=			model(lowercase ,		labels=lowercase					)
            self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.type_sequence_label_size)					)





      def        _snake_case     (			self					)						->	Tuple:
            lowerCAmelCase    		=			self.prepare_config_and_inputs()
            lowerCAmelCase		,						lowerCAmelCase		,						lowerCAmelCase    		=			config_and_inputs
            lowerCAmelCase    		=			{"""pixel_values""": pixel_values}
            return config, inputs_dict







@require_torch
class 						lowercase   (   _UpperCAmelCase	,    _UpperCAmelCase	,    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					)						->	Any:
            lowerCAmelCase    		=			SwinvaModelTester(self					)
            lowerCAmelCase    		=			ConfigTester(self ,		config_class=lowercase ,		embed_dim=37					)





      def        _snake_case     (			self					)						->	Tuple:
            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					)						->	int:
            lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowercase					)





      @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""					)
      def        _snake_case     (			self					)						->	str:
            pass





      @unittest.skip(reason="""Swinv2 does not use inputs_embeds"""					)
      def        _snake_case     (			self					)						->	str:
            pass





      def        _snake_case     (			self					)						->	Tuple:
            lowerCAmelCase		,						lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs_for_common()

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





      def        _snake_case     (			self					)						->	Optional[int]:
            lowerCAmelCase		,						lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  lowerCAmelCase    		=			model_class(lowercase					)
                  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] ,		lowercase					)





      def        _snake_case     (			self					)						->	Tuple:
            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(lowercase					)
                  model.to(lowercase					)
                  model.eval()
                  with torch.no_grad():
                        lowerCAmelCase    		=			model(**self._prepare_for_class(lowercase ,		lowercase					)					)
                  lowerCAmelCase    		=			outputs.attentions
                  lowerCAmelCase    		=			len(self.model_tester.depths					)
                  self.assertEqual(len(lowercase					) ,		lowercase					)

                  # check that output_attentions also work using config
                  del inputs_dict["output_attentions"]
                  lowerCAmelCase    		=			True
                  lowerCAmelCase    		=			config.window_size**2
                  lowerCAmelCase    		=			model_class(lowercase					)
                  model.to(lowercase					)
                  model.eval()
                  with torch.no_grad():
                        lowerCAmelCase    		=			model(**self._prepare_for_class(lowercase ,		lowercase					)					)
                  lowerCAmelCase    		=			outputs.attentions
                  self.assertEqual(len(lowercase					) ,		lowercase					)

                  self.assertListEqual(
                      list(attentions[0].shape[-3:]					) ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,		)
                  lowerCAmelCase    		=			len(lowercase					)

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

                  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(lowercase					)					)

                  lowerCAmelCase    		=			outputs.attentions

                  self.assertEqual(len(lowercase					) ,		lowercase					)

                  self.assertListEqual(
                      list(self_attentions[0].shape[-3:]					) ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,		)





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		lowercase ,		lowercase					)						->	List[str]:
            lowerCAmelCase    		=			model_class(lowercase					)
            model.to(lowercase					)
            model.eval()

            with torch.no_grad():
                  lowerCAmelCase    		=			model(**self._prepare_for_class(lowercase ,		lowercase					)					)

            lowerCAmelCase    		=			outputs.hidden_states

            lowerCAmelCase    		=			getattr(
                self.model_tester ,		"""expected_num_hidden_layers""" ,		len(self.model_tester.depths					) + 1					)
            self.assertEqual(len(lowercase					) ,		lowercase					)

            # 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(lowercase					) ,		lowercase					)

            lowerCAmelCase		,						lowerCAmelCase		,						lowerCAmelCase		,						lowerCAmelCase    		=			reshaped_hidden_states[0].shape
            lowerCAmelCase    		=			(
                reshaped_hidden_states[0].view(lowercase ,		lowercase ,		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					)						->	Dict:
            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(lowercase ,		lowercase ,		lowercase ,		lowercase					)

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  lowerCAmelCase    		=			True

                  self.check_hidden_states_output(lowercase ,		lowercase ,		lowercase ,		lowercase					)





      def        _snake_case     (			self					)						->	int:
            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(lowercase ,		lowercase ,		lowercase ,		(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(lowercase ,		lowercase ,		lowercase ,		(padded_height, padded_width)					)





      def        _snake_case     (			self					)						->	Any:
            lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*lowercase					)





      def        _snake_case     (			self					)						->	Tuple:
            lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*lowercase					)





      @slow
      def        _snake_case     (			self					)						->	Any:
            for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowerCAmelCase    		=			SwinvaModel.from_pretrained(lowercase					)
                  self.assertIsNotNone(lowercase					)





      def        _snake_case     (			self					)						->	Any:
            lowerCAmelCase		,						lowerCAmelCase    		=			self.model_tester.prepare_config_and_inputs_for_common()

            lowerCAmelCase    		=			_config_zero_init(lowercase					)
            for model_class in self.all_model_classes:
                  lowerCAmelCase    		=			model_class(config=lowercase					)
                  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 						lowercase   (   unittest.TestCase   ):





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





      @slow
      def        _snake_case     (			self					)						->	Tuple:
            lowerCAmelCase    		=			SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""					).to(
                lowercase					)
            lowerCAmelCase    		=			self.default_image_processor

            lowerCAmelCase    		=			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
            lowerCAmelCase    		=			image_processor(images=lowercase ,		return_tensors="""pt"""					).to(lowercase					)

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

            # verify the logits
            lowerCAmelCase    		=			torch.Size((1, 1_000)					)
            self.assertEqual(outputs.logits.shape ,		lowercase					)
            lowerCAmelCase    		=			torch.tensor([-0.3_947, -0.4_306, 0.0_026]					).to(lowercase					)
            self.assertTrue(torch.allclose(outputs.logits[0, :3] ,		lowercase ,		atol=1e-4					)					)






