
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 __snake_case						:
    def __init__(    self						,snake_case						,snake_case=None						,snake_case=None						,snake_case=None						,snake_case="resnet50"						,snake_case=3						,snake_case=32						,snake_case=3						,snake_case=True						,snake_case=True						,):



           '''simple docstring'''







           lowercase				:	int			      = parent
           lowercase				:	Tuple			      = out_indices if out_indices is not None else [4]
           lowercase				:	Dict			      = stage_names
           lowercase				:	List[str]			      = out_features
           lowercase				:	Any			      = backbone
           lowercase				:	int			      = batch_size
           lowercase				:	Dict			      = image_size
           lowercase				:	str			      = num_channels
           lowercase				:	int			      = use_pretrained_backbone
           lowercase				:	Union[str, Any]			      = is_training
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	int			      = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
           lowercase				:	int			      = self.get_config()

           return config, pixel_values
    def  _SCREAMING_SNAKE_CASE			(    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  _SCREAMING_SNAKE_CASE			(    self						,snake_case						,snake_case ):



           '''simple docstring'''







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



           '''simple docstring'''







           lowercase				:	Any			      = self.prepare_config_and_inputs()
           lowercase      ,     lowercase				:	Union[str, Any]			      = config_and_inputs
           lowercase				:	int			      = {"""pixel_values""": pixel_values}
           return config, inputs_dict






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



           '''simple docstring'''







           lowercase				:	Tuple			      = TimmBackboneModelTester(self )
           lowercase				:	Union[str, Any]			      = ConfigTester(self						,config_class=a_						,has_text_modality=a_ )
    def  _SCREAMING_SNAKE_CASE			(    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  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase				:	Union[str, Any]			      = """resnet18"""
           lowercase				:	List[str]			      = """microsoft/resnet-18"""

           lowercase				:	List[str]			      = AutoBackbone.from_pretrained(a_						,use_timm_backbone=a_ )
           lowercase				:	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] )

           lowercase				:	Union[str, Any]			      = AutoBackbone.from_pretrained(a_						,use_timm_backbone=a_						,out_indices=[1, 2, 3] )
           lowercase				:	Tuple			      = 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  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







           pass
    @unittest.skip("""TimmBackbone initialization is managed on the timm side""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







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



           '''simple docstring'''







           pass
    @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           pass
    @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







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



           '''simple docstring'''







           pass
    @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           pass
    @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







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



           '''simple docstring'''







           pass
    @unittest.skip("""Safetensors is not supported by timm.""" )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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



           '''simple docstring'''







           pass
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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

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

                  lowercase				:	Any			      = ["""pixel_values"""]
                  self.assertListEqual(arg_names[:1]						,a_ )
    def  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







           lowercase      ,     lowercase				:	Union[str, Any]			      = self.model_tester.prepare_config_and_inputs_for_common()
           lowercase				:	Any			      = True
           lowercase				:	str			      = self.has_attentions

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

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

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

           if self.has_attentions:
                  lowercase				:	Optional[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  _SCREAMING_SNAKE_CASE			(    self ):



           '''simple docstring'''







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

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

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

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





from typing import Dict

from .base import GenericTensor, Pipeline


class 	__snake_case   ( SCREAMING_SNAKE_CASE ):
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_=None    ,a_=None    ,a_=None    ,**a_						):







						"""simple docstring"""
						if tokenize_kwargs is None:
										lowerCAmelCase__		  =  {}

						if truncation is not None:
										if "truncation" in tokenize_kwargs:
														raise ValueError(
														    'truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'						)
										lowerCAmelCase__		  =  truncation

						lowerCAmelCase__		  =  tokenize_kwargs

						lowerCAmelCase__		  =  {}
						if return_tensors is not None:
										lowerCAmelCase__		  =  return_tensors

						return preprocess_params, {}, postprocess_params
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,**a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  self.framework
						lowerCAmelCase__		  =  self.tokenizer(a_    ,return_tensors=a_    ,**a_						)
						return model_inputs
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  self.model(**a_						)
						return model_outputs
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,a_=False						):







						"""simple docstring"""
						# [0] is the first available tensor, logits or last_hidden_state.
						if return_tensors:
										return model_outputs[0]
						if self.framework == "pt":
										return model_outputs[0].tolist()
						elif self.framework == "tf":
										return model_outputs[0].numpy().tolist()



		def __call__(							self    ,*a_    ,**a_						):







						"""simple docstring"""
						return super().__call__(*a_    ,**a_						)
