






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

   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 ,				)		->       Any:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    out_indices if out_indices is not None else [4]
       UpperCamelCase__         =    stage_names
       UpperCamelCase__         =    out_features
       UpperCamelCase__         =    backbone
       UpperCamelCase__         =    batch_size
       UpperCamelCase__         =    image_size
       UpperCamelCase__         =    num_channels
       UpperCamelCase__         =    use_pretrained_backbone
       UpperCamelCase__         =    is_training

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
       UpperCamelCase__         =    self.get_config()

       return config, pixel_values

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       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_      )		->       Optional[Any]:
       UpperCamelCase__         =    TimmBackbone(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       with torch.no_grad():
           UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(
           result.feature_map[-1].shape ,				(self.batch_size, model.channels[-1], 14, 14) ,				)







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       UpperCamelCase__       ,						UpperCamelCase__         =    config_and_inputs
       UpperCamelCase__         =    {'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
@require_timm
class    __lowerCamelCase    (  _a							,	_a							,	_a							,	unittest.TestCase  ):
   a      :				Optional[int] 						=(TimmBackbone,) if is_torch_available() else ()
   a      :				Any 						={"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
   a      :				Optional[Any] 						=False
   a      :				Any 						=False
   a      :				Any 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    TimmBackboneModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				has_text_modality=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       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      )		->       List[str]:
       UpperCamelCase__         =    'resnet18'
       UpperCamelCase__         =    'microsoft/resnet-18'

       UpperCamelCase__         =    AutoBackbone.from_pretrained(snake_case_ ,				use_timm_backbone=snake_case_      )
       UpperCamelCase__         =    AutoBackbone.from_pretrained(snake_case_      )

       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__         =    AutoBackbone.from_pretrained(snake_case_ ,				use_timm_backbone=snake_case_ ,				out_indices=[1, 2, 3]      )
       UpperCamelCase__         =    AutoBackbone.from_pretrained(snake_case_ ,				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      )		->       Optional[int]:
       pass

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

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

   @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       pass

   @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       pass

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

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

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

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

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

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

   @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       pass

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

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

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

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      )
           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] ,				snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    self.has_attentions

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

       UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
       UpperCamelCase__         =    model(**snake_case_      )
       UpperCamelCase__         =    outputs[0][-1]

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

       if self.has_attentions:
           UpperCamelCase__         =    outputs.attentions[0]
           attentions.retain_grad()

       output.flatten()[0].backward(retain_graph=snake_case_      )

       self.assertIsNotNone(hidden_states.grad      )

       if self.has_attentions:
           self.assertIsNotNone(attentions.grad      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    model_class(snake_case_      )
           model.to(snake_case_      )
           model.eval()
           UpperCamelCase__         =    model(**snake_case_      )

           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(snake_case_      )
           UpperCamelCase__         =    None
           UpperCamelCase__         =    model_class(snake_case_      )
           model.to(snake_case_      )
           model.eval()
           UpperCamelCase__         =    model(**snake_case_      )

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

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











"""simple docstring"""





import PIL.Image
import PIL.ImageOps
from packaging import version
from PIL import Image


if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("""9.1.0"""):
  A__					: str=	{
      """linear""": PIL.Image.Resampling.BILINEAR,
      """bilinear""": PIL.Image.Resampling.BILINEAR,
      """bicubic""": PIL.Image.Resampling.BICUBIC,
      """lanczos""": PIL.Image.Resampling.LANCZOS,
      """nearest""": PIL.Image.Resampling.NEAREST,
  }
else:
  A__					: str=	{
      """linear""": PIL.Image.LINEAR,
      """bilinear""": PIL.Image.BILINEAR,
      """bicubic""": PIL.Image.BICUBIC,
      """lanczos""": PIL.Image.LANCZOS,
      """nearest""": PIL.Image.NEAREST,
  }







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	int:
    """simple docstring"""

    UpperCamelCase__         =    (images / 2 + 0.5).clamp(0 ,	1					)
    UpperCamelCase__         =    images.cpu().permute(0 ,	2 ,	3 ,	1					).float().numpy()
    UpperCamelCase__         =    numpy_to_pil(SCREAMING_SNAKE_CASE					)
    return images







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	Optional[int]:
    """simple docstring"""

    if images.ndim == 3:
        UpperCamelCase__         =    images[None, ...]
    UpperCamelCase__         =    (images * 2_55).round().astype('uint8'					)
    if images.shape[-1] == 1:
        # special case for grayscale (single channel) images
        UpperCamelCase__         =    [Image.fromarray(image.squeeze() ,	mode='L'					) for image in images]
    else:
        UpperCamelCase__         =    [Image.fromarray(SCREAMING_SNAKE_CASE					) for image in images]

    return pil_images




