

"""simple docstring"""






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  UpperCamelCase   (     _lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  None	)			->     torch.Tensor:
	...
@overload
def  UpperCamelCase   (     _lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor	)			->     Tuple[torch.Tensor, torch.Tensor]:
	...
def  UpperCamelCase   (     _lowerCAmelCase       :  Any,					_lowerCAmelCase       :  Optional[Any],					_lowerCAmelCase       :  Optional[Any]	)			->     Any:
	_UpperCAmelCase      :							Tuple       =   aatype == rc.restype_order["""G"""]
	_UpperCAmelCase      :							Optional[Any]       =   rc.atom_order["""CA"""]
	_UpperCAmelCase      :							str       =   rc.atom_order["""CB"""]
	_UpperCAmelCase      :							Optional[int]       =   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:
		_UpperCAmelCase      :							Optional[Any]       =   torch.where(
		    _lowerCAmelCase,					all_atom_masks[..., ca_idx],					all_atom_masks[..., cb_idx],					)
		return pseudo_beta, pseudo_beta_mask
	else:
		return pseudo_beta
def  UpperCamelCase   (     _lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  Dict[str, torch.Tensor]	)			->     torch.Tensor:
	_UpperCAmelCase      :							str       =   batched_gather(
	    _lowerCAmelCase,					batch["""residx_atom37_to_atom14"""],					dim=-2,					no_batch_dims=len(atomaa.shape[:-2]	),					)

	_UpperCAmelCase      :							Optional[Any]       =   atomaa_data * batch["""atom37_atom_exists"""][..., None]

	return atomaa_data
def  UpperCamelCase   (     _lowerCAmelCase       :  Dict[str, torch.Tensor]	)			->     torch.Tensor:
	_UpperCAmelCase      :							Any       =   template_feats["""template_aatype"""]
	_UpperCAmelCase      :							Optional[int]       =   template_feats["""template_torsion_angles_sin_cos"""]
	_UpperCAmelCase      :							List[str]       =   template_feats["""template_alt_torsion_angles_sin_cos"""]
	_UpperCAmelCase      :							Tuple       =   template_feats["""template_torsion_angles_mask"""]
	_UpperCAmelCase      :							int       =   torch.cat(
	    [
	        nn.functional.one_hot(_lowerCAmelCase,					22	),
	        torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2],					14	),
	        alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2],					14	),
	        torsion_angles_mask,
	    ],					dim=-1,					)

	return template_angle_feat
def  UpperCamelCase   (     _lowerCAmelCase       :  Dict[str, torch.Tensor],					_lowerCAmelCase       :  torch.types.Number,					_lowerCAmelCase       :  torch.types.Number,					_lowerCAmelCase       :  int,					_lowerCAmelCase       :  bool = False,					_lowerCAmelCase       :  float = 1E-2_0,					_lowerCAmelCase       :  float = 1E8,					)			->     torch.Tensor:
	_UpperCAmelCase      :							Any       =   batch["""template_pseudo_beta_mask"""]
	_UpperCAmelCase      :							Optional[int]       =   template_mask[..., None] * template_mask[..., None, :]

	# Compute distogram (this seems to differ slightly from Alg. 5)
	_UpperCAmelCase      :							int       =   batch["""template_pseudo_beta"""]
	_UpperCAmelCase      :							Union[str, Any]       =   torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2,					dim=-1,					keepdim=_lowerCAmelCase	)
	_UpperCAmelCase      :							Tuple       =   torch.linspace(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase,					device=tpb.device	) ** 2
	_UpperCAmelCase      :							Optional[int]       =   torch.cat([lower[1:], lower.new_tensor([inf]	)],					dim=-1	)
	_UpperCAmelCase      :							Union[str, Any]       =   ((dgram > lower) * (dgram < upper)).type(dgram.dtype	)

	_UpperCAmelCase      :							Tuple       =   [dgram, template_mask_ad[..., None]]

	_UpperCAmelCase      :							torch.LongTensor       =   nn.functional.one_hot(
	    batch["""template_aatype"""],					rc.restype_num + 2,					)

	_UpperCAmelCase      :							Union[str, Any]       =   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	)	)

	_UpperCAmelCase  ,				_UpperCAmelCase  ,				_UpperCAmelCase      :							Union[str, Any]       =   [rc.atom_order[a] for a in ["""N""", """CA""", """C"""]]
	_UpperCAmelCase      :							Optional[Any]       =   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,					)
	_UpperCAmelCase      :							Any       =   rigids.get_trans()[..., None, :, :]
	_UpperCAmelCase      :							List[Any]       =   rigids[..., None].invert_apply(_lowerCAmelCase	)

	_UpperCAmelCase      :							List[str]       =   torch.rsqrt(eps + torch.sum(rigid_vec**2,					dim=-1	)	)

	_UpperCAmelCase      :							str       =   batch["""template_all_atom_mask"""]
	_UpperCAmelCase      :							Any       =   t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
	_UpperCAmelCase      :							Union[str, Any]       =   template_mask[..., None] * template_mask[..., None, :]

	_UpperCAmelCase      :							List[str]       =   inv_distance_scalar * template_mask_ad
	_UpperCAmelCase      :							Tuple       =   rigid_vec * inv_distance_scalar[..., None]

	if not use_unit_vector:
		_UpperCAmelCase      :							Union[str, Any]       =   unit_vector * 0.0

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

	_UpperCAmelCase      :							Dict       =   torch.cat(_lowerCAmelCase,					dim=-1	)
	_UpperCAmelCase      :							int       =   act * template_mask_ad[..., None]

	return act
def  UpperCamelCase   (     _lowerCAmelCase       :  Dict[str, torch.Tensor]	)			->     torch.Tensor:
	_UpperCAmelCase      :							torch.LongTensor       =   nn.functional.one_hot(batch["""extra_msa"""],					23	)
	_UpperCAmelCase      :							str       =   [
	    msa_ahot,
	    batch["""extra_has_deletion"""].unsqueeze(-1	),
	    batch["""extra_deletion_value"""].unsqueeze(-1	),
	]
	return torch.cat(_lowerCAmelCase,					dim=-1	)
def  UpperCamelCase   (     _lowerCAmelCase       :  Rigid,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					)			->     Rigid:
	# [*, N, 8, 4, 4]
	_UpperCAmelCase      :							Optional[Any]       =   rrgdf[aatype, ...]

	# [*, N, 8] transformations, i.e.
	#   One [*, N, 8, 3, 3] rotation matrix and
	#   One [*, N, 8, 3]    translation matrix
	_UpperCAmelCase      :							Optional[int]       =   r.from_tensor_axa(_lowerCAmelCase	)

	_UpperCAmelCase      :							Optional[int]       =   alpha.new_zeros((*((1,) * len(alpha.shape[:-1]	)), 2)	)
	_UpperCAmelCase      :							Tuple       =   1

	# [*, N, 8, 2]
	_UpperCAmelCase      :							Dict       =   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.

	_UpperCAmelCase      :							List[str]       =   alpha.new_zeros(default_r.get_rots().get_rot_mats().shape	)
	_UpperCAmelCase      :							Optional[Any]       =   1
	_UpperCAmelCase      :							Tuple       =   alpha[..., 1]
	_UpperCAmelCase      :							Dict       =   -alpha[..., 0]
	_UpperCAmelCase      :							Tuple       =   alpha

	_UpperCAmelCase      :							Any       =   default_r.compose(Rigid(Rotation(rot_mats=_lowerCAmelCase	),					_lowerCAmelCase	)	)

	_UpperCAmelCase      :							Optional[Any]       =   all_frames[..., 5]
	_UpperCAmelCase      :							List[str]       =   all_frames[..., 6]
	_UpperCAmelCase      :							List[Any]       =   all_frames[..., 7]

	_UpperCAmelCase      :							List[Any]       =   all_frames[..., 4]
	_UpperCAmelCase      :							Optional[Any]       =   chia_frame_to_bb.compose(_lowerCAmelCase	)
	_UpperCAmelCase      :							List[str]       =   chia_frame_to_bb.compose(_lowerCAmelCase	)
	_UpperCAmelCase      :							Any       =   chia_frame_to_bb.compose(_lowerCAmelCase	)

	_UpperCAmelCase      :							List[Any]       =   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,					)

	_UpperCAmelCase      :							Optional[int]       =   r[..., None].compose(_lowerCAmelCase	)

	return all_frames_to_global





def  UpperCamelCase   (     _lowerCAmelCase       :  Rigid,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					_lowerCAmelCase       :  torch.Tensor,					)			->     torch.Tensor:
	# [*, N, 14]
	_UpperCAmelCase      :							List[str]       =   group_idx[aatype, ...]

	# [*, N, 14, 8]
	_UpperCAmelCase      :							torch.LongTensor       =   nn.functional.one_hot(
	    _lowerCAmelCase,					num_classes=default_frames.shape[-3],					)

	# [*, N, 14, 8]
	_UpperCAmelCase      :							List[Any]       =   r[..., None, :] * group_mask_one_hot

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

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

	# [*, N, 14, 3]
	_UpperCAmelCase      :							Optional[int]       =   lit_positions[aatype, ...]
	_UpperCAmelCase      :							List[str]       =   t_atoms_to_global.apply(_lowerCAmelCase	)
	_UpperCAmelCase      :							Optional[int]       =   pred_positions * atom_mask

	return pred_positions








"""simple docstring"""






from typing import TYPE_CHECKING

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


lowerCamelCase__			:					Union[str, Any]							  =					{
    '''configuration_unispeech_sat''': ['''UNISPEECH_SAT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechSatConfig'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			:					List[str]							  =					[
						    '''UNISPEECH_SAT_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''UniSpeechSatForAudioFrameClassification''',
						    '''UniSpeechSatForCTC''',
						    '''UniSpeechSatForPreTraining''',
						    '''UniSpeechSatForSequenceClassification''',
						    '''UniSpeechSatForXVector''',
						    '''UniSpeechSatModel''',
						    '''UniSpeechSatPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_unispeech_sat import UNISPEECH_SAT_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechSatConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_unispeech_sat import (
												    UNISPEECH_SAT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    UniSpeechSatForAudioFrameClassification,
												    UniSpeechSatForCTC,
												    UniSpeechSatForPreTraining,
												    UniSpeechSatForSequenceClassification,
												    UniSpeechSatForXVector,
												    UniSpeechSatModel,
												    UniSpeechSatPreTrainedModel,
												)

else:
						import sys

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





