


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




						def __init__(       self					:      Optional[Any]				,    _a					:      Optional[int]				,    _a					:      Union[str, Any]=None				,    _a					:      List[str]=None				,    _a					:      Any=None				,    _a					:      Optional[int]="resnet50"				,    _a					:      Tuple=3				,    _a					:      int=32				,    _a					:      Dict=3				,    _a					:      Any=True				,    _a					:      List[str]=True				,    )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =parent
										_SCREAMING_SNAKE_CASE			  =out_indices if out_indices is not None else [4]
										_SCREAMING_SNAKE_CASE			  =stage_names
										_SCREAMING_SNAKE_CASE			  =out_features
										_SCREAMING_SNAKE_CASE			  =backbone
										_SCREAMING_SNAKE_CASE			  =batch_size
										_SCREAMING_SNAKE_CASE			  =image_size
										_SCREAMING_SNAKE_CASE			  =num_channels
										_SCREAMING_SNAKE_CASE			  =use_pretrained_backbone
										_SCREAMING_SNAKE_CASE			  =is_training




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
										_SCREAMING_SNAKE_CASE			  =self.get_config()

										return config, pixel_values




						def 							__UpperCamelCase				(       self					:      int  )							->     Optional[Any]:


										"""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					:      Tuple				,    _a					:      Any				,    _a					:      Any  )							->     Optional[int]:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.prepare_config_and_inputs()
										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =config_and_inputs
										_SCREAMING_SNAKE_CASE			  ={'''pixel_values''': pixel_values}
										return config, inputs_dict

@require_torch
@require_timm
class 						A__							(		UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						(TimmBackbone,) if is_torch_available() else ()
						UpperCAmelCase             =						{"feature-extraction": TimmBackbone} if is_torch_available() else {}
						UpperCAmelCase             =						False
						UpperCAmelCase             =						False
						UpperCAmelCase             =						False
						UpperCAmelCase             =						False




						def 							__UpperCamelCase				(       self					:      str  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TimmBackboneModelTester(self  )
										_SCREAMING_SNAKE_CASE			  =ConfigTester(self				,    config_class=_a				,    has_text_modality=_a  )




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  ='''resnet18'''
										_SCREAMING_SNAKE_CASE			  ='''microsoft/resnet-18'''

										_SCREAMING_SNAKE_CASE			  =AutoBackbone.from_pretrained(_a				,    use_timm_backbone=_a  )
										_SCREAMING_SNAKE_CASE			  =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]  )

										_SCREAMING_SNAKE_CASE			  =AutoBackbone.from_pretrained(_a				,    use_timm_backbone=_a				,    out_indices=[1, 2, 3]  )
										_SCREAMING_SNAKE_CASE			  =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					:      str  )							->     Optional[Any]:


										"""simple docstring"""





										pass




						@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''  )
						def 							__UpperCamelCase				(       self					:      int  )							->     List[str]:


										"""simple docstring"""





										pass




						@unittest.skip('''TimmBackbone initialization is managed on the timm side'''  )
						def 							__UpperCamelCase				(       self					:      Any  )							->     Union[str, Any]:


										"""simple docstring"""





										pass




						@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''  )
						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     str:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




						@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''  )
						def 							__UpperCamelCase				(       self					:      int  )							->     Optional[int]:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




						@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''  )
						def 							__UpperCamelCase				(       self					:      Dict  )							->     Dict:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




						@unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''  )
						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     Tuple:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()

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

														_SCREAMING_SNAKE_CASE			  =['''pixel_values''']
														self.assertListEqual(arg_names[:1]				,    _a  )




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()
										_SCREAMING_SNAKE_CASE			  =True
										_SCREAMING_SNAKE_CASE			  =self.has_attentions

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

										_SCREAMING_SNAKE_CASE			  =self._prepare_for_class(_a				,    _a  )
										_SCREAMING_SNAKE_CASE			  =model(**_a  )
										_SCREAMING_SNAKE_CASE			  =outputs[0][-1]

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

										if self.has_attentions:
														_SCREAMING_SNAKE_CASE			  =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					:      List[str]  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														_SCREAMING_SNAKE_CASE			  =model_class(_a  )
														model.to(_a  )
														model.eval()
														_SCREAMING_SNAKE_CASE			  =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
														_SCREAMING_SNAKE_CASE			  =copy.deepcopy(_a  )
														_SCREAMING_SNAKE_CASE			  =None
														_SCREAMING_SNAKE_CASE			  =model_class(_a  )
														model.to(_a  )
														model.eval()
														_SCREAMING_SNAKE_CASE			  =model(**_a  )

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

														# Check backbone can be initialized with fresh weights
														_SCREAMING_SNAKE_CASE			  =copy.deepcopy(_a  )
														_SCREAMING_SNAKE_CASE			  =False
														_SCREAMING_SNAKE_CASE			  =model_class(_a  )
														model.to(_a  )
														model.eval()
														_SCREAMING_SNAKE_CASE			  =model(**_a  )



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						["image_processor", "tokenizer"]
						UpperCAmelCase             =						"ViTImageProcessor"
						UpperCAmelCase             =						("CLIPTokenizer", "CLIPTokenizerFast")




						def __init__(       self					:      int				,    _a					:      int=None				,    _a					:      Optional[int]=None				,    **_a					:      str  )							->     List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =None
										if "feature_extractor" in kwargs:
														warnings.warn(
														    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
														    ''' instead.'''				,    _a				,    )
														_SCREAMING_SNAKE_CASE			  =kwargs.pop('''feature_extractor'''  )

										_SCREAMING_SNAKE_CASE			  =image_processor if image_processor is not None else feature_extractor
										if image_processor is None:
														raise ValueError('''You need to specify an `image_processor`.'''  )
										if tokenizer is None:
														raise ValueError('''You need to specify a `tokenizer`.'''  )

										super().__init__(_a				,    _a  )




						def __call__(       self					:      List[str]				,    _a					:      Tuple=None				,    _a					:      Optional[Any]=None				,    _a					:      List[Any]=None				,    _a					:      List[Any]=None				,    **_a					:      List[Any]  )							->     Optional[Any]:


										"""simple docstring"""





										if text is None and visual_prompt is None and images is None:
														raise ValueError('''You have to specify either text, visual prompt or images.'''  )

										if text is not None and visual_prompt is not None:
														raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.'''  )

										if text is not None:
														_SCREAMING_SNAKE_CASE			  =self.tokenizer(_a				,    return_tensors=_a				,    **_a  )

										if visual_prompt is not None:
														_SCREAMING_SNAKE_CASE			  =self.image_processor(_a				,    return_tensors=_a				,    **_a  )

										if images is not None:
														_SCREAMING_SNAKE_CASE			  =self.image_processor(_a				,    return_tensors=_a				,    **_a  )

										if visual_prompt is not None and images is not None:
														_SCREAMING_SNAKE_CASE			  ={
														    '''pixel_values''': image_features.pixel_values,
														    '''conditional_pixel_values''': prompt_features.pixel_values,
														}
														return encoding
										elif text is not None and images is not None:
														_SCREAMING_SNAKE_CASE			  =image_features.pixel_values
														return encoding
										elif text is not None:
														return encoding
										elif visual_prompt is not None:
														_SCREAMING_SNAKE_CASE			  ={
														    '''conditional_pixel_values''': prompt_features.pixel_values,
														}
														return encoding
										else:
														return BatchEncoding(data=dict(**_a  )				,    tensor_type=_a  )




						def 							__UpperCamelCase				(       self					:      Any				,    *_a					:      str				,    **_a					:      List[Any]  )							->     Tuple:


										"""simple docstring"""





										return self.tokenizer.batch_decode(*_a				,    **_a  )




						def 							__UpperCamelCase				(       self					:      Dict				,    *_a					:      str				,    **_a					:      List[Any]  )							->     List[Any]:


										"""simple docstring"""





										return self.tokenizer.decode(*_a				,    **_a  )




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     int:


										"""simple docstring"""





										warnings.warn(
										    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''				,    _a				,    )
										return self.image_processor_class




						@property
						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     Union[str, Any]:


										"""simple docstring"""





										warnings.warn(
										    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''				,    _a				,    )
										return self.image_processor