



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_lowercase: Tuple      			=		{
    'configuration_data2vec_audio': ['DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Data2VecAudioConfig'],
    'configuration_data2vec_text': [
        'DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecTextConfig',
        'Data2VecTextOnnxConfig',
    ],
    'configuration_data2vec_vision': [
        'DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecVisionConfig',
        'Data2VecVisionOnnxConfig',
    ],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase: Dict      			=		[
				    'DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'Data2VecAudioForAudioFrameClassification',
				    'Data2VecAudioForCTC',
				    'Data2VecAudioForSequenceClassification',
				    'Data2VecAudioForXVector',
				    'Data2VecAudioModel',
				    'Data2VecAudioPreTrainedModel',
				]
				_lowercase: List[str]      			=		[
				    'DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'Data2VecTextForCausalLM',
				    'Data2VecTextForMaskedLM',
				    'Data2VecTextForMultipleChoice',
				    'Data2VecTextForQuestionAnswering',
				    'Data2VecTextForSequenceClassification',
				    'Data2VecTextForTokenClassification',
				    'Data2VecTextModel',
				    'Data2VecTextPreTrainedModel',
				]
				_lowercase: Union[str, Any]      			=		[
				    'DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'Data2VecVisionForImageClassification',
				    'Data2VecVisionForMaskedImageModeling',
				    'Data2VecVisionForSemanticSegmentation',
				    'Data2VecVisionModel',
				    'Data2VecVisionPreTrainedModel',
				]

if is_tf_available():
				_lowercase: Optional[int]      			=		[
				    'TFData2VecVisionForImageClassification',
				    'TFData2VecVisionForSemanticSegmentation',
				    'TFData2VecVisionModel',
				    'TFData2VecVisionPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
				from .configuration_dataavec_text import (
				    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    DataaVecTextConfig,
				    DataaVecTextOnnxConfig,
				)
				from .configuration_dataavec_vision import (
				    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    DataaVecVisionConfig,
				    DataaVecVisionOnnxConfig,
				)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_dataavec_audio import (
								    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecAudioForAudioFrameClassification,
								    DataaVecAudioForCTC,
								    DataaVecAudioForSequenceClassification,
								    DataaVecAudioForXVector,
								    DataaVecAudioModel,
								    DataaVecAudioPreTrainedModel,
								)
								from .modeling_dataavec_text import (
								    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecTextForCausalLM,
								    DataaVecTextForMaskedLM,
								    DataaVecTextForMultipleChoice,
								    DataaVecTextForQuestionAnswering,
								    DataaVecTextForSequenceClassification,
								    DataaVecTextForTokenClassification,
								    DataaVecTextModel,
								    DataaVecTextPreTrainedModel,
								)
								from .modeling_dataavec_vision import (
								    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecVisionForImageClassification,
								    DataaVecVisionForMaskedImageModeling,
								    DataaVecVisionForSemanticSegmentation,
								    DataaVecVisionModel,
								    DataaVecVisionPreTrainedModel,
								)
				if is_tf_available():
								from .modeling_tf_dataavec_vision import (
								    TFDataaVecVisionForImageClassification,
								    TFDataaVecVisionForSemanticSegmentation,
								    TFDataaVecVisionModel,
								    TFDataaVecVisionPreTrainedModel,
								)

else:
				import sys

				_lowercase: List[Any]      			=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map






def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			[]
				lowercase__    =			[]
				lowercase__    =			[]

				for rt in rc.restypes:
								lowercase__    =			rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
								restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]				)
								lowercase__    =			{name: i for i, name in enumerate(lowerCamelCase_				)}
								restype_atomaa_to_atomaa_list.append(
								    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]				)

								restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]				)

				# Add dummy mapping for restype 'UNK'
				restype_atomaa_to_atomaa_list.append([0] * 14				)
				restype_atomaa_to_atomaa_list.append([0] * 37				)
				restype_atomaa_mask_list.append([0.0] * 14				)

				lowercase__    =			torch.tensor(
				    lowerCamelCase_		,   dtype=torch.intaa		,   device=protein['''aatype'''].device		,   )
				lowercase__    =			torch.tensor(
				    lowerCamelCase_		,   dtype=torch.intaa		,   device=protein['''aatype'''].device		,   )
				lowercase__    =			torch.tensor(
				    lowerCamelCase_		,   dtype=torch.floataa		,   device=protein['''aatype'''].device		,   )
				lowercase__    =			protein['''aatype'''].to(torch.long				)

				# create the mapping for (residx, atom14) --> atom37, i.e. an array
				# with shape (num_res, 14) containing the atom37 indices for this protein
				lowercase__    =			restype_atomaa_to_atomaa[protein_aatype]
				lowercase__    =			restype_atomaa_mask[protein_aatype]

				lowercase__    =			residx_atomaa_mask
				lowercase__    =			residx_atomaa_to_atomaa.long()

				# create the gather indices for mapping back
				lowercase__    =			restype_atomaa_to_atomaa[protein_aatype]
				lowercase__    =			residx_atomaa_to_atomaa.long()

				# create the corresponding mask
				lowercase__    =			torch.zeros([21, 37]		,   dtype=torch.floataa		,   device=protein['''aatype'''].device				)
				for restype, restype_letter in enumerate(rc.restypes				):
								lowercase__    =			rc.restype_atoa[restype_letter]
								lowercase__    =			rc.residue_atoms[restype_name]
								for atom_name in atom_names:
												lowercase__    =			rc.atom_order[atom_name]
												lowercase__    =			1

				lowercase__    =			restype_atomaa_mask[protein_aatype]
				lowercase__    =			residx_atomaa_mask

				return protein






def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			tree_map(lambda lowerCamelCase_				: torch.tensor(lowerCamelCase_		,   device=batch['''aatype'''].device				)		,   lowerCamelCase_		,   np.ndarray				)
				lowercase__    =			tensor_tree_map(lambda lowerCamelCase_				: np.array(lowerCamelCase_				)		,   make_atomaa_masks(lowerCamelCase_				)				)
				return out




