



'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCamelCase__    :     Optional[int]			  =   {
    'auto_factory': ['get_values'],
    'configuration_auto': ['ALL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CONFIG_MAPPING', 'MODEL_NAMES_MAPPING', 'AutoConfig'],
    'feature_extraction_auto': ['FEATURE_EXTRACTOR_MAPPING', 'AutoFeatureExtractor'],
    'image_processing_auto': ['IMAGE_PROCESSOR_MAPPING', 'AutoImageProcessor'],
    'processing_auto': ['PROCESSOR_MAPPING', 'AutoProcessor'],
    'tokenization_auto': ['TOKENIZER_MAPPING', 'AutoTokenizer'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     List[Any]			  =   [
      'MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
      'MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING',
      'MODEL_FOR_AUDIO_XVECTOR_MAPPING',
      'MODEL_FOR_BACKBONE_MAPPING',
      'MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING',
      'MODEL_FOR_CAUSAL_LM_MAPPING',
      'MODEL_FOR_CTC_MAPPING',
      'MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING',
      'MODEL_FOR_DEPTH_ESTIMATION_MAPPING',
      'MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
      'MODEL_FOR_IMAGE_SEGMENTATION_MAPPING',
      'MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING',
      'MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING',
      'MODEL_FOR_MASKED_LM_MAPPING',
      'MODEL_FOR_MASK_GENERATION_MAPPING',
      'MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
      'MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
      'MODEL_FOR_OBJECT_DETECTION_MAPPING',
      'MODEL_FOR_PRETRAINING_MAPPING',
      'MODEL_FOR_QUESTION_ANSWERING_MAPPING',
      'MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING',
      'MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
      'MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
      'MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
      'MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING',
      'MODEL_FOR_TEXT_ENCODING_MAPPING',
      'MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
      'MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING',
      'MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING',
      'MODEL_FOR_VISION_2_SEQ_MAPPING',
      'MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING',
      'MODEL_MAPPING',
      'MODEL_WITH_LM_HEAD_MAPPING',
      'MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING',
      'MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING',
      'AutoModel',
      'AutoBackbone',
      'AutoModelForAudioClassification',
      'AutoModelForAudioFrameClassification',
      'AutoModelForAudioXVector',
      'AutoModelForCausalLM',
      'AutoModelForCTC',
      'AutoModelForDepthEstimation',
      'AutoModelForImageClassification',
      'AutoModelForImageSegmentation',
      'AutoModelForInstanceSegmentation',
      'AutoModelForMaskGeneration',
      'AutoModelForTextEncoding',
      'AutoModelForMaskedImageModeling',
      'AutoModelForMaskedLM',
      'AutoModelForMultipleChoice',
      'AutoModelForNextSentencePrediction',
      'AutoModelForObjectDetection',
      'AutoModelForPreTraining',
      'AutoModelForQuestionAnswering',
      'AutoModelForSemanticSegmentation',
      'AutoModelForSeq2SeqLM',
      'AutoModelForSequenceClassification',
      'AutoModelForSpeechSeq2Seq',
      'AutoModelForTableQuestionAnswering',
      'AutoModelForTokenClassification',
      'AutoModelForUniversalSegmentation',
      'AutoModelForVideoClassification',
      'AutoModelForVision2Seq',
      'AutoModelForVisualQuestionAnswering',
      'AutoModelForDocumentQuestionAnswering',
      'AutoModelWithLMHead',
      'AutoModelForZeroShotImageClassification',
      'AutoModelForZeroShotObjectDetection',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     Union[str, Any]			  =   [
      'TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
      'TF_MODEL_FOR_CAUSAL_LM_MAPPING',
      'TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
      'TF_MODEL_FOR_MASK_GENERATION_MAPPING',
      'TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING',
      'TF_MODEL_FOR_MASKED_LM_MAPPING',
      'TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
      'TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
      'TF_MODEL_FOR_PRETRAINING_MAPPING',
      'TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING',
      'TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING',
      'TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING',
      'TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
      'TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
      'TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
      'TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING',
      'TF_MODEL_FOR_TEXT_ENCODING_MAPPING',
      'TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
      'TF_MODEL_FOR_VISION_2_SEQ_MAPPING',
      'TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING',
      'TF_MODEL_MAPPING',
      'TF_MODEL_WITH_LM_HEAD_MAPPING',
      'TFAutoModel',
      'TFAutoModelForAudioClassification',
      'TFAutoModelForCausalLM',
      'TFAutoModelForImageClassification',
      'TFAutoModelForMaskedImageModeling',
      'TFAutoModelForMaskedLM',
      'TFAutoModelForMaskGeneration',
      'TFAutoModelForMultipleChoice',
      'TFAutoModelForNextSentencePrediction',
      'TFAutoModelForPreTraining',
      'TFAutoModelForDocumentQuestionAnswering',
      'TFAutoModelForQuestionAnswering',
      'TFAutoModelForSemanticSegmentation',
      'TFAutoModelForSeq2SeqLM',
      'TFAutoModelForSequenceClassification',
      'TFAutoModelForSpeechSeq2Seq',
      'TFAutoModelForTableQuestionAnswering',
      'TFAutoModelForTextEncoding',
      'TFAutoModelForTokenClassification',
      'TFAutoModelForVision2Seq',
      'TFAutoModelForZeroShotImageClassification',
      'TFAutoModelWithLMHead',
  ]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    :     str			  =   [
      'FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
      'FLAX_MODEL_FOR_CAUSAL_LM_MAPPING',
      'FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
      'FLAX_MODEL_FOR_MASKED_LM_MAPPING',
      'FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
      'FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
      'FLAX_MODEL_FOR_PRETRAINING_MAPPING',
      'FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING',
      'FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
      'FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
      'FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
      'FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
      'FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING',
      'FLAX_MODEL_MAPPING',
      'FlaxAutoModel',
      'FlaxAutoModelForCausalLM',
      'FlaxAutoModelForImageClassification',
      'FlaxAutoModelForMaskedLM',
      'FlaxAutoModelForMultipleChoice',
      'FlaxAutoModelForNextSentencePrediction',
      'FlaxAutoModelForPreTraining',
      'FlaxAutoModelForQuestionAnswering',
      'FlaxAutoModelForSeq2SeqLM',
      'FlaxAutoModelForSequenceClassification',
      'FlaxAutoModelForSpeechSeq2Seq',
      'FlaxAutoModelForTokenClassification',
      'FlaxAutoModelForVision2Seq',
  ]


if TYPE_CHECKING:
  from .auto_factory import get_values
  from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
  from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
  from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
  from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
  from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_auto import (
        MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
        MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
        MODEL_FOR_AUDIO_XVECTOR_MAPPING,
        MODEL_FOR_BACKBONE_MAPPING,
        MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
        MODEL_FOR_CAUSAL_LM_MAPPING,
        MODEL_FOR_CTC_MAPPING,
        MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
        MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
        MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
        MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
        MODEL_FOR_MASK_GENERATION_MAPPING,
        MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
        MODEL_FOR_MASKED_LM_MAPPING,
        MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
        MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
        MODEL_FOR_OBJECT_DETECTION_MAPPING,
        MODEL_FOR_PRETRAINING_MAPPING,
        MODEL_FOR_QUESTION_ANSWERING_MAPPING,
        MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
        MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
        MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
        MODEL_FOR_TEXT_ENCODING_MAPPING,
        MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
        MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
        MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
        MODEL_FOR_VISION_2_SEQ_MAPPING,
        MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
        MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
        MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
        MODEL_MAPPING,
        MODEL_WITH_LM_HEAD_MAPPING,
        AutoBackbone,
        AutoModel,
        AutoModelForAudioClassification,
        AutoModelForAudioFrameClassification,
        AutoModelForAudioXVector,
        AutoModelForCausalLM,
        AutoModelForCTC,
        AutoModelForDepthEstimation,
        AutoModelForDocumentQuestionAnswering,
        AutoModelForImageClassification,
        AutoModelForImageSegmentation,
        AutoModelForInstanceSegmentation,
        AutoModelForMaskedImageModeling,
        AutoModelForMaskedLM,
        AutoModelForMaskGeneration,
        AutoModelForMultipleChoice,
        AutoModelForNextSentencePrediction,
        AutoModelForObjectDetection,
        AutoModelForPreTraining,
        AutoModelForQuestionAnswering,
        AutoModelForSemanticSegmentation,
        AutoModelForSeqaSeqLM,
        AutoModelForSequenceClassification,
        AutoModelForSpeechSeqaSeq,
        AutoModelForTableQuestionAnswering,
        AutoModelForTextEncoding,
        AutoModelForTokenClassification,
        AutoModelForUniversalSegmentation,
        AutoModelForVideoClassification,
        AutoModelForVisionaSeq,
        AutoModelForVisualQuestionAnswering,
        AutoModelForZeroShotImageClassification,
        AutoModelForZeroShotObjectDetection,
        AutoModelWithLMHead,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_auto import (
        TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
        TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_MASK_GENERATION_MAPPING,
        TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
        TF_MODEL_FOR_MASKED_LM_MAPPING,
        TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
        TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
        TF_MODEL_FOR_PRETRAINING_MAPPING,
        TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
        TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
        TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
        TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
        TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
        TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
        TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
        TF_MODEL_MAPPING,
        TF_MODEL_WITH_LM_HEAD_MAPPING,
        TFAutoModel,
        TFAutoModelForAudioClassification,
        TFAutoModelForCausalLM,
        TFAutoModelForDocumentQuestionAnswering,
        TFAutoModelForImageClassification,
        TFAutoModelForMaskedImageModeling,
        TFAutoModelForMaskedLM,
        TFAutoModelForMaskGeneration,
        TFAutoModelForMultipleChoice,
        TFAutoModelForNextSentencePrediction,
        TFAutoModelForPreTraining,
        TFAutoModelForQuestionAnswering,
        TFAutoModelForSemanticSegmentation,
        TFAutoModelForSeqaSeqLM,
        TFAutoModelForSequenceClassification,
        TFAutoModelForSpeechSeqaSeq,
        TFAutoModelForTableQuestionAnswering,
        TFAutoModelForTextEncoding,
        TFAutoModelForTokenClassification,
        TFAutoModelForVisionaSeq,
        TFAutoModelForZeroShotImageClassification,
        TFAutoModelWithLMHead,
    )

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_auto import (
        FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
        FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
        FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        FLAX_MODEL_FOR_MASKED_LM_MAPPING,
        FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
        FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
        FLAX_MODEL_FOR_PRETRAINING_MAPPING,
        FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
        FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
        FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
        FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
        FLAX_MODEL_MAPPING,
        FlaxAutoModel,
        FlaxAutoModelForCausalLM,
        FlaxAutoModelForImageClassification,
        FlaxAutoModelForMaskedLM,
        FlaxAutoModelForMultipleChoice,
        FlaxAutoModelForNextSentencePrediction,
        FlaxAutoModelForPreTraining,
        FlaxAutoModelForQuestionAnswering,
        FlaxAutoModelForSeqaSeqLM,
        FlaxAutoModelForSequenceClassification,
        FlaxAutoModelForSpeechSeqaSeq,
        FlaxAutoModelForTokenClassification,
        FlaxAutoModelForVisionaSeq,
    )

else:
  import sys

  UpperCamelCase__    :     Any			  =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





'''simple docstring'''





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


class 							_lowerCAmelCase	(  enum.Enum							):


 """simple docstring"""

 lowerCamelCase									=     '''timm'''
 lowerCamelCase									=     '''transformers'''



def     UpperCAmelCase     (    a_      ,		a_      ,		a_		)   ->       Optional[Any]:



   """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(a_      ,		(list,)		):
         raise ValueError(F"out_features must be a list {type(a_		)}"		)
      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(a_      ,		(list, tuple)		):
         raise ValueError(F"out_indices must be a list or tuple, got {type(a_		)}"		)
      if any(idx >= len(a_		) 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(a_		) != len(a_		):
         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     UpperCAmelCase     (    a_      ,		a_      ,		a_      ,		)   ->       Dict:



   """simple docstring"""






   if out_indices is None and out_features is None:
      A_  :		Optional[Any]						=					[len(a_		) - 1]
      A_  :		Optional[int]						=					[stage_names[-1]]
   elif out_indices is None and out_features is not None:
      A_  :		Optional[Any]						=					[stage_names.index(a_		) for layer in out_features]
   elif out_features is None and out_indices is not None:
      A_  :		int						=					[stage_names[idx] for idx in out_indices]
   return out_features, out_indices



def     UpperCAmelCase     (    a_      ,		a_      ,		a_      ,		)   ->       Tuple[List[str], List[int]]:



   """simple docstring"""






   verify_out_features_out_indices(out_features=a_      ,		out_indices=a_      ,		stage_names=a_		)
   A_						,  A_  :		List[Any]						=					_align_output_features_output_indices(
       out_features=a_      ,		out_indices=a_      ,		stage_names=a_		)
   # Verify that the aligned out_features and out_indices are valid
   verify_out_features_out_indices(out_features=a_      ,		out_indices=a_      ,		stage_names=a_		)
   return output_features, output_indices


class 							_lowerCAmelCase	:


 """simple docstring"""

 lowerCamelCase									=     None







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    None:
    if getattr(self					,    """_backbone"""					,    _lowerCamelCase  ) 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']
    A_  :		str						=					[stage["""module"""] for stage in self._backbone.feature_info.info]
    A_  :		Any						=					[stage["""num_chs"""] for stage in self._backbone.feature_info.info]
    A_  :		Tuple						=					self._backbone.feature_info.out_indices
    A_  :		str						=					self._backbone.feature_info.module_name()

    # We verify the out indices and out features are valid
    verify_out_features_out_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=self.stage_names  )
    A_						,  A_  :		List[Any]						=					out_features, out_indices







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    None:
    A_  :		List[Any]						=					getattr(_lowerCamelCase					,    """stage_names"""  )
    A_  :		int						=					getattr(_lowerCamelCase					,    """out_features"""					,    _lowerCamelCase  )
    A_  :		Optional[int]						=					getattr(_lowerCamelCase					,    """out_indices"""					,    _lowerCamelCase  )

    A_  :		Union[str, Any]						=					stage_names
    A_						,  A_  :		List[str]						=					get_aligned_output_features_output_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=_lowerCamelCase  )
    # Number of channels for each stage. This is set in the transformer backbone model init
    A_  :		int						=					None







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    None:
    A_  :		Optional[Any]						=					config

    A_  :		Optional[Any]						=					getattr(_lowerCamelCase					,    """use_timm_backbone"""					,    _lowerCamelCase  )
    A_  :		Optional[int]						=					BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS

    if self.backbone_type == BackboneType.TIMM:
       self._init_timm_backbone(_lowerCamelCase  )
    elif self.backbone_type == BackboneType.TRANSFORMERS:
       self._init_transformers_backbone(_lowerCamelCase  )
    else:
       raise ValueError(F"backbone_type {self.backbone_type} not supported."  )







 @property
 def       UpperCAmelCase_       (      self  )    ->    List[str]:
    return self._out_features







 @out_features.setter
 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    Any:
    A_						,  A_  :		Union[str, Any]						=					get_aligned_output_features_output_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=self.stage_names  )







 @property
 def       UpperCAmelCase_       (      self  )    ->    Any:
    return self._out_indices







 @out_indices.setter
 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    Union[str, Any]:
    A_						,  A_  :		List[str]						=					get_aligned_output_features_output_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=self.stage_names  )







 @property
 def       UpperCAmelCase_       (      self  )    ->    Dict:
    # 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       UpperCAmelCase_       (      self  )    ->    Any:
    return [self.out_feature_channels[name] for name in self.out_features]







 def       UpperCAmelCase_       (      self					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    List[Any]:
    A_  :		Optional[int]						=					dict(inspect.signature(self.forward  ).parameters  )
    A_  :		str						=					{k: v for k, v in kwargs.items() if k in signature}
    return self(*_lowerCamelCase					,    **_lowerCamelCase  )







 def       UpperCAmelCase_       (      self					,    _lowerCamelCase					,    _lowerCamelCase = None					,    _lowerCamelCase = None					,    _lowerCamelCase = None					,    )    ->    List[Any]:
    raise NotImplementedError("""This method should be implemented by the derived class."""  )







 def       UpperCAmelCase_       (      self  )    ->    List[str]:
    A_  :		Optional[int]						=					super().to_dict()
    A_  :		Union[str, Any]						=					output.pop("""_out_features"""  )
    A_  :		int						=					output.pop("""_out_indices"""  )
    return output


class 							_lowerCAmelCase	:


 """simple docstring"""

 @property
 def       UpperCAmelCase_       (      self  )    ->    Union[str, Any]:
    return self._out_features







 @out_features.setter
 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    List[str]:
    A_						,  A_  :		List[str]						=					get_aligned_output_features_output_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=self.stage_names  )







 @property
 def       UpperCAmelCase_       (      self  )    ->    List[Any]:
    return self._out_indices







 @out_indices.setter
 def       UpperCAmelCase_       (      self					,    _lowerCamelCase  )    ->    str:
    A_						,  A_  :		Union[str, Any]						=					get_aligned_output_features_output_indices(
        out_features=_lowerCamelCase					,    out_indices=_lowerCamelCase					,    stage_names=self.stage_names  )







 def       UpperCAmelCase_       (      self  )    ->    List[str]:
    A_  :		Optional[int]						=					super().to_dict()
    A_  :		Tuple						=					output.pop("""_out_features"""  )
    A_  :		Optional[Any]						=					output.pop("""_out_indices"""  )
    return output
