




from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


__SCREAMING_SNAKE_CASE 						=logging.get_logger(__name__)

def 			a   (_lowerCAmelCase     ):
							if isinstance(_lowerCAmelCase  ,    np.ndarray     ):
														return list(tensor.shape     )

							SCREAMING_SNAKE_CASE_   	=    tf.shape(_lowerCAmelCase     )

							if tensor.shape == tf.TensorShape(_lowerCAmelCase     ):
														return dynamic

							SCREAMING_SNAKE_CASE_   	=    tensor.shape.as_list()

							return [dynamic[i] if s is None else s for i, s in enumerate(_lowerCAmelCase     )]

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase = None  ,    _lowerCAmelCase = None     ):
							return tf.nn.softmax(logits=logits + 1e-9  ,    axis=_lowerCAmelCase  ,    name=_lowerCAmelCase     )

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase=1e-5  ,    _lowerCAmelCase=-1     ):
							# This is a very simplified functional layernorm, designed to duplicate
							# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
							# models in Transformers.

							if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(_lowerCAmelCase  ,    _lowerCAmelCase     ):
														raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''     )

							# Get mean and variance on the axis to be normalized
							SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    tf.nn.moments(_lowerCAmelCase  ,    axes=[axis]  ,    keepdims=_lowerCAmelCase     )

							if axis != -1:
														# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
														# on every dimension except axis
														SCREAMING_SNAKE_CASE_   	=    [1] * inputs.shape.rank
														SCREAMING_SNAKE_CASE_   	=    shape_list(_lowerCAmelCase     )[axis]
														SCREAMING_SNAKE_CASE_   	=    tf.reshape(_lowerCAmelCase  ,    _lowerCAmelCase     )
														SCREAMING_SNAKE_CASE_   	=    tf.reshape(_lowerCAmelCase  ,    _lowerCAmelCase     )

							# Compute layer normalization using the batch_normalization
							# function.
							SCREAMING_SNAKE_CASE_   	=    tf.nn.batch_normalization(
							    _lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase  ,    offset=_lowerCAmelCase  ,    scale=_lowerCAmelCase  ,    variance_epsilon=_lowerCAmelCase  ,    )
							return outputs

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase=0  ,    _lowerCAmelCase=-1     ):
							# Replicates the behavior of torch.flatten in TF

							# If end_dim or start_dim is negative, count them from the end
							if end_dim < 0:
														end_dim += input.shape.rank
							if start_dim < 0:
														start_dim += input.shape.rank

							if start_dim == end_dim:
														return input

							SCREAMING_SNAKE_CASE_   	=    tf.shape(_lowerCAmelCase     )
							SCREAMING_SNAKE_CASE_   	=    tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]     )
							SCREAMING_SNAKE_CASE_   	=    tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]  ,    axis=0     )
							return tf.reshape(_lowerCAmelCase  ,    _lowerCAmelCase     )

def 			a   (_lowerCAmelCase     ):
							if not isinstance(_lowerCAmelCase  ,    tf.Tensor     ):
														SCREAMING_SNAKE_CASE_   	=    tf.convert_to_tensor(_lowerCAmelCase     )  # Catches stray NumPy inputs
							if encoder_attention_mask.shape.rank == 3:
														SCREAMING_SNAKE_CASE_   	=    encoder_attention_mask[:, None, :, :]
							if encoder_attention_mask.shape.rank == 2:
														SCREAMING_SNAKE_CASE_   	=    encoder_attention_mask[:, None, None, :]
							# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
							# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
							# /transformer/transformer_layers.py#L270
							# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
							# encoder_extended_attention_mask.transpose(-1, -2))
							SCREAMING_SNAKE_CASE_   	=    (
							    tf.cast(1  ,    encoder_attention_mask.dtype     ) - encoder_extended_attention_mask
							) * encoder_extended_attention_mask.dtype.min

							return encoder_extended_attention_mask

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase = "input_ids"     ):
							tf.debugging.assert_less(
							    _lowerCAmelCase  ,    tf.cast(_lowerCAmelCase  ,    dtype=tensor.dtype     )  ,    message=(
							        F"The maximum value of {tensor_name} ({tf.math.reduce_max(_lowerCAmelCase     )}) must be smaller than the embedding "
							        F"layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time."
							    )  ,    )

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    6_4_5_1_2
							# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
							# because in that case even chunking the array would not make the saving
							# possible.
							SCREAMING_SNAKE_CASE_   	=    [x for x in data if len(_lowerCAmelCase     ) > HDF5_OBJECT_HEADER_LIMIT]

							# Expecting this to never be true.
							if bad_attributes:
														raise RuntimeError(
														    '''The following attributes cannot be saved to HDF5 file because '''
														    F"they are larger than {HDF5_OBJECT_HEADER_LIMIT} "
														    F"bytes: {bad_attributes}"     )

							SCREAMING_SNAKE_CASE_   	=    np.asarray(_lowerCAmelCase     )

							SCREAMING_SNAKE_CASE_   	=    1
							SCREAMING_SNAKE_CASE_   	=    np.array_split(_lowerCAmelCase  ,    _lowerCAmelCase     )

							# This will never loop forever thanks to the test above.
							while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data     ):
														num_chunks += 1
														SCREAMING_SNAKE_CASE_   	=    np.array_split(_lowerCAmelCase  ,    _lowerCAmelCase     )

							if num_chunks > 1:
														for chunk_id, chunk_data in enumerate(_lowerCAmelCase     ):
																					SCREAMING_SNAKE_CASE_   	=    chunk_data
							else:
														SCREAMING_SNAKE_CASE_   	=    data

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							if name in group.attrs:
														SCREAMING_SNAKE_CASE_   	=    [n.decode('''utf8'''     ) if hasattr(_lowerCAmelCase  ,    '''decode'''     ) else n for n in group.attrs[name]]
							else:
														SCREAMING_SNAKE_CASE_   	=    []
														SCREAMING_SNAKE_CASE_   	=    0
														while "%s%d" % (name, chunk_id) in group.attrs:
																					data.extend(
																					    [n.decode('''utf8'''     ) if hasattr(_lowerCAmelCase  ,    '''decode'''     ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]     )
																					chunk_id += 1
							return data






def 			a   (_lowerCAmelCase     ):

							def _expand_single_ad_tensor(_lowerCAmelCase     ):
														if isinstance(_lowerCAmelCase  ,    tf.Tensor     ) and t.shape.rank == 1:
																					return tf.expand_dims(_lowerCAmelCase  ,    axis=-1     )
														return t

							return tf.nest.map_structure(_expand_single_ad_tensor  ,    _lowerCAmelCase     )








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		)


