


'''simple docstring'''



import os
import time

import pytest

from datasets.utils.filelock import FileLock, Timeout



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Tuple				)	->						int:
     __lowerCamelCase  :      Dict														=						FileLock(str(tmpdir / 'foo.lock'				)				)
     __lowerCamelCase  :      Optional[Any]														=						FileLock(str(tmpdir / 'foo.lock'				)				)
     __lowerCamelCase  :      Optional[int]														=						0.01
     with locka.acquire():
          with pytest.raises(UpperCAmelCase_				):
               __lowerCamelCase  :      List[str]														=						time.time()
               locka.acquire(UpperCAmelCase_				)
               assert time.time() - _start > timeout



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Optional[Any]				)	->						Dict:
     __lowerCamelCase  :      List[Any]														=						'a' * 10_00 + '.lock'
     __lowerCamelCase  :      Optional[Any]														=						FileLock(str(tmpdir / filename				)				)
     assert locka._lock_file.endswith('.lock'				)
     assert not locka._lock_file.endswith(UpperCAmelCase_				)
     assert len(os.path.basename(locka._lock_file				)				) <= 2_55
     __lowerCamelCase  :      Tuple														=						FileLock(tmpdir / filename				)
     with locka.acquire():
          with pytest.raises(UpperCAmelCase_				):
               locka.acquire(0				)










'''simple docstring'''



import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
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 MaskFormerSwinBackbone
      from transformers.models.maskformer import MaskFormerSwinModel





class   UpperCAmelCase_    :





    """simple docstring"""






    def __init__(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=13     ,	SCREAMING_SNAKE_CASE_=32     ,	SCREAMING_SNAKE_CASE_=2     ,	SCREAMING_SNAKE_CASE_=3     ,	SCREAMING_SNAKE_CASE_=16     ,	SCREAMING_SNAKE_CASE_=[1, 2, 1]     ,	SCREAMING_SNAKE_CASE_=[2, 2, 4]     ,	SCREAMING_SNAKE_CASE_=2     ,	SCREAMING_SNAKE_CASE_=2.0     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=0.1     ,	SCREAMING_SNAKE_CASE_="gelu"     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=0.0_2     ,	SCREAMING_SNAKE_CASE_=1E-5     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=10     ,	SCREAMING_SNAKE_CASE_=8     ,	SCREAMING_SNAKE_CASE_=["stage1", "stage2", "stage3"]     ,	SCREAMING_SNAKE_CASE_=[1, 2, 3]     ,	)							->	Any:
         __lowerCamelCase  :      Optional[Any]														=						parent
         __lowerCamelCase  :      int														=						batch_size
         __lowerCamelCase  :      Optional[int]														=						image_size
         __lowerCamelCase  :      Optional[int]														=						patch_size
         __lowerCamelCase  :      Optional[Any]														=						num_channels
         __lowerCamelCase  :      Dict														=						embed_dim
         __lowerCamelCase  :      List[Any]														=						depths
         __lowerCamelCase  :      int														=						num_heads
         __lowerCamelCase  :      Optional[Any]														=						window_size
         __lowerCamelCase  :      Optional[Any]														=						mlp_ratio
         __lowerCamelCase  :      List[str]														=						qkv_bias
         __lowerCamelCase  :      List[str]														=						hidden_dropout_prob
         __lowerCamelCase  :      int														=						attention_probs_dropout_prob
         __lowerCamelCase  :      List[Any]														=						drop_path_rate
         __lowerCamelCase  :      Any														=						hidden_act
         __lowerCamelCase  :      Union[str, Any]														=						use_absolute_embeddings
         __lowerCamelCase  :      Any														=						patch_norm
         __lowerCamelCase  :      Optional[Any]														=						layer_norm_eps
         __lowerCamelCase  :      str														=						initializer_range
         __lowerCamelCase  :      Dict														=						is_training
         __lowerCamelCase  :      Optional[Any]														=						scope
         __lowerCamelCase  :      Dict														=						use_labels
         __lowerCamelCase  :      List[str]														=						type_sequence_label_size
         __lowerCamelCase  :      Dict														=						encoder_stride
         __lowerCamelCase  :      Union[str, Any]														=						out_features
         __lowerCamelCase  :      str														=						out_indices







    def  lowercase_							(				self      )							->	Optional[Any]:
         __lowerCamelCase  :      int														=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

         __lowerCamelCase  :      List[str]														=						self.get_config()

         return config, pixel_values, labels







    def  lowercase_							(				self      )							->	Optional[int]:
         return MaskFormerSwinConfig(
             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  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )							->	int:
         __lowerCamelCase  :      Dict														=						MaskFormerSwinModel(config=SCREAMING_SNAKE_CASE_      )
         model.to(SCREAMING_SNAKE_CASE_      )
         model.eval()
         __lowerCamelCase  :      Dict														=						model(SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      Optional[int]														=						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
         __lowerCamelCase  :      Dict														=						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  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )							->	Optional[Any]:
         __lowerCamelCase  :      Tuple														=						MaskFormerSwinBackbone(config=SCREAMING_SNAKE_CASE_      )
         model.to(SCREAMING_SNAKE_CASE_      )
         model.eval()
         __lowerCamelCase  :      Any														=						model(SCREAMING_SNAKE_CASE_      )

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps      )     ,	len(config.out_features      )      )
         self.parent.assertListEqual(list(result.feature_maps[0].shape      )     ,	[13, 16, 16, 16]      )

         # verify channels
         self.parent.assertEqual(len(model.channels      )     ,	len(config.out_features      )      )
         self.parent.assertListEqual(model.channels     ,	[16, 32, 64]      )

         # verify ValueError
         with self.parent.assertRaises(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      str														=						['stem']
              __lowerCamelCase  :      Optional[Any]														=						MaskFormerSwinBackbone(config=SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	Union[str, Any]:
         __lowerCamelCase  :      Optional[int]														=						self.prepare_config_and_inputs()
         __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase  :      Optional[Any]														=						config_and_inputs
         __lowerCamelCase  :      Optional[int]														=						{'pixel_values': pixel_values}
         return config, inputs_dict







@require_torch
class   UpperCAmelCase_    (_UpperCAmelCase   ,						_UpperCAmelCase   ,						unittest.TestCase    ):





    """simple docstring"""






    lowerCamelCase    :   List[Any]					=     (
        (
            MaskFormerSwinModel,
            MaskFormerSwinBackbone,
        )
        if is_torch_available()
        else ()
    )
    lowerCamelCase    :   int					=     {'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
    lowerCamelCase    :   int					=     False
    lowerCamelCase    :   int					=     False
    lowerCamelCase    :   str					=     False
    lowerCamelCase    :   int					=     False
    lowerCamelCase    :   Union[str, Any]					=     False







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase  :      Optional[Any]														=						MaskFormerSwinModelTester(self      )
         __lowerCamelCase  :      Optional[Any]														=						ConfigTester(self     ,	config_class=SCREAMING_SNAKE_CASE_     ,	embed_dim=37      )







    @require_torch_multi_gpu
    @unittest.skip(
        reason=(
            '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
            ' `nn.DataParallel`'
        )      )
    def  lowercase_							(				self      )							->	int:
         pass







    def  lowercase_							(				self      )							->	Union[str, Any]:
         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  lowercase_							(				self      )							->	Tuple:
         return







    def  lowercase_							(				self      )							->	Dict:
         __lowerCamelCase  :      List[str]														=						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	List[str]:
         __lowerCamelCase  :      int														=						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_      )







    @unittest.skip('Swin does not use inputs_embeds'      )
    def  lowercase_							(				self      )							->	Optional[int]:
         pass







    @unittest.skip('Swin does not support feedforward chunking'      )
    def  lowercase_							(				self      )							->	Dict:
         pass







    def  lowercase_							(				self      )							->	Union[str, Any]:
         __lowerCamelCase							,			__lowerCamelCase  :      Dict														=						self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              __lowerCamelCase  :      Dict														=						model_class(SCREAMING_SNAKE_CASE_      )
              self.assertIsInstance(model.get_input_embeddings()     ,	(nn.Module)      )
              __lowerCamelCase  :      Optional[Any]														=						model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_     ,	nn.Linear      )      )







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

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

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







    @unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'      )
    def  lowercase_							(				self      )							->	Any:
         pass







    @unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'      )
    def  lowercase_							(				self      )							->	List[Any]:
         pass







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )							->	List[str]:
         __lowerCamelCase  :      Tuple														=						model_class(SCREAMING_SNAKE_CASE_      )
         model.to(SCREAMING_SNAKE_CASE_      )
         model.eval()

         with torch.no_grad():
              __lowerCamelCase  :      Optional[int]														=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )      )

         __lowerCamelCase  :      int														=						outputs.hidden_states

         __lowerCamelCase  :      Tuple														=						getattr(
             self.model_tester     ,	'expected_num_hidden_layers'     ,	len(self.model_tester.depths      ) + 1      )
         self.assertEqual(len(SCREAMING_SNAKE_CASE_      )     ,	SCREAMING_SNAKE_CASE_      )

         # Swin has a different seq_length
         __lowerCamelCase  :      Optional[Any]														=						(
             config.patch_size
             if isinstance(config.patch_size     ,	collections.abc.Iterable      )
             else (config.patch_size, config.patch_size)
         )

         __lowerCamelCase  :      List[Any]														=						(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]     ,	)







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase							,			__lowerCamelCase  :      Dict														=						self.model_tester.prepare_config_and_inputs_for_common()

         __lowerCamelCase  :      List[Any]														=						(
             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  :      Dict														=						True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              __lowerCamelCase  :      Optional[int]														=						True

              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	Any:
         __lowerCamelCase							,			__lowerCamelCase  :      Any														=						self.model_tester.prepare_config_and_inputs_for_common()
         __lowerCamelCase  :      Union[str, Any]														=						3

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

         __lowerCamelCase  :      Optional[int]														=						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         __lowerCamelCase  :      str														=						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
              __lowerCamelCase  :      str														=						True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	(padded_height, padded_width)      )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              __lowerCamelCase  :      Tuple														=						True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	(padded_height, padded_width)      )







    @unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'      )
    def  lowercase_							(				self      )							->	Optional[Any]:
         pass







    @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'      )
    def  lowercase_							(				self      )							->	Any:
         pass







    @unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'      )
    def  lowercase_							(				self      )							->	Union[str, Any]:
         pass







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase							,			__lowerCamelCase  :      List[Any]														=						self.model_tester.prepare_config_and_inputs_for_common()

         def set_nan_tensor_to_zero(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      Any														=						0
              return t

         def check_equivalence(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_={}      ):
              with torch.no_grad():
                   __lowerCamelCase  :      Optional[int]														=						model(**SCREAMING_SNAKE_CASE_     ,	return_dict=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Tuple														=						model(**SCREAMING_SNAKE_CASE_     ,	return_dict=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      ).to_tuple()

                   def recursive_check(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      ):
                        if isinstance(SCREAMING_SNAKE_CASE_     ,	(List, Tuple)      ):
                             for tuple_iterable_value, dict_iterable_value in zip(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      ):
                                  recursive_check(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
                        elif isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      ):
                             for tuple_iterable_value, dict_iterable_value in zip(
                                 tuple_object.values()     ,	dict_object.values()      ):
                                  recursive_check(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
                        elif tuple_object is None:
                             return
                        else:
                             self.assertTrue(
                                 torch.allclose(
                                     set_nan_tensor_to_zero(SCREAMING_SNAKE_CASE_      )     ,	set_nan_tensor_to_zero(SCREAMING_SNAKE_CASE_      )     ,	atol=1E-5      )     ,	msg=(
                                     'Tuple and dict output are not equal. Difference:'
                                     f' {torch.max(torch.abs(tuple_object - dict_object      )      )}. Tuple has `nan`:'
                                     f' {torch.isnan(SCREAMING_SNAKE_CASE_      ).any()} and `inf`: {torch.isinf(SCREAMING_SNAKE_CASE_      )}. Dict has'
                                     f' `nan`: {torch.isnan(SCREAMING_SNAKE_CASE_      ).any()} and `inf`: {torch.isinf(SCREAMING_SNAKE_CASE_      )}.'
                                 )     ,	)

                   recursive_check(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

         for model_class in self.all_model_classes:
              __lowerCamelCase  :      str														=						model_class(SCREAMING_SNAKE_CASE_      )
              model.to(SCREAMING_SNAKE_CASE_      )
              model.eval()

              __lowerCamelCase  :      Optional[Any]														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
              __lowerCamelCase  :      int														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
              check_equivalence(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

              __lowerCamelCase  :      int														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	return_labels=SCREAMING_SNAKE_CASE_      )
              __lowerCamelCase  :      str														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	return_labels=SCREAMING_SNAKE_CASE_      )
              check_equivalence(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

              __lowerCamelCase  :      str														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
              __lowerCamelCase  :      Optional[int]														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
              check_equivalence(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	{'output_hidden_states': True}      )

              __lowerCamelCase  :      Any														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	return_labels=SCREAMING_SNAKE_CASE_      )
              __lowerCamelCase  :      Union[str, Any]														=						self._prepare_for_class(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	return_labels=SCREAMING_SNAKE_CASE_      )
              check_equivalence(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	{'output_hidden_states': True}      )







@require_torch
class   UpperCAmelCase_    (unittest.TestCase   ,						_UpperCAmelCase    ):





    """simple docstring"""






    lowerCamelCase    :   Union[str, Any]					=     (MaskFormerSwinBackbone,) if is_torch_available() else ()
    lowerCamelCase    :   List[str]					=     MaskFormerSwinConfig







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase  :      List[str]														=						MaskFormerSwinModelTester(self      )







    def  lowercase_							(				self      )							->	Optional[Any]:
         __lowerCamelCase							,			__lowerCamelCase  :      Tuple														=						self.model_tester.prepare_config_and_inputs_for_common()
         __lowerCamelCase  :      Any														=						inputs_dict['pixel_values'].shape[0]

         for backbone_class in self.all_model_classes:
              __lowerCamelCase  :      Optional[Any]														=						backbone_class(SCREAMING_SNAKE_CASE_      )
              backbone.to(SCREAMING_SNAKE_CASE_      )
              backbone.eval()

              __lowerCamelCase  :      int														=						backbone(**SCREAMING_SNAKE_CASE_      )

              # Test default outputs and verify feature maps
              self.assertIsInstance(outputs.feature_maps     ,	SCREAMING_SNAKE_CASE_      )
              self.assertTrue(len(outputs.feature_maps      ) == len(backbone.channels      )      )
              for feature_map, n_channels in zip(outputs.feature_maps     ,	backbone.channels      ):
                   self.assertTrue(feature_map.shape[:2]     ,	(batch_size, n_channels)      )
              self.assertIsNone(outputs.hidden_states      )
              self.assertIsNone(outputs.attentions      )

              # Test output_hidden_states=True
              __lowerCamelCase  :      Union[str, Any]														=						backbone(**SCREAMING_SNAKE_CASE_     ,	output_hidden_states=SCREAMING_SNAKE_CASE_      )
              self.assertIsNotNone(outputs.hidden_states      )
              self.assertTrue(len(outputs.hidden_states      )     ,	len(backbone.stage_names      )      )
              # We skip the stem layer
              for hidden_states, n_channels in zip(outputs.hidden_states[1:]     ,	backbone.channels      ):
                   for hidden_state in hidden_states:
                        # Hidden states are in the format (batch_size, (height * width), n_channels)
                        __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase  :      str														=						hidden_state.shape
                        self.assertTrue((h_batch_size, h_n_channels)     ,	(batch_size, n_channels)      )

            # Test output_attentions=True
              if self.has_attentions:
                   __lowerCamelCase  :      Optional[int]														=						backbone(**SCREAMING_SNAKE_CASE_     ,	output_attentions=SCREAMING_SNAKE_CASE_      )
                   self.assertIsNotNone(outputs.attentions      )






