



"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
    import PIL


lowerCamelCase				:     Dict								=  logging.get_logger(__name__)




class    __snake_case(					__A       ):
    _A       = ['''pixel_values''']




    def __init__(   self    ,							A_ = True    ,							A_ = None    ,							A_ = PIL.Image.NEAREST    ,							A_ = False    ,							A_ = None    ,							A_ = 1 / 255    ,							A_ = False    ,							A_ = True    ,							A_ = True    ,							A_ = None    ,							A_ = None    ,							A_ = True    ,							**A_    ,							):





      '''simple docstring'''



      super().__init__(**a__			)
      _SCREAMING_SNAKE_CASE        =			size if size is not None else {'''height''': 346, '''width''': 346}
      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__			)
      _SCREAMING_SNAKE_CASE        =			crop_size if crop_size is not None else {'''height''': 289, '''width''': 289}
      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__    ,							param_name='''crop_size'''			)

      _SCREAMING_SNAKE_CASE        =			do_resize
      _SCREAMING_SNAKE_CASE        =			size
      _SCREAMING_SNAKE_CASE        =			resample
      _SCREAMING_SNAKE_CASE        =			do_center_crop
      _SCREAMING_SNAKE_CASE        =			crop_size
      _SCREAMING_SNAKE_CASE        =			do_rescale
      _SCREAMING_SNAKE_CASE        =			rescale_factor
      _SCREAMING_SNAKE_CASE        =			rescale_offset
      _SCREAMING_SNAKE_CASE        =			do_normalize
      _SCREAMING_SNAKE_CASE        =			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      _SCREAMING_SNAKE_CASE        =			image_std if image_std is not None else IMAGENET_STANDARD_STD
      _SCREAMING_SNAKE_CASE        =			include_top




    def   A   (   self    ,							A_    ,							A_    ,							A_ = PIL.Image.NEAREST    ,							A_ = None    ,							**A_    ,							):





      '''simple docstring'''



      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__			)
      if "height" not in size or "width" not in size:
        raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''			)
      return resize(
          a__    ,							size=(size['''height'''], size['''width'''])    ,							resample=a__    ,							data_format=a__    ,							**a__			)




    def   A   (   self    ,							A_    ,							A_    ,							A_ = None    ,							**A_    ,							):





      '''simple docstring'''



      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__			)
      if "height" not in size or "width" not in size:
        raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''			)
      return center_crop(a__    ,							size=(size['''height'''], size['''width'''])    ,							data_format=a__    ,							**a__			)




    def   A   (   self    ,							A_    ,							A_    ,							A_ = True    ,							A_ = None    ,							**A_    ,							):





      '''simple docstring'''



      if offset:
        _SCREAMING_SNAKE_CASE        =			(image - 127.5) * scale
        if data_format is not None:
          _SCREAMING_SNAKE_CASE        =			to_channel_dimension_format(a__    ,							a__			)
        _SCREAMING_SNAKE_CASE        =			rescaled_image.astype(np.floataa			)
      else:
        _SCREAMING_SNAKE_CASE        =			rescale(a__    ,							scale=a__    ,							data_format=a__    ,							**a__			)
      return rescaled_image




    def   A   (   self    ,							A_    ,							A_    ,							A_    ,							A_ = None    ,							**A_    ,							):





      '''simple docstring'''



      return normalize(a__    ,							mean=a__    ,							std=a__    ,							data_format=a__    ,							**a__			)




    def   A   (   self    ,							A_    ,							A_ = None    ,							A_ = None    ,							A_=None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = None    ,							A_ = ChannelDimension.FIRST    ,							**A_    ,							):





      '''simple docstring'''



      _SCREAMING_SNAKE_CASE        =			do_resize if do_resize is not None else self.do_resize
      _SCREAMING_SNAKE_CASE        =			resample if resample is not None else self.resample
      _SCREAMING_SNAKE_CASE        =			do_center_crop if do_center_crop is not None else self.do_center_crop
      _SCREAMING_SNAKE_CASE        =			do_rescale if do_rescale is not None else self.do_rescale
      _SCREAMING_SNAKE_CASE        =			rescale_factor if rescale_factor is not None else self.rescale_factor
      _SCREAMING_SNAKE_CASE        =			rescale_offset if rescale_offset is not None else self.rescale_offset
      _SCREAMING_SNAKE_CASE        =			do_normalize if do_normalize is not None else self.do_normalize
      _SCREAMING_SNAKE_CASE        =			image_mean if image_mean is not None else self.image_mean
      _SCREAMING_SNAKE_CASE        =			image_std if image_std is not None else self.image_std
      _SCREAMING_SNAKE_CASE        =			include_top if include_top is not None else self.include_top

      _SCREAMING_SNAKE_CASE        =			size if size is not None else self.size
      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__			)
      _SCREAMING_SNAKE_CASE        =			crop_size if crop_size is not None else self.crop_size
      _SCREAMING_SNAKE_CASE        =			get_size_dict(a__    ,							param_name='''crop_size'''			)

      _SCREAMING_SNAKE_CASE        =			make_list_of_images(a__			)

      if not valid_images(a__			):
        raise ValueError(
            '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
            '''torch.Tensor, tf.Tensor or jax.ndarray.'''			)

      if do_resize and size is None or resample is None:
        raise ValueError('''Size and resample must be specified if do_resize is True.'''			)

      if do_center_crop and crop_size is None:
        raise ValueError('''Crop size must be specified if do_center_crop is True.'''			)

      if do_rescale and rescale_factor is None:
        raise ValueError('''Rescale factor must be specified if do_rescale is True.'''			)

      if do_normalize and (image_mean is None or image_std is None):
        raise ValueError('''Image mean and std must be specified if do_normalize is True.'''			)

      # All transformations expect numpy arrays.
      _SCREAMING_SNAKE_CASE        =			[to_numpy_array(a__			) for image in images]

      if do_resize:
        _SCREAMING_SNAKE_CASE        =			[self.resize(image=a__    ,							size=a__    ,							resample=a__			) for image in images]

      if do_center_crop:
        _SCREAMING_SNAKE_CASE        =			[self.center_crop(image=a__    ,							size=a__			) for image in images]

      if do_rescale:
        _SCREAMING_SNAKE_CASE        =			[self.rescale(image=a__    ,							scale=a__    ,							offset=a__			) for image in images]

      if do_normalize:
        _SCREAMING_SNAKE_CASE        =			[self.normalize(image=a__    ,							mean=a__    ,							std=a__			) for image in images]

      if include_top:
        _SCREAMING_SNAKE_CASE        =			[self.normalize(image=a__    ,							mean=[0, 0, 0]    ,							std=a__			) for image in images]

      _SCREAMING_SNAKE_CASE        =			[to_channel_dimension_format(a__    ,							a__			) for image in images]

      _SCREAMING_SNAKE_CASE        =			{'''pixel_values''': images}
      return BatchFeature(data=a__    ,							tensor_type=a__			)







"""simple docstring"""






import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType



@require_torch
class 						lowerCAmelCase       :
       lowerCAmelCase__    			=	()
       lowerCAmelCase__    			=	True






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.config_class

              # test default config
              _UpperCAmelCase			     =  config_class()
              self.assertIsNotNone(a__  )
              _UpperCAmelCase			     =  ['stem'] + [f"""stage{idx}""" for idx in range(1     ,	len(config.depths  ) + 1  )]
              self.assertEqual(config.stage_names     ,	a__  )
              self.assertTrue(set(config.out_features  ).issubset(set(config.stage_names  )  )  )

              # Test out_features and out_indices are correctly set
              # out_features and out_indices both None
              _UpperCAmelCase			     =  config_class(out_features=a__     ,	out_indices=a__  )
              self.assertEqual(config.out_features     ,	[config.stage_names[-1]]  )
              self.assertEqual(config.out_indices     ,	[len(config.stage_names  ) - 1]  )

              # out_features and out_indices both set
              _UpperCAmelCase			     =  config_class(out_features=['stem', 'stage1']     ,	out_indices=[0, 1]  )
              self.assertEqual(config.out_features     ,	['stem', 'stage1']  )
              self.assertEqual(config.out_indices     ,	[0, 1]  )

              # Only out_features set
              _UpperCAmelCase			     =  config_class(out_features=['stage1', 'stage3']  )
              self.assertEqual(config.out_features     ,	['stage1', 'stage3']  )
              self.assertEqual(config.out_indices     ,	[1, 3]  )

              # Only out_indices set
              _UpperCAmelCase			     =  config_class(out_indices=[0, 2]  )
              self.assertEqual(config.out_features     ,	[config.stage_names[0], config.stage_names[2]]  )
              self.assertEqual(config.out_indices     ,	[0, 2]  )

              # Error raised when out_indices do not correspond to out_features
              with self.assertRaises(a__  ):
                     _UpperCAmelCase			     =  config_class(out_features=['stage1', 'stage2']     ,	out_indices=[0, 2]  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     _UpperCAmelCase			     =  inspect.signature(model.forward  )
                     # signature.parameters is an OrderedDict => so arg_names order is deterministic
                     _UpperCAmelCase			     =  [*signature.parameters.keys()]
                     _UpperCAmelCase			     =  ['pixel_values']
                     self.assertListEqual(arg_names[:1]     ,	a__  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	len(config.out_features  )  )
                     _UpperCAmelCase			     =  model.num_features
                     _UpperCAmelCase			     =  [config.stage_names.index(a__  ) for feat in config.out_features]
                     _UpperCAmelCase			     =  [num_features[idx] for idx in out_indices]
                     self.assertListEqual(model.channels     ,	a__  )

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	1  )
                     self.assertListEqual(model.channels     ,	[num_features[-1]]  )

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     self.assertEqual(len(model.channels  )     ,	1  )
                     self.assertListEqual(model.channels     ,	[num_features[-1]]  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

                     self.assertEqual(len(result.feature_maps  )     ,	len(config.out_features  )  )
                     self.assertEqual(len(model.channels  )     ,	len(config.out_features  )  )
                     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			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

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

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

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

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






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for backbone_class in self.all_model_classes:
                     _UpperCAmelCase			     =  backbone_class(a__  )

                     self.assertTrue(hasattr(a__     ,	'backbone_type'  )  )
                     self.assertTrue(hasattr(a__     ,	'stage_names'  )  )
                     self.assertTrue(hasattr(a__     ,	'num_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_indices'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_feature_channels'  )  )
                     self.assertTrue(hasattr(a__     ,	'channels'  )  )

                     self.assertIsInstance(backbone.backbone_type     ,	a__  )
                     # Verify num_features has been initialized in the backbone init
                     self.assertIsNotNone(backbone.num_features  )
                     self.assertTrue(len(backbone.channels  ) == len(backbone.out_indices  )  )
                     self.assertTrue(len(backbone.stage_names  ) == len(backbone.num_features  )  )
                     self.assertTrue(len(backbone.channels  ) <= len(backbone.num_features  )  )
                     self.assertTrue(len(backbone.out_feature_channels  ) == len(backbone.stage_names  )  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()
              _UpperCAmelCase			     =  inputs_dict['pixel_values'].shape[0]

              for backbone_class in self.all_model_classes:
                     _UpperCAmelCase			     =  backbone_class(a__  )
                     backbone.to(a__  )
                     backbone.eval()

                     _UpperCAmelCase			     =  backbone(**a__  )

                     # Test default outputs and verify feature maps
                     self.assertIsInstance(outputs.feature_maps     ,	a__  )
                     self.assertTrue(len(outputs.feature_maps  ) == len(backbone.channels  )  )
                     for feature_map, n_channels in zip(outputs.feature_maps     ,	backbone.channels  ):
                            self.assertTrue(feature_map.shape[:2]     ,	(batch_size, n_channels)  )
                     self.assertIsNone(outputs.hidden_states  )
                     self.assertIsNone(outputs.attentions  )

                     # Test output_hidden_states=True
                     _UpperCAmelCase			     =  backbone(**a__     ,	output_hidden_states=a__  )
                     self.assertIsNotNone(outputs.hidden_states  )
                     self.assertTrue(len(outputs.hidden_states  )     ,	len(backbone.stage_names  )  )
                     for hidden_state, n_channels in zip(outputs.hidden_states     ,	backbone.channels  ):
                            self.assertTrue(hidden_state.shape[:2]     ,	(batch_size, n_channels)  )

                     # Test output_attentions=True
                     if self.has_attentions:
                            _UpperCAmelCase			     =  backbone(**a__     ,	output_attentions=a__  )
                            self.assertIsNotNone(outputs.attentions  )






