


'''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 _lowerCamelCase	:



		'''simple docstring'''







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







		def        __lowerCAmelCase		( self		:						Tuple      )  ->			List[str]:
			__magic_name__	:   int					     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
			__magic_name__	:   Dict					     =					self.get_config()

			return config, pixel_values







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







		def        __lowerCAmelCase		( self		:						Dict      )  ->			List[str]:
			__magic_name__	:   Dict					     =					self.prepare_config_and_inputs()
			__magic_name__     ,    __magic_name__	:   Optional[int]					     =					config_and_inputs
			__magic_name__	:   Optional[int]					     =					{'pixel_values': pixel_values}
			return config, inputs_dict







@require_torch
@require_timm
class _lowerCamelCase	(						lowercase__		,					lowercase__		,					lowercase__		,					unittest.TestCase							):



		'''simple docstring'''







		A_     :      Dict				   =    (TimmBackbone,) if is_torch_available() else ()
		A_     :      Optional[Any]				   =    {"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
		A_     :      Dict				   =    False
		A_     :      Union[str, Any]				   =    False
		A_     :      List[Any]				   =    False
		A_     :      Tuple				   =    False







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			Dict:
			__magic_name__	:   Optional[Any]					     =					TimmBackboneModelTester(self      )
			__magic_name__	:   str					     =					ConfigTester(self  ,					config_class=_A  ,					has_text_modality=_A      )







		def        __lowerCAmelCase		( self		:						str      )  ->			Tuple:
			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		:						int      )  ->			List[Any]:
			__magic_name__	:   Optional[Any]					     =					'resnet18'
			__magic_name__	:   Optional[Any]					     =					'microsoft/resnet-18'

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

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







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







		@unittest.skip('TimmBackbone initialization is managed on the timm side'      )
		def        __lowerCAmelCase		( self		:						Tuple      )  ->			Optional[int]:
			pass







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







		@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'      )
		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			Tuple:
			pass







		@unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'      )
		def        __lowerCAmelCase		( self		:						int      )  ->			Dict:
			pass







		@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'      )
		def        __lowerCAmelCase		( self		:						Dict      )  ->			Any:
			pass







		@unittest.skip('model weights aren\'t tied in TimmBackbone.'      )
		def        __lowerCAmelCase		( self		:						int      )  ->			Optional[Any]:
			pass







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







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







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







		@unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'      )
		def        __lowerCAmelCase		( self		:						Dict      )  ->			str:
			pass







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







		@unittest.skip('Safetensors is not supported by timm.'      )
		def        __lowerCAmelCase		( self		:						Any      )  ->			Union[str, Any]:
			pass







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







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			Tuple:
			__magic_name__     ,    __magic_name__	:   int					     =					self.model_tester.prepare_config_and_inputs_for_common()

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

				__magic_name__	:   Dict					     =					['pixel_values']
				self.assertListEqual(arg_names[:1]  ,					_A      )







		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Tuple:
			__magic_name__     ,    __magic_name__	:   Tuple					     =					self.model_tester.prepare_config_and_inputs_for_common()
			__magic_name__	:   List[str]					     =					True
			__magic_name__	:   List[str]					     =					self.has_attentions

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

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

			# Encoder-/Decoder-only models
			__magic_name__	:   Union[str, Any]					     =					outputs.hidden_states[0]
			hidden_states.retain_grad()

			if self.has_attentions:
				__magic_name__	:   int					     =					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        __lowerCAmelCase		( self		:						List[str]      )  ->			Tuple:
			__magic_name__     ,    __magic_name__	:   Tuple					     =					self.model_tester.prepare_config_and_inputs_for_common()

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

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

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



'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowerCAmelCase				:str        =      {
    '''configuration_vision_encoder_decoder''': ['''VisionEncoderDecoderConfig''', '''VisionEncoderDecoderOnnxConfig''']
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase				:List[str]        =      ['''VisionEncoderDecoderModel''']

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase				:List[str]        =      ['''TFVisionEncoderDecoderModel''']

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase				:Optional[Any]        =      ['''FlaxVisionEncoderDecoderModel''']

if TYPE_CHECKING:
							from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
							import sys

							lowerCAmelCase				:Tuple        =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)