

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        _lowercase  (					a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       None					)					->						torch.Tensor:




					'''simple docstring'''







					...




@overload
def        _lowercase  (					a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor					)					->						Tuple[torch.Tensor, torch.Tensor]:




					'''simple docstring'''







					...




def        _lowercase  (					a_					:       List[str]       ,a_					:       Union[str, Any]       ,a_					:       List[str]					)					->						Optional[int]:




					'''simple docstring'''







					__magic_name__				=     aatype == rc.restype_order['G']
					__magic_name__				=     rc.atom_order['CA']
					__magic_name__				=     rc.atom_order['CB']
					__magic_name__				=     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:
										__magic_name__				=     torch.where(
										    a_       ,all_atom_masks[..., ca_idx]       ,all_atom_masks[..., cb_idx]       ,)
										return pseudo_beta, pseudo_beta_mask
					else:
										return pseudo_beta




def        _lowercase  (					a_					:       torch.Tensor       ,a_					:       Dict[str, torch.Tensor]					)					->						torch.Tensor:




					'''simple docstring'''







					__magic_name__				=     batched_gather(
					    a_       ,batch['residx_atom37_to_atom14']       ,dim=-2       ,no_batch_dims=len(atomaa.shape[:-2]					)       ,)

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

					return atomaa_data




def        _lowercase  (					a_					:       Dict[str, torch.Tensor]					)					->						torch.Tensor:




					'''simple docstring'''







					__magic_name__				=     template_feats['template_aatype']
					__magic_name__				=     template_feats['template_torsion_angles_sin_cos']
					__magic_name__				=     template_feats['template_alt_torsion_angles_sin_cos']
					__magic_name__				=     template_feats['template_torsion_angles_mask']
					__magic_name__				=     torch.cat(
					    [
					        nn.functional.one_hot(a_       ,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        _lowercase  (					a_					:       Dict[str, torch.Tensor]       ,a_					:       torch.types.Number       ,a_					:       torch.types.Number       ,a_					:       int       ,a_					:       bool = False       ,a_					:       float = 1e-20       ,a_					:       float = 1e8       ,)					->						torch.Tensor:




					'''simple docstring'''







					__magic_name__				=     batch['template_pseudo_beta_mask']
					__magic_name__				=     template_mask[..., None] * template_mask[..., None, :]

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

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

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

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

					__magic_name__,						__magic_name__,						__magic_name__				=     [rc.atom_order[a] for a in ['N', 'CA', 'C']]
					__magic_name__				=     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=a_       ,)
					__magic_name__				=     rigids.get_trans()[..., None, :, :]
					__magic_name__				=     rigids[..., None].invert_apply(a_					)

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

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

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

					if not use_unit_vector:
										__magic_name__				=     unit_vector * 0.0

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

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

					return act




def        _lowercase  (					a_					:       Dict[str, torch.Tensor]					)					->						torch.Tensor:




					'''simple docstring'''







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




def        _lowercase  (					a_					:       Rigid       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,)					->						Rigid:




					'''simple docstring'''







					__magic_name__				=     rrgdf[aatype, ...]

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

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

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

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

					__magic_name__				=     default_r.compose(Rigid(Rotation(rot_mats=a_					)       ,a_					)					)

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

					__magic_name__				=     all_frames[..., 4]
					__magic_name__				=     chia_frame_to_bb.compose(a_					)
					__magic_name__				=     chia_frame_to_bb.compose(a_					)
					__magic_name__				=     chia_frame_to_bb.compose(a_					)

					__magic_name__				=     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       ,)

					__magic_name__				=     r[..., None].compose(a_					)

					return all_frames_to_global




def        _lowercase  (					a_					:       Rigid       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,a_					:       torch.Tensor       ,)					->						torch.Tensor:




					'''simple docstring'''







					__magic_name__				=     group_idx[aatype, ...]

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

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

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

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

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

					return pred_positions







from typing import Callable, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__							=				logging.get_logger(__name__)

A__							=				{
    "microsoft/prophetnet-large-uncased": (
        "https://huggingface.co/microsoft/prophetnet-large-uncased/resolve/main/config.json"
    ),
}

class 					__UpperCamelCase					(       SCREAMING_SNAKE_CASE      ):
	_lowercase	: Union[str, Any]												=	"prophetnet"
	_lowercase	: Any												=	["past_key_values"]
	_lowercase	: int												=	{
	    "num_attention_heads": "num_encoder_attention_heads",
	}







	def __init__( self:			Union[str, Any]	,			__UpperCamelCase:			Optional[float] = 0.1	,			__UpperCamelCase:			Optional[Union[str, Callable]] = "gelu"	,			__UpperCamelCase:			Optional[int] = 3_05_22	,			__UpperCamelCase:			Optional[int] = 10_24	,			__UpperCamelCase:			Optional[int] = 40_96	,			__UpperCamelCase:			Optional[int] = 12	,			__UpperCamelCase:			Optional[int] = 16	,			__UpperCamelCase:			Optional[int] = 40_96	,			__UpperCamelCase:			Optional[int] = 12	,			__UpperCamelCase:			Optional[int] = 16	,			__UpperCamelCase:			Optional[float] = 0.1	,			__UpperCamelCase:			Optional[float] = 0.1	,			__UpperCamelCase:			Optional[int] = 5_12	,			__UpperCamelCase:			Optional[float] = 0.02	,			__UpperCamelCase:			Optional[bool] = True	,			__UpperCamelCase:			Optional[bool] = True	,			__UpperCamelCase:			Optional[int] = 0	,			__UpperCamelCase:			Optional[int] = 2	,			__UpperCamelCase:			Optional[int] = 32	,			__UpperCamelCase:			Optional[int] = 1_28	,			__UpperCamelCase:			Optional[bool] = False	,			__UpperCamelCase:			Optional[float] = 0.0	,			__UpperCamelCase:			Optional[bool] = True	,			__UpperCamelCase:			Optional[int] = 0	,			__UpperCamelCase:			Optional[int] = 1	,			__UpperCamelCase:			Optional[int] = 2	,			**__UpperCamelCase:			Optional[int]	,			):

						'''simple docstring'''





						__magic_name__				=     vocab_size
						__magic_name__				=     hidden_size
						__magic_name__				=     encoder_ffn_dim
						__magic_name__				=     num_encoder_layers
						__magic_name__				=     num_encoder_attention_heads
						__magic_name__				=     decoder_ffn_dim
						__magic_name__				=     num_decoder_layers
						__magic_name__				=     num_decoder_attention_heads
						__magic_name__				=     max_position_embeddings
						__magic_name__				=     init_std  # Normal(0, this parameter)
						__magic_name__				=     activation_function

						# parameters for prophetnet
						__magic_name__				=     ngram
						__magic_name__				=     num_buckets
						__magic_name__				=     relative_max_distance
						__magic_name__				=     disable_ngram_loss
						__magic_name__				=     eps

						# 3 Types of Dropout
						__magic_name__				=     attention_dropout
						__magic_name__				=     activation_dropout
						__magic_name__				=     dropout

						__magic_name__				=     use_cache

						super().__init__(
						    pad_token_id=__UpperCamelCase	,			bos_token_id=__UpperCamelCase	,			eos_token_id=__UpperCamelCase	,			is_encoder_decoder=__UpperCamelCase	,			add_cross_attention=__UpperCamelCase	,			decoder_start_token_id=__UpperCamelCase	,			**__UpperCamelCase	,			)







	@property
	def 						_SCREAMING_SNAKE_CASE				( self:			Tuple   ):

						'''simple docstring'''





						return self.num_encoder_layers + self.num_decoder_layers







	@num_hidden_layers.setter
	def 						_SCREAMING_SNAKE_CASE				( self:			Union[str, Any]	,			__UpperCamelCase:			List[Any]   ):

						'''simple docstring'''





						raise NotImplementedError(
						    'This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'
						    ' `num_decoder_layers`.'   )




