





import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_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


if is_torch_available():
	import torch

	from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin



class    __lowerCAmelCase			:






			def __init__(self   ,				__magic_name__   ,				__magic_name__=None   ,				__magic_name__=None   ,				__magic_name__=None   ,				__magic_name__="resnet50"   ,				__magic_name__=3   ,				__magic_name__=32   ,				__magic_name__=3   ,				__magic_name__=True   ,				__magic_name__=True   ,				)	->  str:


							'''simple docstring'''



							snake_case_		:       int           =    parent
							snake_case_		:       Union[str, Any]           =    out_indices if out_indices is not None else [4]
							snake_case_		:       Union[str, Any]           =    stage_names
							snake_case_		:       Tuple           =    out_features
							snake_case_		:       Any           =    backbone
							snake_case_		:       Dict           =    batch_size
							snake_case_		:       Any           =    image_size
							snake_case_		:       Dict           =    num_channels
							snake_case_		:       int           =    use_pretrained_backbone
							snake_case_		:       Any           =    is_training






			def      lowerCamelCase    (self       )	->  Optional[Any]:


							'''simple docstring'''



							snake_case_		:       Tuple           =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
							snake_case_		:       Optional[int]           =    self.get_config()

							return config, pixel_values






			def      lowerCamelCase    (self       )	->  int:


							'''simple docstring'''



							return TimmBackboneConfig(
							    image_size=self.image_size   ,				num_channels=self.num_channels   ,				out_features=self.out_features   ,				out_indices=self.out_indices   ,				stage_names=self.stage_names   ,				use_pretrained_backbone=self.use_pretrained_backbone   ,				backbone=self.backbone   ,				)






			def      lowerCamelCase    (self   ,				__magic_name__   ,				__magic_name__       )	->  Optional[Any]:


							'''simple docstring'''



							snake_case_		:       Optional[Any]           =    TimmBackbone(config=__magic_name__       )
							model.to(__magic_name__       )
							model.eval()
							with torch.no_grad():
											snake_case_		:       List[Any]           =    model(__magic_name__       )
							self.parent.assertEqual(
							    result.feature_map[-1].shape   ,				(self.batch_size, model.channels[-1], 14, 14)   ,				)






			def      lowerCamelCase    (self       )	->  Dict:


							'''simple docstring'''



							snake_case_		:       Dict           =    self.prepare_config_and_inputs()
							snake_case_     ,				snake_case_		:       Any           =    config_and_inputs
							snake_case_		:       Optional[int]           =    {'''pixel_values''': pixel_values}
							return config, inputs_dict




@require_torch
@require_timm
class    __lowerCAmelCase			(     _a,	_a,	_a,	unittest.TestCase	):
			lowerCamelCase_	:	List[str]			     = (TimmBackbone,) if is_torch_available() else ()
			lowerCamelCase_	:	Tuple			     = {'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
			lowerCamelCase_	:	int			     = False
			lowerCamelCase_	:	int			     = False
			lowerCamelCase_	:	str			     = False
			lowerCamelCase_	:	Any			     = False






			def      lowerCamelCase    (self       )	->  Any:


							'''simple docstring'''



							snake_case_		:       str           =    TimmBackboneModelTester(self       )
							snake_case_		:       int           =    ConfigTester(self   ,				config_class=__magic_name__   ,				has_text_modality=__magic_name__       )






			def      lowerCamelCase    (self       )	->  int:


							'''simple docstring'''



							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      lowerCamelCase    (self       )	->  List[Any]:


							'''simple docstring'''



							snake_case_		:       Tuple           =    '''resnet18'''
							snake_case_		:       List[str]           =    '''microsoft/resnet-18'''

							snake_case_		:       Union[str, Any]           =    AutoBackbone.from_pretrained(__magic_name__   ,				use_timm_backbone=__magic_name__       )
							snake_case_		:       Any           =    AutoBackbone.from_pretrained(__magic_name__       )

							self.assertEqual(len(timm_model.out_features       )   ,				len(transformers_model.out_features       )       )
							self.assertEqual(len(timm_model.stage_names       )   ,				len(transformers_model.stage_names       )       )
							self.assertEqual(timm_model.channels   ,				transformers_model.channels       )
							# Out indices are set to the last layer by default. For timm models, we don't know
							# the number of layers in advance, so we set it to (-1,), whereas for transformers
							# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
							self.assertEqual(timm_model.out_indices   ,				(-1,)       )
							self.assertEqual(transformers_model.out_indices   ,				[len(timm_model.stage_names       ) - 1]       )

							snake_case_		:       Optional[int]           =    AutoBackbone.from_pretrained(__magic_name__   ,				use_timm_backbone=__magic_name__   ,				out_indices=[1, 2, 3]       )
							snake_case_		:       Dict           =    AutoBackbone.from_pretrained(__magic_name__   ,				out_indices=[1, 2, 3]       )

							self.assertEqual(timm_model.out_indices   ,				transformers_model.out_indices       )
							self.assertEqual(len(timm_model.out_features       )   ,				len(transformers_model.out_features       )       )
							self.assertEqual(timm_model.channels   ,				transformers_model.channels       )






			@unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''       )
			def      lowerCamelCase    (self       )	->  Optional[Any]:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''       )
			def      lowerCamelCase    (self       )	->  int:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone initialization is managed on the timm side'''       )
			def      lowerCamelCase    (self       )	->  Tuple:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''       )
			def      lowerCamelCase    (self       )	->  List[Any]:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''       )
			def      lowerCamelCase    (self       )	->  Tuple:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''       )
			def      lowerCamelCase    (self       )	->  Tuple:


							'''simple docstring'''



							pass






			@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''       )
			def      lowerCamelCase    (self       )	->  int:


							'''simple docstring'''



							pass






			@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''       )
			def      lowerCamelCase    (self       )	->  Union[str, Any]:


							'''simple docstring'''



							pass






			@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''       )
			def      lowerCamelCase    (self       )	->  List[str]:


							'''simple docstring'''



							pass






			@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''       )
			def      lowerCamelCase    (self       )	->  List[Any]:


							'''simple docstring'''



							pass






			@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''       )
			def      lowerCamelCase    (self       )	->  Optional[int]:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''       )
			def      lowerCamelCase    (self       )	->  List[str]:


							'''simple docstring'''



							pass






			@unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''       )
			def      lowerCamelCase    (self       )	->  Optional[Any]:


							'''simple docstring'''



							pass






			@unittest.skip('''Safetensors is not supported by timm.'''       )
			def      lowerCamelCase    (self       )	->  Tuple:


							'''simple docstring'''



							pass






			@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''       )
			def      lowerCamelCase    (self       )	->  str:


							'''simple docstring'''



							pass






			def      lowerCamelCase    (self       )	->  List[str]:


							'''simple docstring'''



							snake_case_     ,				snake_case_		:       Optional[int]           =    self.model_tester.prepare_config_and_inputs_for_common()

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

											snake_case_		:       Optional[int]           =    ['''pixel_values''']
											self.assertListEqual(arg_names[:1]   ,				__magic_name__       )






			def      lowerCamelCase    (self       )	->  Optional[Any]:


							'''simple docstring'''



							snake_case_     ,				snake_case_		:       str           =    self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_		:       int           =    True
							snake_case_		:       Any           =    self.has_attentions

							# no need to test all models as different heads yield the same functionality
							snake_case_		:       List[str]           =    self.all_model_classes[0]
							snake_case_		:       Union[str, Any]           =    model_class(__magic_name__       )
							model.to(__magic_name__       )

							snake_case_		:       Tuple           =    self._prepare_for_class(__magic_name__   ,				__magic_name__       )
							snake_case_		:       Optional[int]           =    model(**__magic_name__       )
							snake_case_		:       Union[str, Any]           =    outputs[0][-1]

							# Encoder-/Decoder-only models
							snake_case_		:       Optional[int]           =    outputs.hidden_states[0]
							hidden_states.retain_grad()

							if self.has_attentions:
											snake_case_		:       Dict           =    outputs.attentions[0]
											attentions.retain_grad()

							output.flatten()[0].backward(retain_graph=__magic_name__       )

							self.assertIsNotNone(hidden_states.grad       )

							if self.has_attentions:
											self.assertIsNotNone(attentions.grad       )






			def      lowerCamelCase    (self       )	->  List[Any]:


							'''simple docstring'''



							snake_case_     ,				snake_case_		:       str           =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											snake_case_		:       List[Any]           =    model_class(__magic_name__       )
											model.to(__magic_name__       )
											model.eval()
											snake_case_		:       Tuple           =    model(**__magic_name__       )

											self.assertEqual(len(result.feature_maps       )   ,				len(config.out_indices       )       )
											self.assertEqual(len(model.channels       )   ,				len(config.out_indices       )       )

											# Check output of last stage is taken if out_features=None, out_indices=None
											snake_case_		:       List[Any]           =    copy.deepcopy(__magic_name__       )
											snake_case_		:       List[Any]           =    None
											snake_case_		:       Tuple           =    model_class(__magic_name__       )
											model.to(__magic_name__       )
											model.eval()
											snake_case_		:       int           =    model(**__magic_name__       )

											self.assertEqual(len(result.feature_maps       )   ,				1       )
											self.assertEqual(len(model.channels       )   ,				1       )

											# Check backbone can be initialized with fresh weights
											snake_case_		:       Optional[Any]           =    copy.deepcopy(__magic_name__       )
											snake_case_		:       List[Any]           =    False
											snake_case_		:       Tuple           =    model_class(__magic_name__       )
											model.to(__magic_name__       )
											model.eval()
											snake_case_		:       Dict           =    model(**__magic_name__       )




"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__snake_case       =       {
    """configuration_poolformer""": [
        """POOLFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """PoolFormerConfig""",
        """PoolFormerOnnxConfig""",
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __snake_case       =       ["""PoolFormerFeatureExtractor"""]
  __snake_case       =       ["""PoolFormerImageProcessor"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __snake_case       =       [
      """POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """PoolFormerForImageClassification""",
      """PoolFormerModel""",
      """PoolFormerPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_poolformer import (
      POOLFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      PoolFormerConfig,
      PoolFormerOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_poolformer import PoolFormerFeatureExtractor
    from .image_processing_poolformer import PoolFormerImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_poolformer import (
        POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        PoolFormerForImageClassification,
        PoolFormerModel,
        PoolFormerPreTrainedModel,
    )


else:
  import sys

  __snake_case       =       _LazyModule(__name__, globals()["""__file__"""], _import_structure)





