code: 
  
  
  
  
  """simple docstring"""
  
  
  
  from dataclasses import dataclass
  from typing import Optional, Tuple, Union
  
  import flax
  import jax.numpy as jnp
  from scipy import integrate
  
  from ..configuration_utils import ConfigMixin, register_to_config
  from .scheduling_utils_flax import (
      CommonSchedulerState,
      FlaxKarrasDiffusionSchedulers,
      FlaxSchedulerMixin,
      FlaxSchedulerOutput,
      broadcast_to_shape_from_left,
  )
  
  
  
  
  @flax.struct.dataclass
  class 			UpperCAmelCase_						:
      lowercase__		      =   42
  
      # setable values
      lowercase__		      =   42
      lowercase__		      =   42
      lowercase__		      =   42
      lowercase__		      =   None
  
      # running values
      lowercase__		      =   None
  
  
  
  
      @classmethod
      def 							__magic_name__							(					cls		: Optional[int]			,				snake_case_		: str			,				snake_case_		: Tuple			,				snake_case_		: List[Any]			,				snake_case_		: Union[str, Any]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       return cls(common=_lowerCAmelCase			,				init_noise_sigma=_lowerCAmelCase			,				timesteps=_lowerCAmelCase			,				sigmas=_lowerCAmelCase   )
  
  
  
  
  
  
  @dataclass
  class 			UpperCAmelCase_						(		__lowerCamelCase							):
      lowercase__		      =   42
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		__lowerCamelCase,     __lowerCamelCase							):
      lowercase__		      =   [e.name for e in FlaxKarrasDiffusionSchedulers]
  
      lowercase__		      =   42
  
  
  
  
      @property
      def 							__magic_name__							(					self		: Tuple   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       return True
  
  
  
  
      @register_to_config
      def __init__(					self		: Optional[Any]			,				snake_case_		: Optional[Any] = 1_000			,				snake_case_		: Tuple = 0.0001			,				snake_case_		: int = 0.02			,				snake_case_		: List[Any] = "linear"			,				snake_case_		: Optional[int] = None			,				snake_case_		: List[Any] = "epsilon"			,				snake_case_		: Optional[Any] = jnp.floataa			,				)   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       A__ =       dtype
  
  
  
  
      def 							__magic_name__							(					self		: Dict			,				snake_case_		: Optional[int] = None   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       if common is None:
        A__ =       CommonSchedulerState.create(self   )
  
       A__ =       jnp.arange(0			,				self.config.num_train_timesteps   ).round()[::-1]
       A__ =       ((1 - common.alphas_cumprod) / common.alphas_cumprod) ** 0.5
  
       # standard deviation of the initial noise distribution
       A__ =       sigmas.max()
  
       return LMSDiscreteSchedulerState.create(
           common=_lowerCAmelCase			,				init_noise_sigma=_lowerCAmelCase			,				timesteps=_lowerCAmelCase			,				sigmas=_lowerCAmelCase			,				)
  
  
  
  
      def 							__magic_name__							(					self		: Union[str, Any]			,				snake_case_		: List[str]			,				snake_case_		: Optional[int]			,				snake_case_		: Optional[Any]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       (A__		) =       jnp.where(state.timesteps == timestep			,				size=1   )
       A__ =       step_index[0]
  
       A__ =       state.sigmas[step_index]
       A__ =       sample / ((sigma**2 + 1) ** 0.5)
       return sample
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]			,				snake_case_		: Optional[Any]			,				snake_case_		: Union[str, Any]			,				snake_case_		: int			,				snake_case_		: Union[str, Any]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       def lms_derivative(snake_case_		: List[str]   ):
        A__ =       1.0
        for k in range(_lowerCAmelCase   ):
         if current_order == k:
          continue
         prod *= (tau - state.sigmas[t - k]) / (state.sigmas[t - current_order] - state.sigmas[t - k])
        return prod
  
       A__ =       integrate.quad(_lowerCAmelCase			,				state.sigmas[t]			,				state.sigmas[t + 1]			,				epsrel=1e-4   )[0]
  
       return integrated_coeff
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]			,				snake_case_		: Any			,				snake_case_		: Dict			,				snake_case_		: Optional[Any] = ()   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       jnp.linspace(self.config.num_train_timesteps - 1			,				0			,				_lowerCAmelCase			,				dtype=self.dtype   )
  
       A__ =       jnp.floor(_lowerCAmelCase   ).astype(jnp.intaa   )
       A__ =       jnp.ceil(_lowerCAmelCase   ).astype(jnp.intaa   )
  
       A__ =       jnp.mod(_lowerCAmelCase			,				1.0   )
  
       A__ =       ((1 - state.common.alphas_cumprod) / state.common.alphas_cumprod) ** 0.5
       A__ =       (1 - frac) * sigmas[low_idx] + frac * sigmas[high_idx]
       A__ =       jnp.concatenate([sigmas, jnp.array([0.0]			,				dtype=self.dtype   )]   )
  
       A__ =       timesteps.astype(jnp.intaa   )
  
       # initial running values
       A__ =       jnp.zeros((0,) + shape			,				dtype=self.dtype   )
  
       return state.replace(
           timesteps=_lowerCAmelCase			,				sigmas=_lowerCAmelCase			,				num_inference_steps=_lowerCAmelCase			,				derivatives=_lowerCAmelCase			,				)
  
  
  
  
      def 							__magic_name__							(					self		: Tuple			,				snake_case_		: Any			,				snake_case_		: Dict			,				snake_case_		: int			,				snake_case_		: Optional[Any]			,				snake_case_		: Dict = 4			,				snake_case_		: Dict = True			,				)   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       if state.num_inference_steps is None:
        raise ValueError(
            "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"   )
  
       A__ =       state.sigmas[timestep]
  
       # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
       if self.config.prediction_type == "epsilon":
        A__ =       sample - sigma * model_output
       elif self.config.prediction_type == "v_prediction":
        # * c_out + input * c_skip
        A__ =       model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
       else:
        raise ValueError(
            F"""prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"""   )
  
       # 2. Convert to an ODE derivative
       A__ =       (sample - pred_original_sample) / sigma
       A__ =       state.replace(derivatives=jnp.append(state.derivatives			,				_lowerCAmelCase   )   )
       if len(state.derivatives   ) > order:
        A__ =       state.replace(derivatives=jnp.delete(state.derivatives			,				0   )   )
  
       # 3. Compute linear multistep coefficients
       A__ =       min(timestep + 1			,				_lowerCAmelCase   )
       A__ =       [self.get_lms_coefficient(_lowerCAmelCase			,				_lowerCAmelCase			,				_lowerCAmelCase			,				_lowerCAmelCase   ) for curr_order in range(_lowerCAmelCase   )]
  
       # 4. Compute previous sample based on the derivatives path
       A__ =       sample + sum(
           coeff * derivative for coeff, derivative in zip(_lowerCAmelCase			,				reversed(state.derivatives   )   )   )
  
       if not return_dict:
        return (prev_sample, state)
  
       return FlaxLMSSchedulerOutput(prev_sample=_lowerCAmelCase			,				state=_lowerCAmelCase   )
  
  
  
  
      def 							__magic_name__							(					self		: int			,				snake_case_		: Tuple			,				snake_case_		: Any			,				snake_case_		: Any			,				snake_case_		: List[Any]			,				)   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       state.sigmas[timesteps].flatten()
       A__ =       broadcast_to_shape_from_left(_lowerCAmelCase			,				noise.shape   )
  
       A__ =       original_samples + noise * sigma
  
       return noisy_samples
  
  
  
  
      def __len__(					self		: Tuple   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       return self.config.num_train_timesteps
  
  
  
  
  
  
style_context: 
  
  
  
  
  """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 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	torch.Tensor:
   ...
  
  
  
  
  
  
  
  @overload
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	Tuple[torch.Tensor, torch.Tensor]:
   ...
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_		)		->	Dict:
   A__ =       aatype == rc.restype_order["G"]
   A__ =       rc.atom_order["CA"]
   A__ =       rc.atom_order["CB"]
   A__ =       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:
    A__ =       torch.where(
        lowercase_    ,				all_atom_masks[..., ca_idx]    ,				all_atom_masks[..., cb_idx]    ,				)
    return pseudo_beta, pseudo_beta_mask
   else:
    return pseudo_beta
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_		)		->	torch.Tensor:
   A__ =       batched_gather(
       lowercase_    ,				batch["residx_atom37_to_atom14"]    ,				dim=-2    ,				no_batch_dims=len(atomaa.shape[:-2]		)    ,				)
  
   A__ =       atomaa_data * batch["atom37_atom_exists"][..., None]
  
   return atomaa_data
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_		)		->	torch.Tensor:
   A__ =       template_feats["template_aatype"]
   A__ =       template_feats["template_torsion_angles_sin_cos"]
   A__ =       template_feats["template_alt_torsion_angles_sin_cos"]
   A__ =       template_feats["template_torsion_angles_mask"]
   A__ =       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 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_ = False    ,				lowercase_ = 1E-20    ,				lowercase_ = 1E8    ,				)		->	torch.Tensor:
   A__ =       batch["template_pseudo_beta_mask"]
   A__ =       template_mask[..., None] * template_mask[..., None, :]
  
   # Compute distogram (this seems to differ slightly from Alg. 5)
   A__ =       batch["template_pseudo_beta"]
   A__ =       torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2    ,				dim=-1    ,				keepdim=lowercase_		)
   A__ =       torch.linspace(lowercase_    ,				lowercase_    ,				lowercase_    ,				device=tpb.device		) ** 2
   A__ =       torch.cat([lower[1:], lower.new_tensor([inf]		)]    ,				dim=-1		)
   A__ =       ((dgram > lower) * (dgram < upper)).type(dgram.dtype		)
  
   A__ =       [dgram, template_mask_ad[..., None]]
  
   A__ =       nn.functional.one_hot(
       batch["template_aatype"]    ,				rc.restype_num + 2    ,				)
  
   A__ =       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		)		)
  
   A__,   A__,   A__ =       [rc.atom_order[a] for a in ["N", "CA", "C"]]
   A__ =       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_    ,				)
   A__ =       rigids.get_trans()[..., None, :, :]
   A__ =       rigids[..., None].invert_apply(lowercase_		)
  
   A__ =       torch.rsqrt(eps + torch.sum(rigid_vec**2    ,				dim=-1		)		)
  
   A__ =       batch["template_all_atom_mask"]
   A__ =       t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
   A__ =       template_mask[..., None] * template_mask[..., None, :]
  
   A__ =       inv_distance_scalar * template_mask_ad
   A__ =       rigid_vec * inv_distance_scalar[..., None]
  
   if not use_unit_vector:
    A__ =       unit_vector * 0.0
  
   to_concat.extend(torch.unbind(unit_vector[..., None, :]    ,				dim=-1		)		)
   to_concat.append(template_mask_ad[..., None]		)
  
   A__ =       torch.cat(lowercase_    ,				dim=-1		)
   A__ =       act * template_mask_ad[..., None]
  
   return act
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_		)		->	torch.Tensor:
   A__ =       nn.functional.one_hot(batch["extra_msa"]    ,				23		)
   A__ =       [
       msa_ahot,
       batch["extra_has_deletion"].unsqueeze(-1		),
       batch["extra_deletion_value"].unsqueeze(-1		),
   ]
   return torch.cat(lowercase_    ,				dim=-1		)
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				)		->	Rigid:
   # [*, N, 8, 4, 4]
   A__ =       rrgdf[aatype, ...]
  
   # [*, N, 8] transformations, i.e.
   #   One [*, N, 8, 3, 3] rotation matrix and
   #   One [*, N, 8, 3]    translation matrix
   A__ =       r.from_tensor_axa(lowercase_		)
  
   A__ =       alpha.new_zeros((*((1,) * len(alpha.shape[:-1]		)), 2)		)
   A__ =       1
  
   # [*, N, 8, 2]
   A__ =       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.
  
   A__ =       alpha.new_zeros(default_r.get_rots().get_rot_mats().shape		)
   A__ =       1
   A__ =       alpha[..., 1]
   A__ =       -alpha[..., 0]
   A__ =       alpha
  
   A__ =       default_r.compose(Rigid(Rotation(rot_mats=lowercase_		)    ,				lowercase_		)		)
  
   A__ =       all_frames[..., 5]
   A__ =       all_frames[..., 6]
   A__ =       all_frames[..., 7]
  
   A__ =       all_frames[..., 4]
   A__ =       chia_frame_to_bb.compose(lowercase_		)
   A__ =       chia_frame_to_bb.compose(lowercase_		)
   A__ =       chia_frame_to_bb.compose(lowercase_		)
  
   A__ =       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    ,				)
  
   A__ =       r[..., None].compose(lowercase_		)
  
   return all_frames_to_global
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				lowercase_    ,				)		->	torch.Tensor:
   # [*, N, 14]
   A__ =       group_idx[aatype, ...]
  
   # [*, N, 14, 8]
   A__ =       nn.functional.one_hot(
       lowercase_    ,				num_classes=default_frames.shape[-3]    ,				)
  
   # [*, N, 14, 8]
   A__ =       r[..., None, :] * group_mask_one_hot
  
   # [*, N, 14]
   A__ =       t_atoms_to_global.map_tensor_fn(lambda lowercase_		: torch.sum(lowercase_    ,				dim=-1		)		)
  
   # [*, N, 14, 1]
   A__ =       atom_mask[aatype, ...].unsqueeze(-1		)
  
   # [*, N, 14, 3]
   A__ =       lit_positions[aatype, ...]
   A__ =       t_atoms_to_global.apply(lowercase_		)
   A__ =       pred_positions * atom_mask
  
   return pred_positions
  
  
  
  
  
  