




'''simple docstring'''




from sklearn.metrics import mean_absolute_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 Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual\nvalues.\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\nReturns:\n    mae : mean absolute error.\n        If multioutput is "raw_values", then mean absolute error is returned for each output separately. If multioutput is "uniform_average" or an ndarray of weights, then the weighted average of all output errors is returned.\n        MAE output is non-negative floating point. The best value is 0.0.\nExamples:\n\n    >>> mae_metric = datasets.load_metric("mae")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mae_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mae\': 0.5}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mae_metric = datasets.load_metric("mae", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mae_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mae\': 0.75}\n    >>> results = mae_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results)\n    {\'mae\': array([0.5, 1. ])}\n'

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,  _KWARGS_DESCRIPTION   )
class 						lowerCAmelCase_   ( datasets.Metric   ):







  '''simple docstring'''







  def 							SCREAMING_SNAKE_CASE__			(						self    :	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_absolute_error.html"""
       ]						,		)


  def 							SCREAMING_SNAKE_CASE__			(						self    :	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 							SCREAMING_SNAKE_CASE__			(						self    :	Dict						,		_UpperCAmelCase    :	Union[str, Any]						,		_UpperCAmelCase    :	Any						,		_UpperCAmelCase    :	Optional[int]=None						,		_UpperCAmelCase    :	Optional[int]="uniform_average" ):






   """simple docstring"""






   UpperCAmelCase__										=    mean_absolute_error(_UpperCAmelCase						,		_UpperCAmelCase						,		sample_weight=_UpperCAmelCase						,		multioutput=_UpperCAmelCase )

   return {"mae": mae_score}






'''simple docstring'''




import collections
import inspect
import unittest

from transformers import SwinConfig
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_backbone_common import BackboneTesterMixin
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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
    from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class 						lowerCAmelCase_   :







  '''simple docstring'''







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






   """simple docstring"""






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


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






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

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

   UpperCAmelCase__										=    self.get_config()

   return config, pixel_values, labels


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   return SwinConfig(
       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						,		out_features=self.out_features						,		out_indices=self.out_indices						,		)


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int						,		_UpperCAmelCase    :	Any						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    SwinModel(config=_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()
   UpperCAmelCase__										=    model(_UpperCAmelCase )

   UpperCAmelCase__										=    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
   UpperCAmelCase__										=    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    :	int						,		_UpperCAmelCase    :	List[Any]						,		_UpperCAmelCase    :	Any						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    SwinBackbone(config=_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()
   UpperCAmelCase__										=    model(_UpperCAmelCase )

   # verify hidden states
   self.parent.assertEqual(len(result.feature_maps )						,		len(config.out_features ) )
   self.parent.assertListEqual(list(result.feature_maps[0].shape )						,		[self.batch_size, model.channels[0], 16, 16] )

   # verify channels
   self.parent.assertEqual(len(model.channels )						,		len(config.out_features ) )

   # verify backbone works with out_features=None
   UpperCAmelCase__										=    None
   UpperCAmelCase__										=    SwinBackbone(config=_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()
   UpperCAmelCase__										=    model(_UpperCAmelCase )

   # verify feature maps
   self.parent.assertEqual(len(result.feature_maps )						,		1 )
   self.parent.assertListEqual(list(result.feature_maps[0].shape )						,		[self.batch_size, model.channels[-1], 4, 4] )

   # verify channels
   self.parent.assertEqual(len(model.channels )						,		1 )


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






   """simple docstring"""






   UpperCAmelCase__										=    SwinForMaskedImageModeling(config=_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()
   UpperCAmelCase__										=    model(_UpperCAmelCase )
   self.parent.assertEqual(
       result.logits.shape						,		(self.batch_size, self.num_channels, self.image_size, self.image_size) )

   # test greyscale images
   UpperCAmelCase__										=    1
   UpperCAmelCase__										=    SwinForMaskedImageModeling(_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()

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


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	List[str]						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	int ):






   """simple docstring"""






   UpperCAmelCase__										=    self.type_sequence_label_size
   UpperCAmelCase__										=    SwinForImageClassification(_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()
   UpperCAmelCase__										=    model(_UpperCAmelCase						,		labels=_UpperCAmelCase )
   self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.type_sequence_label_size) )

   # test greyscale images
   UpperCAmelCase__										=    1
   UpperCAmelCase__										=    SwinForImageClassification(_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()

   UpperCAmelCase__										=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
   UpperCAmelCase__										=    model(_UpperCAmelCase )
   self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.type_sequence_label_size) )



  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.prepare_config_and_inputs()
   (
       (
       UpperCAmelCase__
   )							,			(
       UpperCAmelCase__
   )							,			(
       UpperCAmelCase__
   )							,			
   )										=    config_and_inputs
   UpperCAmelCase__										=    {"""pixel_values""": pixel_values}
   return config, inputs_dict

@require_torch
class 						lowerCAmelCase_   ( lowerCamelCase_			,  lowerCamelCase_			,  unittest.TestCase   ):







  '''simple docstring'''







  lowerCAmelCase_				:					Any				     =						(
      (
          SwinModel,
          SwinBackbone,
          SwinForImageClassification,
          SwinForMaskedImageModeling,
      )
      if is_torch_available()
      else ()
  )
  lowerCAmelCase_				:					str				     =						(
      {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
      if is_torch_available()
      else {}
  )
  lowerCAmelCase_				:					Optional[Any]				     =						True

  lowerCAmelCase_				:					Optional[int]				     =						False
  lowerCAmelCase_				:					List[Any]				     =						False
  lowerCAmelCase_				:					List[Any]				     =						False


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   UpperCAmelCase__										=    SwinModelTester(self )
   UpperCAmelCase__										=    ConfigTester(self						,		config_class=_UpperCAmelCase						,		embed_dim=37 )


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






   """simple docstring"""






   self.create_and_test_config_common_properties()
   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    :	Union[str, Any] ):






   """simple docstring"""






   return


  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*_UpperCAmelCase )


  @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0.""" )
  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str] ):






   """simple docstring"""






   pass


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   super().test_training_gradient_checkpointing()


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_backbone(*_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase )


  @unittest.skip(reason="""Swin does not use inputs_embeds""" )
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






   pass


  @unittest.skip(reason="""Swin Transformer does not use feedforward chunking""" )
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






   pass


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__							,			UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs_for_common()

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


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   UpperCAmelCase__							,			UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs_for_common()

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

    UpperCAmelCase__										=    ["""pixel_values"""]
    self.assertListEqual(arg_names[:1]						,		_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






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

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

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

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

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

    # also another +1 for reshaped_hidden_states
    UpperCAmelCase__										=    1 if model_class.__name__ == """SwinBackbone""" else 2
    self.assertEqual(out_len + added_hidden_states						,		len(_UpperCAmelCase ) )

    UpperCAmelCase__										=    outputs.attentions

    self.assertEqual(len(_UpperCAmelCase )						,		_UpperCAmelCase )

    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    :	Any						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	Optional[int]						,		_UpperCAmelCase    :	str						,		_UpperCAmelCase    :	Dict ):






   """simple docstring"""






   UpperCAmelCase__										=    model_class(_UpperCAmelCase )
   model.to(_UpperCAmelCase )
   model.eval()

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

   UpperCAmelCase__										=    outputs.hidden_states

   UpperCAmelCase__										=    getattr(
       self.model_tester						,		"""expected_num_hidden_layers"""						,		len(self.model_tester.depths ) + 1 )
   self.assertEqual(len(_UpperCAmelCase )						,		_UpperCAmelCase )

   # Swin has a different seq_length
   UpperCAmelCase__										=    (
       config.patch_size
       if isinstance(config.patch_size						,		collections.abc.Iterable )
       else (config.patch_size, config.patch_size)
   )

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

   if not model_class.__name__ == "SwinBackbone":
    UpperCAmelCase__										=    outputs.reshaped_hidden_states
    self.assertEqual(len(_UpperCAmelCase )						,		_UpperCAmelCase )

    UpperCAmelCase__							,			UpperCAmelCase__							,			UpperCAmelCase__							,			UpperCAmelCase__										=    reshaped_hidden_states[0].shape
    UpperCAmelCase__										=    (
        reshaped_hidden_states[0].view(_UpperCAmelCase						,		_UpperCAmelCase						,		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    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__							,			UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs_for_common()

   UpperCAmelCase__										=    (
       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__										=    True
    self.check_hidden_states_output(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase )

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

    self.check_hidden_states_output(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase )


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






   """simple docstring"""






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

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

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

   for model_class in self.all_model_classes:
    UpperCAmelCase__										=    True
    self.check_hidden_states_output(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase						,		(padded_height, padded_width) )

    # check that output_hidden_states also work using config
    del inputs_dict["output_hidden_states"]
    UpperCAmelCase__										=    True
    self.check_hidden_states_output(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase						,		(padded_height, padded_width) )


  @slow
  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str] ):






   """simple docstring"""






   for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    UpperCAmelCase__										=    SwinModel.from_pretrained(_UpperCAmelCase )
    self.assertIsNotNone(_UpperCAmelCase )



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






   """simple docstring"""






   UpperCAmelCase__							,			UpperCAmelCase__										=    self.model_tester.prepare_config_and_inputs_for_common()

   UpperCAmelCase__										=    _config_zero_init(_UpperCAmelCase )
   for model_class in self.all_model_classes:
    UpperCAmelCase__										=    model_class(config=_UpperCAmelCase )
    for name, param in model.named_parameters():
     if "embeddings" 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 						lowerCAmelCase_   ( unittest.TestCase   ):







  '''simple docstring'''







  @cached_property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   return (
       AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224""" )
       if is_vision_available()
       else None
   )



  @slow
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Dict ):






   """simple docstring"""






   UpperCAmelCase__										=    SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224""" ).to(_UpperCAmelCase )
   UpperCAmelCase__										=    self.default_image_processor

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

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

   # verify the logits
   UpperCAmelCase__										=    torch.Size((1, 10_00) )
   self.assertEqual(outputs.logits.shape						,		_UpperCAmelCase )
   UpperCAmelCase__										=    torch.tensor([-0.0948, -0.6454, -0.0921] ).to(_UpperCAmelCase )
   self.assertTrue(torch.allclose(outputs.logits[0, :3]						,		_UpperCAmelCase						,		atol=1E-4 ) )

@require_torch
class 						lowerCAmelCase_   ( unittest.TestCase			,  lowerCamelCase_   ):







  '''simple docstring'''







  lowerCAmelCase_				:					Dict				     =						(SwinBackbone,) if is_torch_available() else ()
  lowerCAmelCase_				:					Tuple				     =						SwinConfig


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   UpperCAmelCase__										=    SwinModelTester(self )
