


'''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						,    __a						,    __a=None						,    __a=None						,    __a=None						,    __a="resnet50"						,    __a=3						,    __a=32						,    __a=3						,    __a=True						,    __a=True						,    ):

						'''simple docstring'''





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




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Dict    =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
						__a      :	Any    =  self.get_config()

						return config, pixel_values




	def 				__UpperCAmelCase							(       self							):

						'''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 				__UpperCAmelCase							(       self						,    __a						,    __a							):

						'''simple docstring'''





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





	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Tuple    =  self.prepare_config_and_inputs()
						__a      :	int    =  config_and_inputs
						__a      :	Any    =  {'pixel_values': pixel_values}
						return config, inputs_dict





@require_torch
@require_timm
class 							__UpperCamelCase    (		lowerCAmelCase_		,				lowerCAmelCase_		,				lowerCAmelCase_		,				unittest.TestCase ):
	A_           =   (TimmBackbone,) if is_torch_available() else ()
	A_           =   {"feature-extraction": TimmBackbone} if is_torch_available() else {}
	A_           =   False
	A_           =   False
	A_           =   False
	A_           =   False




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Dict    =  TimmBackboneModelTester(self							)
						__a      :	Any    =  ConfigTester(self						,    config_class=__a						,    has_text_modality=__a							)




	def 				__UpperCAmelCase							(       self							):

						'''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 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Optional[int]    =  'resnet18'
						__a      :	str    =  'microsoft/resnet-18'

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

						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]							)

						__a      :	Optional[int]    =  AutoBackbone.from_pretrained(__a						,    use_timm_backbone=__a						,    out_indices=[1, 2, 3]							)
						__a      :	str    =  AutoBackbone.from_pretrained(__a						,    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 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone initialization is managed on the timm side'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




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

						'''simple docstring'''





						pass




	@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('model weights aren\'t tied in TimmBackbone.'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('model weights aren\'t tied in TimmBackbone.'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('TimmBackbone doesn\'t support output_attentions.'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




	@unittest.skip('Safetensors is not supported by timm.'							)
	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						pass




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

						'''simple docstring'''





						pass




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	List[str]    =  self.model_tester.prepare_config_and_inputs_for_common()

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

											__a      :	Union[str, Any]    =  ['pixel_values']
											self.assertListEqual(arg_names[:1]						,    __a							)




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Tuple    =  self.model_tester.prepare_config_and_inputs_for_common()
						__a      :	Optional[Any]    =  True
						__a      :	Optional[Any]    =  self.has_attentions

						# no need to test all models as different heads yield the same functionality
						__a      :	Tuple    =  self.all_model_classes[0]
						__a      :	int    =  model_class(__a							)
						model.to(__a							)

						__a      :	int    =  self._prepare_for_class(__a						,    __a							)
						__a      :	Any    =  model(**__a							)
						__a      :	Tuple    =  outputs[0][-1]

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

						if self.has_attentions:
											__a      :	Union[str, Any]    =  outputs.attentions[0]
											attentions.retain_grad()

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

						self.assertIsNotNone(hidden_states.grad							)

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





	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Optional[Any]    =  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__a      :	int    =  model_class(__a							)
											model.to(__a							)
											model.eval()
											__a      :	List[str]    =  model(**__a							)

											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
											__a      :	Dict    =  copy.deepcopy(__a							)
											__a      :	Tuple    =  None
											__a      :	Any    =  model_class(__a							)
											model.to(__a							)
											model.eval()
											__a      :	List[str]    =  model(**__a							)

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

											# Check backbone can be initialized with fresh weights
											__a      :	Union[str, Any]    =  copy.deepcopy(__a							)
											__a      :	Union[str, Any]    =  False
											__a      :	Any    =  model_class(__a							)
											model.to(__a							)
											model.eval()
											__a      :	Union[str, Any]    =  model(**__a							)







'''simple docstring'''



def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       int       ):
					return number & 1 == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()



