





"""simple docstring"""




from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowerCamelCase_	:		str         =   logging.get_logger(__name__)

# General docstring
lowerCamelCase_	:		str         =   'ResNetConfig'

# Base docstring
lowerCamelCase_	:		Optional[Any]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Dict         =   [1, 20_48, 7, 7]

# Image classification docstring
lowerCamelCase_	:		List[str]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Union[str, Any]         =   'tiger cat'

lowerCamelCase_	:		int         =   [
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]

class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_ = 3   , snake_case_ = 1   , snake_case_ = "relu"   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Tuple									=    kernel_size // 2
        A_    :			List[Any]									=    tf.keras.layers.ConvaD(
            snake_case_   , kernel_size=snake_case_   , strides=snake_case_   , padding='valid'   , use_bias=snake_case_   , name='convolution'    )
        # Use same default momentum and epsilon as PyTorch equivalent
        A_    :			List[Any]									=    tf.keras.layers.BatchNormalization(epsilon=1E-5   , momentum=0.9   , name='normalization'    )
        A_    :			Any									=    ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'    )

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    (self.pad_value, self.pad_value)
        A_    :			int									=    tf.pad(snake_case_   , [(0, 0), height_pad, width_pad, (0, 0)]    )
        A_    :			List[Any]									=    self.conv(snake_case_    )
        return hidden_state

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    self.convolution(snake_case_    )
        A_    :			Optional[Any]									=    self.normalization(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.activation(snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[int]									=    TFResNetConvLayer(
            config.embedding_size   , kernel_size=7   , stride=2   , activation=config.hidden_act   , name='embedder'   , )
        A_    :			Optional[int]									=    tf.keras.layers.MaxPoolaD(pool_size=3   , strides=2   , padding='valid'   , name='pooler'    )
        A_    :			Tuple									=    config.num_channels

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_		,			A_		,			A_		,			A_    :			Dict									=    shape_list(snake_case_    )
        if tf.executing_eagerly() and num_channels != self.num_channels:
          raise ValueError(
              'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'    )
        A_    :			str									=    pixel_values
        A_    :			Union[str, Any]									=    self.embedder(snake_case_    )
        A_    :			int									=    tf.pad(snake_case_   , [[0, 0], [1, 1], [1, 1], [0, 0]]    )
        A_    :			str									=    self.pooler(snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_ = 2   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[Any]									=    tf.keras.layers.ConvaD(
            snake_case_   , kernel_size=1   , strides=snake_case_   , use_bias=snake_case_   , name='convolution'    )
        # Use same default momentum and epsilon as PyTorch equivalent
        A_    :			Optional[Any]									=    tf.keras.layers.BatchNormalization(epsilon=1E-5   , momentum=0.9   , name='normalization'    )

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[Any]									=    x
        A_    :			Any									=    self.convolution(snake_case_    )
        A_    :			Dict									=    self.normalization(snake_case_   , training=snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_ = 1   , snake_case_ = "relu"   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[Any]									=    in_channels != out_channels or stride != 1
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , stride=snake_case_   , name='layer.0'    )
        A_    :			List[str]									=    TFResNetConvLayer(snake_case_   , activation=snake_case_   , name='layer.1'    )
        A_    :			int									=    (
            TFResNetShortCut(snake_case_   , stride=snake_case_   , name='shortcut'    )
            if should_apply_shortcut
            else tf.keras.layers.Activation('linear'   , name='shortcut'    )
        )
        A_    :			Tuple									=    ACTaFN[activation]

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			Optional[int]									=    hidden_state
        A_    :			str									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[str]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[Any]									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			str									=    self.activation(snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_ = 1   , snake_case_ = "relu"   , snake_case_ = 4   , **snake_case_   , ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[int]									=    in_channels != out_channels or stride != 1
        A_    :			Optional[int]									=    out_channels // reduction
        A_    :			Optional[Any]									=    TFResNetConvLayer(snake_case_   , kernel_size=1   , name='layer.0'    )
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , stride=snake_case_   , name='layer.1'    )
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , kernel_size=1   , activation=snake_case_   , name='layer.2'    )
        A_    :			Any									=    (
            TFResNetShortCut(snake_case_   , stride=snake_case_   , name='shortcut'    )
            if should_apply_shortcut
            else tf.keras.layers.Activation('linear'   , name='shortcut'    )
        )
        A_    :			Dict									=    ACTaFN[activation]

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    hidden_state
        A_    :			int									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Optional[int]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			str									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			Union[str, Any]									=    self.activation(snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_   , snake_case_ = 2   , snake_case_ = 2   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )

        A_    :			str									=    TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

        A_    :			List[Any]									=    [layer(snake_case_   , snake_case_   , stride=snake_case_   , activation=config.hidden_act   , name='layers.0'    )]
        layers += [
            layer(snake_case_   , snake_case_   , activation=config.hidden_act   , name=F"""layers.{i + 1}"""    )
            for i in range(depth - 1    )
        ]
        A_    :			str									=    layers

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        for layer in self.stage_layers:
          A_    :			List[Any]									=    layer(snake_case_   , training=snake_case_    )
        return hidden_state


class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
        A_    :			Optional[int]									=    [
            TFResNetStage(
                snake_case_   , config.embedding_size   , config.hidden_sizes[0]   , stride=2 if config.downsample_in_first_stage else 1   , depth=config.depths[0]   , name='stages.0'   , )
        ]
        for i, (in_channels, out_channels, depth) in enumerate(
            zip(config.hidden_sizes   , config.hidden_sizes[1:]   , config.depths[1:]    )    ):
          self.stages.append(TFResNetStage(snake_case_   , snake_case_   , snake_case_   , depth=snake_case_   , name=F"""stages.{i + 1}"""    )    )

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False   , snake_case_ = True   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Any									=    () if output_hidden_states else None

        for stage_module in self.stages:
          if output_hidden_states:
            A_    :			Tuple									=    hidden_states + (hidden_state,)

          A_    :			Any									=    stage_module(snake_case_   , training=snake_case_    )

        if output_hidden_states:
          A_    :			List[str]									=    hidden_states + (hidden_state,)

        if not return_dict:
          return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

        return TFBaseModelOutputWithNoAttention(last_hidden_state=snake_case_   , hidden_states=snake_case_    )


class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig
      lowercase_ :					Dict             =  """resnet"""
      lowercase_ :					Union[str, Any]             =  """pixel_values"""

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)   , dtype=tf.floataa    )}


lowerCamelCase_	:		Tuple         =   r'\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'


lowerCamelCase_	:		Tuple         =   r'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'

@keras_serializable
class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Union[str, Any]									=    config
        A_    :			Optional[Any]									=    TFResNetEmbeddings(snake_case_   , name='embedder'    )
        A_    :			Any									=    TFResNetEncoder(snake_case_   , name='encoder'    )
        A_    :			List[str]									=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case_    )

      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Optional[int]									=    (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        A_    :			Dict									=    return_dict if return_dict is not None else self.config.use_return_dict

        # TF 2.0 image layers can't use NCHW format when running on CPU.
        # We transpose to NHWC format and then transpose back after the full forward pass.
        # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
        A_    :			str									=    tf.transpose(snake_case_   , perm=[0, 2, 3, 1]    )
        A_    :			Tuple									=    self.embedder(snake_case_   , training=snake_case_    )

        A_    :			List[Any]									=    self.encoder(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

        A_    :			Optional[int]									=    encoder_outputs[0]

        A_    :			int									=    self.pooler(snake_case_    )

        # Transpose all the outputs to the NCHW format
        # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
        A_    :			Dict									=    tf.transpose(snake_case_   , (0, 3, 1, 2)    )
        A_    :			int									=    tf.transpose(snake_case_   , (0, 3, 1, 2)    )
        A_    :			Optional[Any]									=    ()
        for hidden_state in encoder_outputs[1:]:
          A_    :			Union[str, Any]									=    hidden_states + tuple(tf.transpose(snake_case_   , (0, 3, 1, 2)    ) for h in hidden_state    )

        if not return_dict:
          return (last_hidden_state, pooled_output) + hidden_states

        A_    :			Dict									=    hidden_states if output_hidden_states else None

        return TFBaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=snake_case_   , pooler_output=snake_case_   , hidden_states=snake_case_   , )


@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""     ,  UpperCAmelCase__     ,  )
class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Dict									=    TFResNetMainLayer(config=snake_case_   , name='resnet'    )

      @add_start_docstrings_to_model_forward(snake_case_    )
      @add_code_sample_docstrings(
          checkpoint=_CHECKPOINT_FOR_DOC   , output_type=snake_case_   , config_class=_CONFIG_FOR_DOC   , modality='vision'   , expected_output=_EXPECTED_OUTPUT_SHAPE   , )
      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			int									=    (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        A_    :			List[Any]									=    return_dict if return_dict is not None else self.config.use_return_dict

        A_    :			Tuple									=    self.resnet(
            pixel_values=snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_   , )
        return resnet_outputs


@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """     ,  UpperCAmelCase__     ,  )
class 					_UpperCAmelCase    (  UpperCAmelCase__     ,  UpperCAmelCase__						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Any									=    config.num_labels
        A_    :			Tuple									=    TFResNetMainLayer(snake_case_   , name='resnet'    )
        # classification head
        A_    :			List[str]									=    (
            tf.keras.layers.Dense(config.num_labels   , name='classifier.1'    )
            if config.num_labels > 0
            else tf.keras.layers.Activation('linear'   , name='classifier.1'    )
        )

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        A_    :			Tuple									=    tf.keras.layers.Flatten()(snake_case_    )
        A_    :			List[str]									=    self.classifier_layer(snake_case_    )
        return logits

      @add_start_docstrings_to_model_forward(snake_case_    )
      @add_code_sample_docstrings(
          checkpoint=_IMAGE_CLASS_CHECKPOINT   , output_type=snake_case_   , config_class=_CONFIG_FOR_DOC   , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   , )
      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_ = None   , snake_case_ = None   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Optional[int]									=    return_dict if return_dict is not None else self.config.use_return_dict

        A_    :			Tuple									=    self.resnet(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

        A_    :			Tuple									=    outputs.pooler_output if return_dict else outputs[1]

        A_    :			str									=    self.classifier(snake_case_    )

        A_    :			Tuple									=    None if labels is None else self.hf_compute_loss(snake_case_   , snake_case_    )

        if not return_dict:
          A_    :			Tuple									=    (logits,) + outputs[2:]
          return (loss,) + output if loss is not None else output

        return TFImageClassifierOutputWithNoAttention(loss=snake_case_   , logits=snake_case_   , hidden_states=outputs.hidden_states    )





'''simple docstring'''







import enum
import inspect
from typing import Iterable, List, Optional, Tuple, Union





class 	lowerCamelCase_				(			enum.Enum				):




					'''simple docstring'''






					lowercase__       =					"""timm"""
					lowercase__       =					"""transformers"""






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_    ):



		'''simple docstring'''







		if stage_names is None:
				raise ValueError("Stage_names must be set for transformers backbones"    )

		if out_features is not None:
				if not isinstance(lowercase_		,				(list,)    ):
						raise ValueError(f'''out_features must be a list {type(lowercase_    )}'''    )
				if any(feat not in stage_names for feat in out_features    ):
						raise ValueError(f'''out_features must be a subset of stage_names: {stage_names} got {out_features}'''    )

		if out_indices is not None:
				if not isinstance(lowercase_		,				(list, tuple)    ):
						raise ValueError(f'''out_indices must be a list or tuple, got {type(lowercase_    )}'''    )
				if any(idx >= len(lowercase_    ) for idx in out_indices    ):
						raise ValueError("out_indices must be valid indices for stage_names {stage_names}, got {out_indices}"    )

		if out_features is not None and out_indices is not None:
				if len(lowercase_    ) != len(lowercase_    ):
						raise ValueError("out_features and out_indices should have the same length if both are set"    )
				if out_features != [stage_names[idx] for idx in out_indices]:
						raise ValueError("out_features and out_indices should correspond to the same stages if both are set"    )






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_		,				):



		'''simple docstring'''







		if out_indices is None and out_features is None:
				_snake_case      			=			[len(lowercase_    ) - 1]
				_snake_case      			=			[stage_names[-1]]
		elif out_indices is None and out_features is not None:
				_snake_case      			=			[stage_names.index(lowercase_    ) for layer in out_features]
		elif out_features is None and out_indices is not None:
				_snake_case      			=			[stage_names[idx] for idx in out_indices]
		return out_features, out_indices






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_		,				):



		'''simple docstring'''







		verify_out_features_out_indices(out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		_snake_case			,       _snake_case      			=			_align_output_features_output_indices(
		    out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		# Verify that the aligned out_features and out_indices are valid
		verify_out_features_out_indices(out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		return output_features, output_indices





class 	lowerCamelCase_				:




					'''simple docstring'''






					lowercase__       =					None






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							if getattr(self,    "_backbone",    __UpperCamelCase					) is None:
									raise ValueError("self._backbone must be set before calling _init_timm_backbone"					)

							# These will diagree with the defaults for the transformers models e.g. for resnet50
							# the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
							# the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
							_snake_case      			=			[stage["module"] for stage in self._backbone.feature_info.info]
							_snake_case      			=			[stage["num_chs"] for stage in self._backbone.feature_info.info]
							_snake_case      			=			self._backbone.feature_info.out_indices
							_snake_case      			=			self._backbone.feature_info.module_name()

							# We verify the out indices and out features are valid
							verify_out_features_out_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)
							_snake_case			,       _snake_case      			=			out_features, out_indices






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case      			=			getattr(__UpperCamelCase,    "stage_names"					)
							_snake_case      			=			getattr(__UpperCamelCase,    "out_features",    __UpperCamelCase					)
							_snake_case      			=			getattr(__UpperCamelCase,    "out_indices",    __UpperCamelCase					)

							_snake_case      			=			stage_names
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=__UpperCamelCase					)
							# Number of channels for each stage. This is set in the transformer backbone model init
							_snake_case      			=			None






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case      			=			config

							_snake_case      			=			getattr(__UpperCamelCase,    "use_timm_backbone",    __UpperCamelCase					)
							_snake_case      			=			BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS

							if self.backbone_type == BackboneType.TIMM:
									self._init_timm_backbone(__UpperCamelCase					)
							elif self.backbone_type == BackboneType.TRANSFORMERS:
									self._init_transformers_backbone(__UpperCamelCase					)
							else:
									raise ValueError(f'''backbone_type {self.backbone_type} not supported.'''					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_features






					@out_features.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_indices






					@out_indices.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# the current backbones will output the number of channels for each stage
							# even if that stage is not in the out_features list.
							return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names					)}






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return [self.out_feature_channels[name] for name in self.out_features]






					def 							__SCREAMING_SNAKE_CASE      (       self,    *__UpperCamelCase,    **__UpperCamelCase					):
							_snake_case      			=			dict(inspect.signature(self.forward					).parameters					)
							_snake_case      			=			{k: v for k, v in kwargs.items() if k in signature}
							return self(*__UpperCamelCase,    **__UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase,    __UpperCamelCase = None,    __UpperCamelCase = None,    __UpperCamelCase = None,    ):
							raise NotImplementedError("This method should be implemented by the derived class."					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			super().to_dict()
							_snake_case      			=			output.pop("_out_features"					)
							_snake_case      			=			output.pop("_out_indices"					)
							return output





class 	lowerCamelCase_				:




					'''simple docstring'''






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_features






					@out_features.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_indices






					@out_indices.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			super().to_dict()
							_snake_case      			=			output.pop("_out_features"					)
							_snake_case      			=			output.pop("_out_indices"					)
							return output





