





"""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 			a_							(				_lowercase			,		_lowercase			,		_lowercase  ):
						...





@overload
def 			a_							(				_lowercase			,		_lowercase			,		_lowercase  ):
						...





def 			a_							(				_lowercase			,		_lowercase			,		_lowercase  ):
						_UpperCamelCase     :   Tuple      =       aatype == rc.restype_order['''G''']
						_UpperCamelCase     :   Optional[Any]      =       rc.atom_order['''CA''']
						_UpperCamelCase     :   Dict      =       rc.atom_order['''CB''']
						_UpperCamelCase     :   Tuple      =       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     :   List[str]      =       torch.where(
												    _lowercase			,		all_atom_masks[..., ca_idx]			,		all_atom_masks[..., cb_idx]			,		)
												return pseudo_beta, pseudo_beta_mask
						else:
												return pseudo_beta





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

						_UpperCamelCase     :   int      =       atomaa_data * batch['''atom37_atom_exists'''][..., None]

						return atomaa_data





def 			a_							(				_lowercase  ):
						_UpperCamelCase     :   str      =       template_feats['''template_aatype''']
						_UpperCamelCase     :   Optional[int]      =       template_feats['''template_torsion_angles_sin_cos''']
						_UpperCamelCase     :   Tuple      =       template_feats['''template_alt_torsion_angles_sin_cos''']
						_UpperCamelCase     :   List[str]      =       template_feats['''template_torsion_angles_mask''']
						_UpperCamelCase     :   Dict      =       torch.cat(
						    [
						        nn.functional.one_hot(_lowercase			,		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 			a_							(				_lowercase			,		_lowercase			,		_lowercase			,		_lowercase			,		_lowercase = False			,		_lowercase = 1E-20			,		_lowercase = 1E8			,		):
						_UpperCamelCase     :   Optional[int]      =       batch['''template_pseudo_beta_mask''']
						_UpperCamelCase     :   Optional[Any]      =       template_mask[..., None] * template_mask[..., None, :]

						# Compute distogram (this seems to differ slightly from Alg. 5)
						_UpperCamelCase     :   Optional[int]      =       batch['''template_pseudo_beta''']
						_UpperCamelCase     :   Dict      =       torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2			,		dim=-1			,		keepdim=_lowercase  )
						_UpperCamelCase     :   Dict      =       torch.linspace(_lowercase			,		_lowercase			,		_lowercase			,		device=tpb.device  ) ** 2
						_UpperCamelCase     :   List[Any]      =       torch.cat([lower[1:], lower.new_tensor([inf]  )]			,		dim=-1  )
						_UpperCamelCase     :   Optional[int]      =       ((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     :   List[str]      =       batch['''template_aatype'''].shape[-1]
						to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]			,		_lowercase			,		-1			,		-1  )  )
						to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]			,		-1			,		_lowercase			,		-1  )  )

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

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

						_UpperCamelCase     :   List[str]      =       batch['''template_all_atom_mask''']
						_UpperCamelCase     :   int      =       t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
						_UpperCamelCase     :   Union[str, Any]      =       template_mask[..., None] * template_mask[..., None, :]

						_UpperCamelCase     :   List[Any]      =       inv_distance_scalar * template_mask_ad
						_UpperCamelCase     :   int      =       rigid_vec * inv_distance_scalar[..., None]

						if not use_unit_vector:
												_UpperCamelCase     :   Any      =       unit_vector * 0.0

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

						_UpperCamelCase     :   int      =       torch.cat(_lowercase			,		dim=-1  )
						_UpperCamelCase     :   List[Any]      =       act * template_mask_ad[..., None]

						return act





def 			a_							(				_lowercase  ):
						_UpperCamelCase     :   torch.LongTensor      =       nn.functional.one_hot(batch['''extra_msa''']			,		23  )
						_UpperCamelCase     :   Optional[Any]      =       [
						    msa_ahot,
						    batch['''extra_has_deletion'''].unsqueeze(-1  ),
						    batch['''extra_deletion_value'''].unsqueeze(-1  ),
						]
						return torch.cat(_lowercase			,		dim=-1  )





def 			a_							(				_lowercase			,		_lowercase			,		_lowercase			,		_lowercase			,		):
						# [*, N, 8, 4, 4]
						_UpperCamelCase     :   List[str]      =       rrgdf[aatype, ...]

						# [*, N, 8] transformations, i.e.
						#   One [*, N, 8, 3, 3] rotation matrix and
						#   One [*, N, 8, 3]    translation matrix
						_UpperCamelCase     :   Union[str, Any]      =       r.from_tensor_axa(_lowercase  )

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

						# [*, N, 8, 2]
						_UpperCamelCase     :   Tuple      =       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     :   Any      =       1
						_UpperCamelCase     :   Tuple      =       alpha[..., 1]
						_UpperCamelCase     :   List[str]      =       -alpha[..., 0]
						_UpperCamelCase     :   Any      =       alpha

						_UpperCamelCase     :   int      =       default_r.compose(Rigid(Rotation(rot_mats=_lowercase  )			,		_lowercase  )  )

						_UpperCamelCase     :   int      =       all_frames[..., 5]
						_UpperCamelCase     :   int      =       all_frames[..., 6]
						_UpperCamelCase     :   Optional[Any]      =       all_frames[..., 7]

						_UpperCamelCase     :   Union[str, Any]      =       all_frames[..., 4]
						_UpperCamelCase     :   Any      =       chia_frame_to_bb.compose(_lowercase  )
						_UpperCamelCase     :   Union[str, Any]      =       chia_frame_to_bb.compose(_lowercase  )
						_UpperCamelCase     :   Union[str, Any]      =       chia_frame_to_bb.compose(_lowercase  )

						_UpperCamelCase     :   str      =       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     :   List[str]      =       r[..., None].compose(_lowercase  )

						return all_frames_to_global






def 			a_							(				_lowercase			,		_lowercase			,		_lowercase			,		_lowercase			,		_lowercase			,		_lowercase			,		):
						# [*, N, 14]
						_UpperCamelCase     :   Optional[Any]      =       group_idx[aatype, ...]

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

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

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

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

						# [*, N, 14, 3]
						_UpperCamelCase     :   Union[str, Any]      =       lit_positions[aatype, ...]
						_UpperCamelCase     :   Any      =       t_atoms_to_global.apply(_lowercase  )
						_UpperCamelCase     :   Dict      =       pred_positions * atom_mask

						return pred_positions











'''simple docstring'''

import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm






def 						_UpperCAmelCase     (	a		:						Tuple    ,      a		:						int				)      ->      List[str]:





						"""simple docstring"""
						if isinstance(a    ,      (list, tuple)				):
												return honor_type(a    ,      (move_to_device(a    ,      a				) for t in state)				)
						elif isinstance(a    ,      a				):
												return type(a				)({k: move_to_device(a    ,      a				) for k, v in state.items()}				)
						elif isinstance(a    ,      torch.Tensor				):
												return state.to(a				)
						return state






class 				__magic_name__  (						torch.optim.Optimizer					):







	"""simple docstring"""



	def __init__(				self	,   _lowercase	,   _lowercase=True	,   _lowercase=None							)    ->	int:
							lowercase_   : List[str]   	=      optimizer
							lowercase_   : Optional[int]   	=      scaler
							lowercase_   : Union[str, Any]   	=      AcceleratorState()
							lowercase_   : Optional[Any]   	=      GradientState()
							lowercase_   : Union[str, Any]   	=      device_placement
							lowercase_   : List[str]   	=      False
							lowercase_   : Optional[Any]   	=      None

							# Handle device placement
							if device_placement:
													lowercase_   : str   	=      self.optimizer.state_dict()
													if self.accelerator_state.distributed_type == DistributedType.TPU:
																			xm.send_cpu_data_to_device(_lowercase	,   self.accelerator_state.device							)
													else:
																			lowercase_   : List[str]   	=      move_to_device(_lowercase	,   self.accelerator_state.device							)
													self.optimizer.load_state_dict(_lowercase							)
	@property
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.state
	@state.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Union[str, Any]:
							lowercase_   : Optional[Any]   	=      state
	@property
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.param_groups
	@param_groups.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Optional[Any]:
							lowercase_   : Dict   	=      param_groups
	@property
	def 							lowerCamelCase__		(				self							)    ->	int:
							return self.optimizer.defaults
	@defaults.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Any:
							lowercase_   : List[Any]   	=      defaults
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Tuple:
							self.optimizer.add_param_group(_lowercase							)
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Any:
							if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
													xm.send_cpu_data_to_device(_lowercase	,   self.accelerator_state.device							)
							self.optimizer.load_state_dict(_lowercase							)
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.state_dict()
	def 							lowerCamelCase__		(				self	,   _lowercase=None							)    ->	Optional[Any]:
							if self.gradient_state.sync_gradients:
													lowercase_   : Tuple   	=      'set_to_none' in inspect.signature(self.optimizer.zero_grad							).parameters
													if accept_arg:
																			if set_to_none is None:
																									lowercase_   : Optional[int]   	=      False
																			self.optimizer.zero_grad(set_to_none=_lowercase							)
													else:
																			if set_to_none is not None:
																									raise ValueError('`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.'							)
																			self.optimizer.zero_grad()
	def 							lowerCamelCase__		(				self	,   _lowercase=None							)    ->	Optional[Any]:
							if self.gradient_state.sync_gradients:
													if self.accelerator_state.distributed_type == DistributedType.TPU:
																			lowercase_   : Union[str, Any]   	=      {'closure': closure} if closure is not None else {}
																			xm.optimizer_step(self.optimizer	,   optimizer_args=_lowercase							)
													elif self.scaler is not None:
																			lowercase_   : Optional[Any]   	=      False
																			if self._last_scale is None:
																									# `get_scale` is an async operation requiring full synchronization
																									# on CPU and GPUs before finishing. As a result, we store away
																									# the prior one to reduce the call overhead
																									lowercase_   : Tuple   	=      self.scaler.get_scale()
																									lowercase_   : int   	=      True
																			self.scaler.step(self.optimizer	,   _lowercase							)
																			self.scaler.update()
																			lowercase_   : List[str]   	=      self.scaler.get_scale()
																			if not new_scale:
																									# If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
																									lowercase_   : Optional[int]   	=      scale_after < self._last_scale
																			lowercase_   : List[str]   	=      scale_after

													else:
																			self.optimizer.step(_lowercase							)
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Optional[int]:
							for param_group in self.optimizer.param_groups:
													lowercase_   : Dict   	=      [parameters_map.get(_lowercase	,   _lowercase							) for p in param_group['params']]
	@property
	def 							lowerCamelCase__		(				self							)    ->	List[Any]:
							warnings.warn(
							    'The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use '
							    '`optimizer.step_was_skipped` instead.'	,   _lowercase	,   )
							return self._is_overflow
	@property
	def 							lowerCamelCase__		(				self							)    ->	str:
							return self._is_overflow
	def __getstate__(				self							)    ->	str:
							return self.__dict__.copy()







	def __setstate__(				self	,   _lowercase							)    ->	Union[str, Any]:
							self.__dict__.update(_lowercase							)
