from typing import Dict, Tuple, overload

import torch
import torch.types
from torch import nn

from . import residue_constants as rc
from .rigid_utils import Rigid, Rotation
from .tensor_utils import batched_gather






@overload
def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			):
       ...






@overload
def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			):
       ...






def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			):
       lowerCAmelCase__  			=      aatype == rc.restype_order['G']
       lowerCAmelCase__  			=      rc.atom_order['CA']
       lowerCAmelCase__  			=      rc.atom_order['CB']
       lowerCAmelCase__  			=      torch.where(
           is_gly[..., None].expand(*((-1,) * len(is_gly.shape			))			,						3			)			,						all_atom_positions[..., ca_idx, :]			,						all_atom_positions[..., cb_idx, :]			,						)

       if all_atom_masks is not None:
              lowerCAmelCase__  			=      torch.where(
                  lowerCAmelCase__			,						all_atom_masks[..., ca_idx]			,						all_atom_masks[..., cb_idx]			,						)
              return pseudo_beta, pseudo_beta_mask
       else:
              return pseudo_beta






def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			):
       lowerCAmelCase__  			=      batched_gather(
           lowerCAmelCase__			,						batch['residx_atom37_to_atom14']			,						dim=-2			,						no_batch_dims=len(atomaa.shape[:-2]			)			,						)

       lowerCAmelCase__  			=      atomaa_data * batch['atom37_atom_exists'][..., None]

       return atomaa_data






def    __lowerCamelCase	(		lowerCAmelCase__			):
       lowerCAmelCase__  			=      template_feats['template_aatype']
       lowerCAmelCase__  			=      template_feats['template_torsion_angles_sin_cos']
       lowerCAmelCase__  			=      template_feats['template_alt_torsion_angles_sin_cos']
       lowerCAmelCase__  			=      template_feats['template_torsion_angles_mask']
       lowerCAmelCase__  			=      torch.cat(
           [
               nn.functional.one_hot(lowerCAmelCase__			,						2_2			),
               torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2]			,						1_4			),
               alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2]			,						1_4			),
               torsion_angles_mask,
           ]			,						dim=-1			,						)

       return template_angle_feat






def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__ = False			,						lowerCAmelCase__ = 1e-2_0			,						lowerCAmelCase__ = 1e8			,						):
       lowerCAmelCase__  			=      batch['template_pseudo_beta_mask']
       lowerCAmelCase__  			=      template_mask[..., None] * template_mask[..., None, :]

       # Compute distogram (this seems to differ slightly from Alg. 5)
       lowerCAmelCase__  			=      batch['template_pseudo_beta']
       lowerCAmelCase__  			=      torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2			,						dim=-1			,						keepdim=lowerCAmelCase__			)
       lowerCAmelCase__  			=      torch.linspace(lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						device=tpb.device			) ** 2
       lowerCAmelCase__  			=      torch.cat([lower[1:], lower.new_tensor([inf]			)]			,						dim=-1			)
       lowerCAmelCase__  			=      ((dgram > lower) * (dgram < upper)).type(dgram.dtype			)

       lowerCAmelCase__  			=      [dgram, template_mask_ad[..., None]]

       lowerCAmelCase__  			=      nn.functional.one_hot(
           batch['template_aatype']			,						rc.restype_num + 2			,						)

       lowerCAmelCase__  			=      batch['template_aatype'].shape[-1]
       to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]			,						lowerCAmelCase__			,						-1			,						-1			)			)
       to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]			,						-1			,						lowerCAmelCase__			,						-1			)			)

       lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__  			=      [rc.atom_order[a] for a in ['N', 'CA', 'C']]
       lowerCAmelCase__  			=      Rigid.make_transform_from_reference(
           n_xyz=batch['template_all_atom_positions'][..., n, :]			,						ca_xyz=batch['template_all_atom_positions'][..., ca, :]			,						c_xyz=batch['template_all_atom_positions'][..., c, :]			,						eps=lowerCAmelCase__			,						)
       lowerCAmelCase__  			=      rigids.get_trans()[..., None, :, :]
       lowerCAmelCase__  			=      rigids[..., None].invert_apply(lowerCAmelCase__			)

       lowerCAmelCase__  			=      torch.rsqrt(eps + torch.sum(rigid_vec**2			,						dim=-1			)			)

       lowerCAmelCase__  			=      batch['template_all_atom_mask']
       lowerCAmelCase__  			=      t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
       lowerCAmelCase__  			=      template_mask[..., None] * template_mask[..., None, :]

       lowerCAmelCase__  			=      inv_distance_scalar * template_mask_ad
       lowerCAmelCase__  			=      rigid_vec * inv_distance_scalar[..., None]

       if not use_unit_vector:
              lowerCAmelCase__  			=      unit_vector * 0.0

       to_concat.extend(torch.unbind(unit_vector[..., None, :]			,						dim=-1			)			)
       to_concat.append(template_mask_ad[..., None]			)

       lowerCAmelCase__  			=      torch.cat(lowerCAmelCase__			,						dim=-1			)
       lowerCAmelCase__  			=      act * template_mask_ad[..., None]

       return act






def    __lowerCamelCase	(		lowerCAmelCase__			):
       lowerCAmelCase__  			=      nn.functional.one_hot(batch['extra_msa']			,						2_3			)
       lowerCAmelCase__  			=      [
           msa_ahot,
           batch['extra_has_deletion'].unsqueeze(-1			),
           batch['extra_deletion_value'].unsqueeze(-1			),
       ]
       return torch.cat(lowerCAmelCase__			,						dim=-1			)






def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						):
       # [*, N, 8, 4, 4]
       lowerCAmelCase__  			=      rrgdf[aatype, ...]

       # [*, N, 8] transformations, i.e.
       #   One [*, N, 8, 3, 3] rotation matrix and
       #   One [*, N, 8, 3]    translation matrix
       lowerCAmelCase__  			=      r.from_tensor_axa(lowerCAmelCase__			)

       lowerCAmelCase__  			=      alpha.new_zeros((*((1,) * len(alpha.shape[:-1]			)), 2)			)
       lowerCAmelCase__  			=      1

       # [*, N, 8, 2]
       lowerCAmelCase__  			=      torch.cat([bb_rot.expand(*alpha.shape[:-2]			,						-1			,						-1			), alpha]			,						dim=-2			)

       # [*, N, 8, 3, 3]
       # Produces rotation matrices of the form:
       # [
       #   [1, 0  , 0  ],
       #   [0, a_2,-a_1],
       #   [0, a_1, a_2]
       # ]
       # This follows the original code rather than the supplement, which uses
       # different indices.

       lowerCAmelCase__  			=      alpha.new_zeros(default_r.get_rots().get_rot_mats().shape			)
       lowerCAmelCase__  			=      1
       lowerCAmelCase__  			=      alpha[..., 1]
       lowerCAmelCase__  			=      -alpha[..., 0]
       lowerCAmelCase__  			=      alpha

       lowerCAmelCase__  			=      default_r.compose(Rigid(Rotation(rot_mats=lowerCAmelCase__			)			,						lowerCAmelCase__			)			)

       lowerCAmelCase__  			=      all_frames[..., 5]
       lowerCAmelCase__  			=      all_frames[..., 6]
       lowerCAmelCase__  			=      all_frames[..., 7]

       lowerCAmelCase__  			=      all_frames[..., 4]
       lowerCAmelCase__  			=      chia_frame_to_bb.compose(lowerCAmelCase__			)
       lowerCAmelCase__  			=      chia_frame_to_bb.compose(lowerCAmelCase__			)
       lowerCAmelCase__  			=      chia_frame_to_bb.compose(lowerCAmelCase__			)

       lowerCAmelCase__  			=      Rigid.cat(
           [
               all_frames[..., :5],
               chia_frame_to_bb.unsqueeze(-1			),
               chia_frame_to_bb.unsqueeze(-1			),
               chia_frame_to_bb.unsqueeze(-1			),
           ]			,						dim=-1			,						)

       lowerCAmelCase__  			=      r[..., None].compose(lowerCAmelCase__			)

       return all_frames_to_global






def    __lowerCamelCase	(		lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						):
       # [*, N, 14]
       lowerCAmelCase__  			=      group_idx[aatype, ...]

       # [*, N, 14, 8]
       lowerCAmelCase__  			=      nn.functional.one_hot(
           lowerCAmelCase__			,						num_classes=default_frames.shape[-3]			,						)

       # [*, N, 14, 8]
       lowerCAmelCase__  			=      r[..., None, :] * group_mask_one_hot

       # [*, N, 14]
       lowerCAmelCase__  			=      t_atoms_to_global.map_tensor_fn(lambda lowerCAmelCase__			: torch.sum(lowerCAmelCase__			,						dim=-1			)			)

       # [*, N, 14, 1]
       lowerCAmelCase__  			=      atom_mask[aatype, ...].unsqueeze(-1			)

       # [*, N, 14, 3]
       lowerCAmelCase__  			=      lit_positions[aatype, ...]
       lowerCAmelCase__  			=      t_atoms_to_global.apply(lowerCAmelCase__			)
       lowerCAmelCase__  			=      pred_positions * atom_mask

       return pred_positions

from typing import TYPE_CHECKING

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


lowerCAmelCase__					=				{
    '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:
    lowerCAmelCase__					=				[
        '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:
    lowerCAmelCase__					=				[
        '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:
    lowerCAmelCase__					=				[
        '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

    lowerCAmelCase__					=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
