






"""simple docstring"""







import warnings

from ...utils import logging
from .image_processing_perceiver import PerceiverImageProcessor


_lowerCAmelCase            =	logging.get_logger(__name__)


class      UpperCamelCase		(__snake_case     ):






						def __init__(		self  :Optional[int]			, *__magic_name__  :Tuple			, **__magic_name__  :Any				)      ->None:
										warnings.warn(
										    """The class PerceiverFeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
										    """ Please use PerceiverImageProcessor instead."""			, __magic_name__			, )
										super().__init__(*__magic_name__			, **__magic_name__				)








"""simple docstring"""







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      UpperCamelCase		:






						def __init__(		self  :Union[str, Any]			, __magic_name__  :List[Any]			, __magic_name__  :Union[str, Any]=None			, __magic_name__  :List[Any]=None			, __magic_name__  :Dict=None			, __magic_name__  :List[Any]="resnet50"			, __magic_name__  :Tuple=3			, __magic_name__  :Optional[Any]=32			, __magic_name__  :str=3			, __magic_name__  :str=True			, __magic_name__  :Optional[Any]=True			, )      ->str:
										lowercase    :      Tuple       = parent
										lowercase    :      Tuple       = out_indices if out_indices is not None else [4]
										lowercase    :      Union[str, Any]       = stage_names
										lowercase    :      Tuple       = out_features
										lowercase    :      Optional[int]       = backbone
										lowercase    :      Optional[Any]       = batch_size
										lowercase    :      Tuple       = image_size
										lowercase    :      Union[str, Any]       = num_channels
										lowercase    :      List[Any]       = use_pretrained_backbone
										lowercase    :      str       = is_training






						def      __snake_case      (		self  :List[Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
										lowercase    :      Optional[int]       = self.get_config()

										return config, pixel_values






						def      __snake_case      (		self  :Tuple				)      ->int:
										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      __snake_case      (		self  :Any			, __magic_name__  :List[str]			, __magic_name__  :Optional[int]				)      ->Tuple:
										lowercase    :      List[str]       = TimmBackbone(config=__magic_name__				)
										model.to(__magic_name__				)
										model.eval()
										with torch.no_grad():
														lowercase    :      str       = model(__magic_name__				)
										self.parent.assertEqual(
										    result.feature_map[-1].shape			, (self.batch_size, model.channels[-1], 14, 14)			, )






						def      __snake_case      (		self  :str				)      ->Dict:
										lowercase    :      Tuple       = self.prepare_config_and_inputs()
										lowercase      ,      lowercase    :      List[Any]       = config_and_inputs
										lowercase    :      Union[str, Any]       = {"""pixel_values""": pixel_values}
										return config, inputs_dict


@require_torch
@require_timm
class      UpperCamelCase		(__snake_case						,						__snake_case						,						__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		(TimmBackbone,) if is_torch_available() else ()
						_SCREAMING_SNAKE_CASE  : str												=		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
						_SCREAMING_SNAKE_CASE  : Optional[Any]												=		False
						_SCREAMING_SNAKE_CASE  : int												=		False
						_SCREAMING_SNAKE_CASE  : List[Any]												=		False
						_SCREAMING_SNAKE_CASE  : List[str]												=		False






						def      __snake_case      (		self  :Dict				)      ->List[str]:
										lowercase    :      List[str]       = TimmBackboneModelTester(self				)
										lowercase    :      Any       = ConfigTester(self			, config_class=__magic_name__			, has_text_modality=__magic_name__				)






						def      __snake_case      (		self  :Optional[Any]				)      ->List[Any]:
										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  :Union[str, Any]				)      ->Optional[Any]:
										lowercase    :      Dict       = """resnet18"""
										lowercase    :      int       = """microsoft/resnet-18"""

										lowercase    :      Union[str, Any]       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__				)
										lowercase    :      int       = 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]				)

										lowercase    :      Tuple       = AutoBackbone.from_pretrained(__magic_name__			, use_timm_backbone=__magic_name__			, out_indices=[1, 2, 3]				)
										lowercase    :      Any       = 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      __snake_case      (		self  :Tuple				)      ->Optional[int]:
										pass






						@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->int:
										pass






						@unittest.skip("""TimmBackbone initialization is managed on the timm side"""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""				)
						def      __snake_case      (		self  :int				)      ->Tuple:
										pass






						@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""				)
						def      __snake_case      (		self  :List[Any]				)      ->List[str]:
										pass






						@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""				)
						def      __snake_case      (		self  :int				)      ->Any:
										pass






						@unittest.skip("""model weights aren't tied in TimmBackbone."""				)
						def      __snake_case      (		self  :int				)      ->int:
										pass






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






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






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






						@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""				)
						def      __snake_case      (		self  :Union[str, Any]				)      ->List[Any]:
										pass






						@unittest.skip("""TimmBackbone doesn't support output_attentions."""				)
						def      __snake_case      (		self  :Tuple				)      ->List[Any]:
										pass






						@unittest.skip("""Safetensors is not supported by timm."""				)
						def      __snake_case      (		self  :List[Any]				)      ->int:
										pass






						@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""				)
						def      __snake_case      (		self  :Optional[Any]				)      ->Optional[int]:
										pass






						def      __snake_case      (		self  :Union[str, Any]				)      ->Union[str, Any]:
										lowercase      ,      lowercase    :      Optional[Any]       = self.model_tester.prepare_config_and_inputs_for_common()

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

														lowercase    :      Dict       = ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]			, __magic_name__				)






						def      __snake_case      (		self  :Any				)      ->List[str]:
										lowercase      ,      lowercase    :      str       = self.model_tester.prepare_config_and_inputs_for_common()
										lowercase    :      Any       = True
										lowercase    :      int       = self.has_attentions

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

										lowercase    :      Optional[Any]       = self._prepare_for_class(__magic_name__			, __magic_name__				)
										lowercase    :      Dict       = model(**__magic_name__				)
										lowercase    :      List[str]       = outputs[0][-1]

										# Encoder-/Decoder-only models
										lowercase    :      str       = outputs.hidden_states[0]
										hidden_states.retain_grad()

										if self.has_attentions:
														lowercase    :      List[Any]       = 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      __snake_case      (		self  :Any				)      ->List[Any]:
										lowercase      ,      lowercase    :      int       = self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase    :      Optional[int]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Any       = 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
														lowercase    :      List[Any]       = copy.deepcopy(__magic_name__				)
														lowercase    :      Dict       = None
														lowercase    :      str       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Optional[Any]       = model(**__magic_name__				)

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

														# Check backbone can be initialized with fresh weights
														lowercase    :      str       = copy.deepcopy(__magic_name__				)
														lowercase    :      int       = False
														lowercase    :      List[str]       = model_class(__magic_name__				)
														model.to(__magic_name__				)
														model.eval()
														lowercase    :      Dict       = model(**__magic_name__				)
