





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




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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Optional[Any] 			=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )
       UpperCamelCase			:      List[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'''




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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




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



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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[Any] 			=     TimmBackboneModelTester(self     )
       UpperCamelCase			:      Optional[int] 			=     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'''




       UpperCamelCase			:      str 			=     "resnet18"
       UpperCamelCase			:      Optional[Any] 			=     "microsoft/resnet-18"

       UpperCamelCase			:      Optional[Any] 			=     AutoBackbone.from_pretrained(A_ ,							use_timm_backbone=A_     )
       UpperCamelCase			:      Union[str, 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]     )

       UpperCamelCase			:      int 			=     AutoBackbone.from_pretrained(A_ ,							use_timm_backbone=A_ ,							out_indices=[1, 2, 3]     )
       UpperCamelCase			:      Dict 			=     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'''




       UpperCamelCase			,					UpperCamelCase			:      Union[str, Any] 			=     self.model_tester.prepare_config_and_inputs_for_common()

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

        UpperCamelCase			:      int 			=     ["pixel_values"]
        self.assertListEqual(arg_names[:1] ,							A_     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




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

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

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

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

       if self.has_attentions:
        UpperCamelCase			:      List[str] 			=     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'''




       UpperCamelCase			,					UpperCamelCase			:      Tuple 			=     self.model_tester.prepare_config_and_inputs_for_common()

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

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

        # Check backbone can be initialized with fresh weights
        UpperCamelCase			:      Optional[int] 			=     copy.deepcopy(A_     )
        UpperCamelCase			:      Dict 			=     False
        UpperCamelCase			:      int 			=     model_class(A_     )
        model.to(A_     )
        model.eval()
        UpperCamelCase			:      Tuple 			=     model(**A_     )







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import VivitImageProcessor



class       A__     ( unittest.TestCase    ):





      def __init__(				self ,							A_ ,							A_=7 ,							A_=3 ,							A_=10 ,							A_=18 ,							A_=30 ,							A_=400 ,							A_=True ,							A_=None ,							A_=True ,							A_=[0.5, 0.5, 0.5] ,							A_=[0.5, 0.5, 0.5] ,							A_=None ,							):
       '''simple docstring'''




       UpperCamelCase			:      Optional[int] 			=     size if size is not None else {"shortest_edge": 18}
       UpperCamelCase			:      Tuple 			=     crop_size if crop_size is not None else {"height": 18, "width": 18}

       UpperCamelCase			:      Optional[Any] 			=     parent
       UpperCamelCase			:      Optional[int] 			=     batch_size
       UpperCamelCase			:      List[Any] 			=     num_channels
       UpperCamelCase			:      Union[str, Any] 			=     num_frames
       UpperCamelCase			:      Any 			=     image_size
       UpperCamelCase			:      Tuple 			=     min_resolution
       UpperCamelCase			:      Optional[Any] 			=     max_resolution
       UpperCamelCase			:      Any 			=     do_resize
       UpperCamelCase			:      Tuple 			=     size
       UpperCamelCase			:      List[Any] 			=     do_normalize
       UpperCamelCase			:      Optional[int] 			=     image_mean
       UpperCamelCase			:      Any 			=     image_std
       UpperCamelCase			:      str 			=     crop_size





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
           "crop_size": self.crop_size,
       }



@require_torch
@require_vision
class       A__     ( __snake_case ,     unittest.TestCase    ):
      _UpperCAmelCase			:List[str]							=     VivitImageProcessor if is_vision_available() else None





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[Any] 			=     VivitImageProcessingTester(self     )





      @property
      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       return self.image_processor_tester.prepare_image_processor_dict()





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[Any] 			=     self.image_processing_class(**self.image_processor_dict     )
       self.assertTrue(hasattr(A_ ,							"image_mean"     )     )
       self.assertTrue(hasattr(A_ ,							"image_std"     )     )
       self.assertTrue(hasattr(A_ ,							"do_normalize"     )     )
       self.assertTrue(hasattr(A_ ,							"do_resize"     )     )
       self.assertTrue(hasattr(A_ ,							"do_center_crop"     )     )
       self.assertTrue(hasattr(A_ ,							"size"     )     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Dict 			=     self.image_processing_class.from_dict(self.image_processor_dict     )
       self.assertEqual(image_processor.size ,							{"shortest_edge": 18}     )
       self.assertEqual(image_processor.crop_size ,							{"height": 18, "width": 18}     )

       UpperCamelCase			:      Dict 			=     self.image_processing_class.from_dict(self.image_processor_dict ,							size=42 ,							crop_size=84     )
       self.assertEqual(image_processor.size ,							{"shortest_edge": 42}     )
       self.assertEqual(image_processor.crop_size ,							{"height": 84, "width": 84}     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Optional[Any] 			=     self.image_processing_class(**self.image_processor_dict     )
       # create random PIL videos
       UpperCamelCase			:      Union[str, Any] 			=     prepare_video_inputs(self.image_processor_tester ,							equal_resolution=A_     )
       for video in video_inputs:
        self.assertIsInstance(A_ ,							A_     )
        self.assertIsInstance(video[0] ,							Image.Image     )

       # Test not batched input
       UpperCamelCase			:      Any 			=     image_processing(video_inputs[0] ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)

       # Test batched
       UpperCamelCase			:      str 			=     image_processing(A_ ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[Any] 			=     self.image_processing_class(**self.image_processor_dict     )
       # create random numpy tensors
       UpperCamelCase			:      str 			=     prepare_video_inputs(self.image_processor_tester ,							equal_resolution=A_ ,							numpify=A_     )
       for video in video_inputs:
        self.assertIsInstance(A_ ,							A_     )
        self.assertIsInstance(video[0] ,							np.ndarray     )

       # Test not batched input
       UpperCamelCase			:      Tuple 			=     image_processing(video_inputs[0] ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)

       # Test batched
       UpperCamelCase			:      Any 			=     image_processing(A_ ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      str 			=     self.image_processing_class(**self.image_processor_dict     )
       # create random PyTorch tensors
       UpperCamelCase			:      Union[str, Any] 			=     prepare_video_inputs(self.image_processor_tester ,							equal_resolution=A_ ,							torchify=A_     )
       for video in video_inputs:
        self.assertIsInstance(A_ ,							A_     )
        self.assertIsInstance(video[0] ,							torch.Tensor     )

       # Test not batched input
       UpperCamelCase			:      Tuple 			=     image_processing(video_inputs[0] ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)

       # Test batched
       UpperCamelCase			:      List[Any] 			=     image_processing(A_ ,							return_tensors="pt"     ).pixel_values
       self.assertEqual(
           encoded_videos.shape ,							(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           ) ,							)
