




from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
							import PIL

if is_torch_available():
							import torch


__SCREAMING_SNAKE_CASE 						=logging.get_logger(__name__)






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					["pixel_values"]


				def __init__(							self:   Optional[Any]		,					_lowerCamelCase:   bool = True		,					_lowerCamelCase:   Dict[str, int] = None		,					_lowerCamelCase:   PILImageResampling = PILImageResampling.BILINEAR		,					_lowerCamelCase:   bool = True		,					_lowerCamelCase:   Union[int, float] = 1 / 2_55		,					_lowerCamelCase:   bool = True		,					_lowerCamelCase:   Dict[str, int] = None		,					_lowerCamelCase:   bool = True		,					**_lowerCamelCase:   Any		,					):
											super().__init__(**_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    size if size is not None else {'''shortest_edge''': 2_24}
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		,					default_to_square=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    crop_size if crop_size is not None else {'''height''': 2_56, '''width''': 2_56}
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		,					param_name='''crop_size'''		)

											SCREAMING_SNAKE_CASE_   	=    do_resize
											SCREAMING_SNAKE_CASE_   	=    size
											SCREAMING_SNAKE_CASE_   	=    resample
											SCREAMING_SNAKE_CASE_   	=    do_rescale
											SCREAMING_SNAKE_CASE_   	=    rescale_factor
											SCREAMING_SNAKE_CASE_   	=    do_center_crop
											SCREAMING_SNAKE_CASE_   	=    crop_size
											SCREAMING_SNAKE_CASE_   	=    do_flip_channel_order


				def     _A							(							self:   List[str]		,					_lowerCamelCase:   np.ndarray		,					_lowerCamelCase:   Dict[str, int]		,					_lowerCamelCase:   PILImageResampling = PIL.Image.BILINEAR		,					_lowerCamelCase:   Optional[Union[str, ChannelDimension]] = None		,					**_lowerCamelCase:   List[Any]		,					):
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		,					default_to_square=_lowerCamelCase		)
											if "shortest_edge" not in size:
																		raise ValueError(f"The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}"		)
											SCREAMING_SNAKE_CASE_   	=    get_resize_output_image_size(_lowerCamelCase		,					size=size['''shortest_edge''']		,					default_to_square=_lowerCamelCase		)
											return resize(_lowerCamelCase		,					size=_lowerCamelCase		,					resample=_lowerCamelCase		,					data_format=_lowerCamelCase		,					**_lowerCamelCase		)


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   np.ndarray		,					_lowerCamelCase:   Dict[str, int]		,					_lowerCamelCase:   Optional[Union[str, ChannelDimension]] = None		,					**_lowerCamelCase:   List[str]		,					):
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		)
											if "height" not in size or "width" not in size:
																		raise ValueError(f"The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}"		)
											return center_crop(_lowerCamelCase		,					size=(size['''height'''], size['''width'''])		,					data_format=_lowerCamelCase		,					**_lowerCamelCase		)


				def     _A							(							self:   str		,					_lowerCamelCase:   np.ndarray		,					_lowerCamelCase:   Union[int, float]		,					_lowerCamelCase:   Optional[Union[str, ChannelDimension]] = None		,					**_lowerCamelCase:   Union[str, Any]		,					):
											return rescale(_lowerCamelCase		,					scale=_lowerCamelCase		,					data_format=_lowerCamelCase		,					**_lowerCamelCase		)


				def     _A							(							self:   Optional[int]		,					_lowerCamelCase:   np.ndarray		,					_lowerCamelCase:   Optional[Union[str, ChannelDimension]] = None		):
											return flip_channel_order(_lowerCamelCase		,					data_format=_lowerCamelCase		)


				def     _A							(							self:   Tuple		,					_lowerCamelCase:   ImageInput		,					_lowerCamelCase:   bool = None		,					_lowerCamelCase:   Dict[str, int] = None		,					_lowerCamelCase:   PILImageResampling = None		,					_lowerCamelCase:   bool = None		,					_lowerCamelCase:   float = None		,					_lowerCamelCase:   bool = None		,					_lowerCamelCase:   Dict[str, int] = None		,					_lowerCamelCase:   bool = None		,					_lowerCamelCase:   Optional[Union[str, TensorType]] = None		,					_lowerCamelCase:   ChannelDimension = ChannelDimension.FIRST		,					**_lowerCamelCase:   Any		,					):
											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_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_   	=    do_center_crop if do_center_crop is not None else self.do_center_crop
											SCREAMING_SNAKE_CASE_   	=    (
											    do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
											)

											SCREAMING_SNAKE_CASE_   	=    size if size is not None else self.size
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		,					default_to_square=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    crop_size if crop_size is not None else self.crop_size
											SCREAMING_SNAKE_CASE_   	=    get_size_dict(_lowerCamelCase		,					param_name='''crop_size'''		)

											SCREAMING_SNAKE_CASE_   	=    make_list_of_images(_lowerCamelCase		)

											if not valid_images(_lowerCamelCase		):
																		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:
																		raise ValueError('''Size must be specified if do_resize is True.'''		)

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

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

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

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

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

											if do_rescale:
																		SCREAMING_SNAKE_CASE_   	=    [self.rescale(image=_lowerCamelCase		,					scale=_lowerCamelCase		) for image in images]

											# the pretrained checkpoints assume images are BGR, not RGB
											if do_flip_channel_order:
																		SCREAMING_SNAKE_CASE_   	=    [self.flip_channel_order(image=_lowerCamelCase		) for image in images]

											SCREAMING_SNAKE_CASE_   	=    [to_channel_dimension_format(_lowerCamelCase		,					_lowerCamelCase		) for image in images]

											SCREAMING_SNAKE_CASE_   	=    {'''pixel_values''': images}
											return BatchFeature(data=_lowerCamelCase		,					tensor_type=_lowerCamelCase		)





				def     _A							(							self:   Dict		,					_lowerCamelCase:   int		,					_lowerCamelCase:   List[Tuple] = None		):
											SCREAMING_SNAKE_CASE_   	=    outputs.logits

											# Resize logits and compute semantic segmentation maps
											if target_sizes is not None:
																		if len(_lowerCamelCase		) != len(_lowerCamelCase		):
																									raise ValueError(
																									    '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''		)

																		if is_torch_tensor(_lowerCamelCase		):
																									SCREAMING_SNAKE_CASE_   	=    target_sizes.numpy()

																		SCREAMING_SNAKE_CASE_   	=    []

																		for idx in range(len(_lowerCamelCase		)		):
																									SCREAMING_SNAKE_CASE_   	=    torch.nn.functional.interpolate(
																									    logits[idx].unsqueeze(dim=0		)		,					size=target_sizes[idx]		,					mode='''bilinear'''		,					align_corners=_lowerCamelCase		)
																									SCREAMING_SNAKE_CASE_   	=    resized_logits[0].argmax(dim=0		)
																									semantic_segmentation.append(_lowerCamelCase		)
											else:
																		SCREAMING_SNAKE_CASE_   	=    logits.argmax(dim=1		)
																		SCREAMING_SNAKE_CASE_   	=    [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]		)]

											return semantic_segmentation








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  __magic_name__						:
				'''simple docstring'''







				def __init__(							self:   Optional[int]		,					_lowerCamelCase:   Tuple		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   Tuple=None		,					_lowerCamelCase:   Optional[Any]="resnet50"		,					_lowerCamelCase:   Any=3		,					_lowerCamelCase:   Optional[int]=32		,					_lowerCamelCase:   List[Any]=3		,					_lowerCamelCase:   int=True		,					_lowerCamelCase:   Any=True		,					):
											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     _A							(							self:   Optional[Any]		):
											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     _A							(							self:   List[Any]		):
											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     _A							(							self:   str		,					_lowerCamelCase:   str		,					_lowerCamelCase:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    TimmBackbone(config=_lowerCamelCase		)
											model.to(_lowerCamelCase		)
											model.eval()
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(
											    result.feature_map[-1].shape		,					(self.batch_size, model.channels[-1], 14, 14)		,					)





				def     _A							(							self:   Optional[Any]		):
											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  __magic_name__						(  __UpperCAmelCase    ,  __UpperCAmelCase    ,  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							List[str]	      =					(TimmBackbone,) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE__					:							List[str]	      =					{"feature-extraction": TimmBackbone} if is_torch_available() else {}
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					False
				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					False
				SCREAMING_SNAKE_CASE__					:							Any	      =					False
				SCREAMING_SNAKE_CASE__					:							Any	      =					False


				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    TimmBackboneModelTester(self		)
											SCREAMING_SNAKE_CASE_   	=    ConfigTester(self		,					config_class=_lowerCamelCase		,					has_text_modality=_lowerCamelCase		)


				def     _A							(							self:   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     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    '''resnet18'''
											SCREAMING_SNAKE_CASE_   	=    '''microsoft/resnet-18'''

											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		,					use_timm_backbone=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		)

											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(_lowerCamelCase		,					use_timm_backbone=_lowerCamelCase		,					out_indices=[1, 2, 3]		)
											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		,					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     _A							(							self:   Optional[Any]		):
											pass


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


				@unittest.skip('''TimmBackbone initialization is managed on the timm side'''		)
				def     _A							(							self:   Dict		):
											pass


				@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''		)
				def     _A							(							self:   Optional[Any]		):
											pass


				@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''		)
				def     _A							(							self:   List[Any]		):
											pass


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


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   List[str]		):
											pass


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


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


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   Optional[int]		):
											pass


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   Union[str, Any]		):
											pass


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


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


				@unittest.skip('''Safetensors is not supported by timm.'''		)
				def     _A							(							self:   Optional[int]		):
											pass


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


				def     _A							(							self:   Dict		):
											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(_lowerCamelCase		)
																		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]		,					_lowerCamelCase		)


				def     _A							(							self:   Dict		):
											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(_lowerCamelCase		)
											model.to(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    self._prepare_for_class(_lowerCamelCase		,					_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)
											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=_lowerCamelCase		)

											self.assertIsNotNone(hidden_states.grad		)

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





				def     _A							(							self:   List[str]		):
											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(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)

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

																		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(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    False
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)


