+
    œ°³j’² ã                   ó*  € ^ RI t ^ RIHt ^ RIHtHt ^ RIt^ RIHt ^ RI	Hu H
t ^ RIHt ^RIHt ^RIHt ^RIHt ^RIHtHt ^R	IHt ^R
IHt ^RIHtHt ^RIHt ^RI H!t!H"t" ^RI#H$t$ ^RI%H&t&H't' ^RI(H)t) ^RI*H+t+ ^RI,H-t-H.t.H/t/ ^RI0H1t1 ] ! R R4      4       t2] ! R R4      4       t3 ! R R]Ph                  4      t5 ! R R])4      t6 ! R R]Pn                  4      t8 ! R R]Pn                  4      t9 ! R  R!]Pn                  4      t: ! R" R#]+4      t;RnR$ lt< ! R% R&]Pn                  4      t= ! R' R(]4      t> ! R) R*]Pn                  4      t?RoR+ R, llt@ ! R- R.]Pn                  4      tAR/ R0 ltB ! R1 R2]Pn                  4      tC ! R3 R4]Pn                  4      tD ! R5 R6]4      tE ! R7 R8]Pn                  4      tF ! R9 R:]Pn                  4      tG ! R; R<]Pn                  4      tH ! R= R>]Pn                  4      tI ! R? R@]Pn                  4      tJ ! RA RB]Pn                  4      tK ! RC RD]Pn                  4      tL]! RE4       ! RF RG]Pn                  4      4       tM ! RH RI]4      tN ! RJ RK]Pn                  4      tO ! RL RM]Pn                  4      tP ! RN RO]Pn                  4      tQ]"! RPRQ7      ] ! RR RS]4      4       4       tR]"! RTRQ7      ] ! RU RV]4      4       4       tSRW RX ltTRY RZ ltU ! R[ R\]Pn                  4      tV ! R] R^]Pn                  4      tWR_ R` ltX ! Ra Rb]N4      tY ! Rc Rd]Pn                  4      tZ ! Re Rf]Pn                  4      t[ ! Rg Rh]Pn                  4      t\]" ! Ri Rj]4      4       t]]"! RkRQ7       ! Rl Rm]]]14      4       t^RmRj.t_R# )pé    N)ÚCallable)Ú	dataclassÚreplace©ÚTensor)Úinitialization)ÚACT2FN)Úuse_kernel_forward_from_hub)Úcreate_bidirectional_maskÚ$sliding_window_bidirectional_overlay)ÚGradientCheckpointingLayer)ÚModelOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚTransformersKwargsÚauto_docstring)Ú	AutoModel)Úeager_attention_forwardÚrotate_half)ÚNanoChatRMSNorm)ÚPhi3MLP)ÚEsmFold2AtomEncoderConfigÚEsmFold2ConfigÚEsmFold2DiffusionModuleConfig)ÚEsmFold2FoldingMixinc                   ó0   a € ] tR t^)t o RtV 3R ltRtV tR# )ÚEsmFold2AtomInputsaã  Featurized reference-conformer atom inputs, bundled so the atom stack takes one argument.

Taken as one argument by [`EsmFold2Model.forward`], holding the raw featurizer tensors.
``EsmFold2Model._prepare_features`` then one-hot encodes the categorical fields and zeroes the
padding, and ``forward`` swaps those in with `dataclasses.replace`, so every consumer downstream of
that point sees the encoded forms documented below. Returned on [`EsmFold2TrunkOutput`] so the
diffusion sampler and the confidence head reuse the trunk's featurization rather than redoing it.

A plain dataclass rather than a [`~utils.ModelOutput`]: every field here is required and is read
unconditionally downstream, and ``ModelOutput`` permits at most one required field (the rest must
default to ``None``), which would turn a missing tensor from a constructor error into a ``None``
surfacing deep in the atom encoder.

Args:
    ref_pos: `(batch_size, num_atoms, 3)` reference-conformer Cartesian coordinates.
    ref_charge: `(batch_size, num_atoms)` formal charge of each atom.
    atom_attention_mask: `(batch_size, num_atoms)` valid atoms (`1`) versus padding (`0`).
    ref_element: `(batch_size, num_atoms, max_atomic_number)` one-hot atomic number.
    ref_atom_name_chars: `(batch_size, num_atoms, max_chars, char_vocab_size)` one-hot atom name.
    ref_space_uid: `(batch_size, num_atoms)` per-atom group ID (the atom's token index).
    atom_to_token: `(batch_size, num_atoms)` index of the token each atom belongs to.
c                ón   <€ V ^8„  d   Qh/ S[ ;R&   S[ ;R&   S[ ;R&   S[ ;R&   S[ ;R&   S[ ;R&   S[ ;R&   # )é   Úref_posÚ
ref_chargeÚatom_attention_maskÚref_elementÚref_atom_name_charsÚref_space_uidÚatom_to_tokenr   )ÚformatÚ__classdict__s   "€Ún/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/models/esmfold2/modular_esmfold2.pyÚ__annotate__ÚEsmFold2AtomInputs.__annotate__)   s_   ø‡ ‚ ñ2 �Oñ3 ñ4 Ññ5 ñ6  Ññ7 ñ8 Ññ9 ñ:  Ññ; ñ< Ññ= ñ> Ñò? ó    © N©Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__annotate_func__Ú__static_attributes__Ú__classdictcell__©r)   s   @r*   r   r   )   s   ø‡ € ñ÷ ƒ r-   r   c                   ó0   a € ] tR t^Kt o RtV 3R ltRtV tR# )ÚEsmFold2DenoiserConditioningaO  Denoiser conditioning that depends on neither the noise level nor the noisy coordinates.

Built once per fold by ``EsmFold2DiffusionModule.prepare_conditioning``, with both attention masks
folded in, so nothing downstream takes a mask. See there for which fields are expanded across
diffusion samples and which are left broadcastable.
c                ó”   <€ V ^8„  d   Qh/ S[ ;R&   S[ ;R&   S[S[ S[ 3,          ;R&   S[ ;R&   S[ ;R&   S[ ;R&   S[S[ ,          ;R&   # )r    Úatom_embedsÚattention_maskÚposition_embeddingsÚ	atom_maskr'   Úprojected_single_inputsÚtoken_attention_bias)r   ÚtupleÚlist)r(   r)   s   "€r*   r+   Ú)EsmFold2DenoiserConditioning.__annotate__K   sm   ø‡ ‚ ñ Ññ ñ Ññ ñ ™v¡v˜~Õ.Ñ.ñ ñ Ññ ñ Ññ ñ" $Ñ#ñ# ñ$ ™v�,Ñ&ò% r-   r.   Nr/   r8   s   @r*   r:   r:   K   s   ø‡ € ñ÷ ƒ r-   r:   c                   ó6   a € ] tR t^`t o RtV 3R lR ltRtV tR# )ÚEsmFold2LayerNormz^LayerNorm that computes in fp32 (its weight/bias are fp32-pinned) and returns its input dtype.c                ó&   <€ V ^8„  d   QhRS[ RS[ /# ©r    Úhidden_statesÚreturnr   )r(   r)   s   "€r*   r+   ÚEsmFold2LayerNorm.__annotate__c   s   ø€ ÷ 
ñ 
¡Vð 
±ñ 
r-   c                óÔ   € \         P                  ! VP                  4       V P                  V P                  V P
                  V P                  4      P                  VP                  4      # ©N)	ÚFÚ
layer_normÚfloatÚnormalized_shapeÚweightÚbiasÚepsÚtoÚdtype©ÚselfrI   s   &&r*   ÚforwardÚEsmFold2LayerNorm.forwardc   sP   € Ü�|Š|˜M×/Ñ/Ó1°4×3HÑ3HÈ$Ï+É+ÐW[×W`ÑW`Ðbf×bjÑbjÓk×nÑnØ×Ñó
ð 	
r-   r.   N)r0   r1   r2   r3   r4   rY   r6   r7   r8   s   @r*   rF   rF   `   s   ø‡ € Ùh÷
ö 
r-   rF   c                   ó   € ] tR t^itRtRtR# )ÚEsmFold2RMSNormzEWeightless RMSNorm that computes in fp32 and returns its input dtype.r.   N)r0   r1   r2   r3   r4   r6   r.   r-   r*   r\   r\   i   s   † ÝOr-   r\   c                   óT   a a€ ] tR t^mt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2TransitionaU  LayerNorm + SwiGLU feed-forward residual, chunked along the token axis.

``chunk_size`` has no default and every call site states it, because passing ``None`` (unchunked)
is a deliberate numerical choice at two of them: chunking is exact, but its reassociation moves
the last bf16 bits, which the diffusion sampler amplifies over its steps.
c                ó>   <€ V ^8„  d   QhRS[ RS[ RS[ R,          RR/# )r    Úhidden_sizeÚintermediate_sizeÚ
chunk_sizeNrJ   ©Úint)r(   r)   s   "€r*   r+   ÚEsmFold2Transition.__annotate__u   s/   ø€ ÷ %ñ %¡Cð %¹Cð %ÉSÐSWÍZð %Ð\`ñ %r-   c                óp   <€ \         SV `  4        \        V4      V n        \	        W4      V n        W0n        R # rM   )ÚsuperÚ__init__rF   ÚnormÚEsmFold2SwiGLUÚmlprb   )rX   r`   ra   rb   Ú	__class__s   &&&&€r*   rh   ÚEsmFold2Transition.__init__u   s+   ø€ Ü‰ÑÔÜ% kÓ2ˆŒ	Ü! +ÓAˆŒà$Žr-   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# rH   r   )r(   r)   s   "€r*   r+   re   |   s   ø€ ÷ (ñ (¡Vð (±ñ (r-   c           	     ó>  € VP                   ^,          pV P                  ;'       g    Tp. p\        ^ W#4       FK  pVRWUV,           13,          pVP                  W`P	                  V P                  V4      4      ,           4       KM  	  \        P                  ! V^R7      # )é   ºNNN©Údim)Úshaperb   ÚrangeÚappendrk   ri   ÚtorchÚcat)rX   rI   Úseq_lenrb   ÚchunksÚstartÚchunks   &&     r*   rY   ÚEsmFold2Transition.forward|   s„   € Ø×%Ñ% aÕ(ˆØ—_‘_×/Ð/¨ˆ
Ø!ˆÜ˜1˜gÖ2ˆEØ! ! U°ZÕ-?Ð%?Ð"?Õ@ˆEØ�M‰M˜%§(¡(¨4¯9©9°UÓ+;Ó"<Õ<Ö=ñ 3ô �yŠy˜ QÔ'Ð'r-   )rb   rk   ri   ©
r0   r1   r2   r3   r4   rh   rY   r6   r7   Ú__classcell__©rl   r)   s   @@r*   r^   r^   m   s#   ù‡ € ñ÷%ó %÷(÷ (ð (r-   r^   c                   óX   a a€ ] tR t^†t oRtRV3R lV 3R llltV3R lR ltRtVtV ;t	# )ÚEsmFold2AdaptiveLayerNormz*Adaptive layer normalization (adaLN-Zero).c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r    r`   rT   rJ   N)rd   rP   )r(   r)   s   "€r*   r+   Ú&EsmFold2AdaptiveLayerNorm.__annotate__‰   s'   ø€ ÷ Tñ T¡Cð T©eð T¸tñ Tr-   c                ó>  <€ \         SV `  4        Wn        W n        \	        V P                  VR R7      V n        \        P                  ! V P                  V P                  RR7      V n        \        P                  ! V P                  V P                  R R7      V n	        R# )F)rT   rS   T©rS   N)
rg   rh   r`   rT   rF   Ú	cond_normÚnnÚLinearÚ	gate_projÚ
shift_proj)rX   r`   rT   rl   s   &&&€r*   rh   Ú"EsmFold2AdaptiveLayerNorm.__init__‰   so   ø€ Ü‰ÑÔØ&ÔØŒÜ*¨4×+;Ñ+;ÀÈ5ÔQˆŒÜŸš 4×#3Ñ#3°T×5EÑ5EÈDÔQˆŒÜŸ)š) D×$4Ñ$4°d×6FÑ6FÈUÔSˆŽr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    rI   Úsingle_statesrJ   r   )r(   r)   s   "€r*   r+   r„   ‘   s'   ø€ ÷ Mñ M¡Vð M¹Fð MÁvñ Mr-   c                óZ  € \         P                  ! VP                  4       V P                  3R R V P                  4      pV P                  V4      p\        P                  ! V P                  V4      4      pV P                  V4      pWS,          V,           P                  VP                  4      # rM   )rN   rO   rP   r`   rT   r‡   rw   ÚsigmoidrŠ   r‹   rU   rV   )rX   rI   rŽ   Únormed_hidden_statesÚnormed_conditioningÚgateÚshifts   &&&    r*   rY   Ú!EsmFold2AdaptiveLayerNorm.forward‘   s‹   € ô  !Ÿ|š|¨M×,?Ñ,?Ó,AÀD×DTÑDTÐCVÐX\Ð^bÐdh×dlÑdlÓmÐØ"Ÿn™n¨]Ó;Ðä�}Š}˜TŸ^™^Ð,?Ó@ÓAˆØ—‘Ð 3Ó4ˆØÕ+¨eÕ3×7Ñ7¸×8KÑ8KÓLÐLr-   )r‡   rT   rŠ   r`   r‹   )gñhãˆµøä>r~   r€   s   @@r*   r‚   r‚   †   s&   ù‡ € Ù4÷Tõ T÷M÷ Mð Mr-   r‚   c                   ó`   a a€ ] tR t^œt oRtV3R lV 3R lltV3R lR ltV3R ltRtVt	V ;t
# )ÚEsmFold2FourierEmbeddingzŸFourier embedding ``cos(2*pi*(t*frequencies + phases))``, with the random frequencies and
phases sampled once and stored in the checkpoint rather than learned.c                ó$   <€ V ^8„  d   QhRS[ RR/# )r    Úembedding_dimrJ   Nrc   )r(   r)   s   "€r*   r+   Ú%EsmFold2FourierEmbedding.__annotate__£   s   ø€ ÷ <ñ <¡cð <¨dñ <r-   c                óà   <€ \         SV `  4        \        P                  ! \        P
                  ! V4      4      V n        \        P                  ! \        P
                  ! V4      4      V n        R # rM   )rg   rh   rˆ   ÚBufferrw   ÚrandnÚfrequenciesÚphases)rX   r™   rl   s   &&€r*   rh   Ú!EsmFold2FourierEmbedding.__init__£   sA   ø€ Ü‰ÑÔÜŸ9š9¤U§[¢[°Ó%?Ó@ˆÔÜ—i’i¤§¢¨MÓ :Ó;ˆŽr-   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# )r    Únoise_levelrJ   r   )r(   r)   s   "€r*   r+   rš   ¨   s   ø€ ÷ uñ u¡6ð u©fñ ur-   c                óÔ   € \         P                  ! R \         P                  ,          VR,          V P                  R,          ,          V P                  R,          ,           ,          4      # )ç       @©rq   N)Nrq   )rw   ÚcosÚpirž   rŸ   )rX   r¢   s   &&r*   rY   Ú EsmFold2FourierEmbedding.forward¨   sF   € ä�yŠy˜œuŸx™x�¨;°wÕ+?À$×BRÑBRÐSZÕB[Õ+[Ð^b×^iÑ^iÐjqÕ^rÕ+rÕsÓtÐtr-   c                ó2   <€ V ^8„  d   Qh/ S[ ;R&   S[ ;R&   # )r    rž   rŸ   r   )r(   r)   s   "€r*   r+   rš   œ   s   ø‡ ‚ ñ Ññ	 ñ
 �Nò r-   )rž   rŸ   )r0   r1   r2   r3   r4   rh   rY   r5   r6   r7   r   r€   s   @@r*   r—   r—   œ   s(   ù‡ € ñM÷<ó <÷
uð u÷ … r-   r—   c                   ó6   a € ] tR t^­t o RtV 3R lR ltRtV tR# )rj   zÌSwiGLU feed-forward with a fused gate+up projection (``gate_up_proj``) and output ``down_proj``.

Takes explicit widths rather than a config: the six call sites draw them from four different
sub-configs.
c                ó*   <€ V ^8„  d   QhRS[ RS[ RR/# )r    r`   ra   rJ   Nrc   )r(   r)   s   "€r*   r+   ÚEsmFold2SwiGLU.__annotate__´   s"   ø€ ÷ ,ñ ,¡Cð ,¹Cð ,ÀDñ ,r-   c                óì   € \         P                  P                  V 4       \         P                  ! V^V,          RR7      V n        \         P                  ! W!RR7      V n        \        R,          V n        R# )r    Fr†   ÚsiluN)rˆ   ÚModulerh   r‰   Úgate_up_projÚ	down_projr	   Úactivation_fn)rX   r`   ra   s   &&&r*   rh   ÚEsmFold2SwiGLU.__init__´   sN   € Ü
�	‰	×Ñ˜4Ô ÜŸIšI k°1Ð7HÕ3HÈuÔUˆÔÜŸšÐ#4ÈÔNˆŒÜ# F�^ˆÖr-   )r²   r±   r°   N)r0   r1   r2   r3   r4   rh   r6   r7   r8   s   @r*   rj   rj   ­   s   ø‡ € ñ÷,ö ,r-   rj   c                óÈ   € VP                  V4      pVP                  V4      pW,          \        V 4      V,          ,           pW,          \        V4      V,          ,           pWV3# )a·  Applies Rotary Position Embedding to the query and key tensors.

No kernel decorator: the fused rotary kernel is CUDA-only, and the atom stack's rope must stay
bit-exact with the bf16 reference on CPU.

Args:
    q (`torch.Tensor`): The query tensor.
    k (`torch.Tensor`): The key tensor.
    cos (`torch.Tensor`): The cosine part of the rotary embedding.
    sin (`torch.Tensor`): The sine part of the rotary embedding.
    unsqueeze_dim (`int`, *optional*, defaults to 1):
        The dimension along which to unsqueeze `cos` and `sin` so they broadcast against `q`/`k`.
Returns:
    `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
)Ú	unsqueezer   )ÚqÚkr¦   ÚsinÚunsqueeze_dimÚq_embedÚk_embeds   &&&&&  r*   Úapply_rotary_pos_embr¼   »   sS   € ð  �-‰-˜Ó
&€CØ
�-‰-˜Ó
&€CØ�wœ; q›>¨CÕ/Õ0€GØ�wœ; q›>¨CÕ/Õ0€GØÐÐr-   c                   óT   a a€ ] tR t^Òt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2AtomAttentionzæSliding-window self-attention with 3D RoPE and a gated output.

The sliding window is expressed as an additive attention mask; dims come from ``atom_config``,
the atom sub-config `EsmFold2AtomEncoder` resolved for this call site.
c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# ©r    ÚconfigÚatom_configrJ   N©r   r   )r(   r)   s   "€r*   r+   Ú"EsmFold2AtomAttention.__annotate__Ù   s$   ø€ ÷ (ñ (™~ð (Ñ<Uð (ÐZ^ñ (r-   c                óÎ  <€ \         SV `  4        Wn        VP                  V n        V P                  R,          V n        ^V n        RV n        \        P                  ! VP                  VP                  RR7      V n
        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        \        4       V n        \        4       V n        R# )ç      à?Fr†   Nç      à¿)rg   rh   rÁ   Úhead_dimÚscalingÚnum_key_value_groupsÚ	is_causalrˆ   r‰   r`   Úq_projÚk_projÚv_projÚo_projrŠ   r\   Úq_normÚk_norm©rX   rÁ   rÂ   rl   s   &&&€r*   rh   ÚEsmFold2AtomAttention.__init__Ù   sø   ø€ Ü‰ÑÔØŒØ#×,Ñ,ˆŒØ—}‘} dÕ*ˆŒà$%ˆÔ!ØˆŒä—i’i × 7Ñ 7¸×9PÑ9PÐW\Ô]ˆŒÜ—i’i × 7Ñ 7¸×9PÑ9PÐW\Ô]ˆŒÜ—i’i × 7Ñ 7¸×9PÑ9PÐW\Ô]ˆŒÜ—i’i × 7Ñ 7¸×9PÑ9PÐW\Ô]ˆŒÜŸš ;×#:Ñ#:¸K×<SÑ<SÐZ_Ô`ˆŒÜ%Ó'ˆŒÜ%Ó'ˆŽr-   c                ó‚   <€ V ^8„  d   QhRS[ RS[ RS[S[ S[ 3,          RS[S[,          RS[S[ S[ R,          3,          /# )r    rI   r=   r>   ÚkwargsrJ   N)r   rB   r   r   )r(   r)   s   "€r*   r+   rÄ   ê   sZ   ø€ ÷ &6ñ &6áð&6ñ ð&6ñ #¡6©6 >Õ2ð	&6ñ
 Ñ+Õ,ð&6ñ 
‰v‘v •}Ð$Õ	%ñ&6r-   c                ó:  € VP                   R R p. VORNV P                  N5pV P                  V4      P                  V4      P	                  ^^4      pV P                  V4      P                  V4      P	                  ^^4      pV P                  V4      P                  V4      P	                  ^^4      p	V P                  V4      pV P                  V4      pVw  r«\        WxW«4      w  rx\        P                  ! V P                  P                  \        4      pV! V VVV	V3RRRV P                  /VB w  rÞ\         P"                  ! V4      pVP$                  ! . VORN5!  pV\         P&                  ! V P)                  V4      4      ,          pV P+                  V4      V3# ©NÚdropoutç        rÉ   éÿÿÿÿ)rt   rÈ   rÌ   ÚviewÚ	transposerÍ   rÎ   rÐ   rÑ   r¼   r   Úget_interfacerÁ   Ú_attn_implementationr   rÉ   rw   Ú
nan_to_numÚreshaper�   rŠ   rÏ   )rX   rI   r=   r>   rÕ   Úinput_shapeÚhidden_shapeÚquery_statesÚ
key_statesÚvalue_statesr¦   r¸   Úattention_interfaceÚattn_outputÚattn_weightss   &&&&,          r*   rY   ÚEsmFold2AtomAttention.forwardê   s‘  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆØ—[‘[ Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆ
Ø—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆà—{‘{ <Ó0ˆØ—[‘[ Ó,ˆ
à&‰ˆÜ#7¸ÐRUÓ#[Ñ ˆä(?×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØñ	%
ð ð	%
ð —L‘Lð	%
ð ñ	%
Ñ!ˆô ×&Ò& {Ó3ˆà!×)Ò)Ð;¨;Ð;¸Ó;ˆØ!¤E§M¢M°$·.±.ÀÓ2OÓ$PÕPˆØ�{‰{˜;Ó'¨Ð5Ð5r-   )rÁ   rŠ   rÈ   rË   rÑ   rÍ   rÊ   rÏ   rÐ   rÌ   rÉ   rÎ   r~   r€   s   @@r*   r¾   r¾   Ò   s#   ù‡ € ñ÷(ó (÷"&6÷ &6ð &6r-   r¾   c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2AtomLayeri  z`adaLN-Zero + SWA attention + SwiGLU FFN, modulated by ``adaln_linear(silu(atom_conditioning))``.c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# rÀ   rÃ   )r(   r)   s   "€r*   r+   ÚEsmFold2AtomLayer.__annotate__  s$   ø€ ÷ :ñ :™~ð :Ñ<Uð :ÐZ^ñ :r-   c                ó<  <€ \         SV `  4        \        P                  ! VP                  ^VP                  ,          RR7      V n        \        W4      V n        \        VP                  VP                  4      V n
        \        4       V n        \        4       V n        R# ©é   Fr†   N)rg   rh   rˆ   r‰   r`   Úadaln_linearr¾   Ú	self_attnrj   ra   rk   r\   Úinput_layernormÚpost_attention_layernormrÒ   s   &&&€r*   rh   ÚEsmFold2AtomLayer.__init__  sq   ø€ Ü‰ÑÔäŸIšI k×&=Ñ&=¸qÀ;×CZÑCZÕ?ZÐafÔgˆÔä.¨vÓCˆŒÜ! +×"9Ñ"9¸;×;XÑ;XÓYˆŒÜ.Ó0ˆÔÜ(7Ó(9ˆÖ%r-   c          
      óN   <€ V ^8„  d   QhRS[ RS[ RS[ RS[S[ S[ 3,          RS[ /# )r    rI   Úatom_conditioningr=   r>   rJ   ©r   rB   )r(   r)   s   "€r*   r+   rí      sF   ø€ ÷ ñ áðñ "ðñ ð	ñ
 #¡6©6 >Õ2ðñ 
ñr-   c                óè  € V P                  \        P                  ! V4      4      pVP                  4       ^8X  d   VP	                  ^4      pVP                  ^RR7      w  rgr‰r«V P                  V4      ^V,           ,          V,           pV P                  WÃV4      w  rÞWV,          ,           pV P                  V4      ^V
,           ,          V	,           pV P                  V4      pWV,          ,           pV# ©r    rr   rÚ   )
rñ   rN   r®   rs   rµ   r|   ró   rò   rô   rk   )rX   rI   r÷   r=   r>   Ú
modulationÚ
attn_shiftÚ
attn_scaleÚ	attn_gateÚ	mlp_shiftÚ	mlp_scaleÚmlp_gateÚattn_hidden_statesrç   Ú_Úmlp_hidden_statesÚ
mlp_outputs   &&&&&            r*   rY   ÚEsmFold2AtomLayer.forward   sß   € ð ×&Ñ&¤q§v¢vÐ.?Ó'@ÓAˆ
Ø�>‰>Ó˜qÔ Ø#×-Ñ-¨aÓ0ˆJØLV×L\ÑL\Ð]^ÐdfÐL\ÓLgÑIˆ
 	°ià!×1Ñ1°-Ó@ÀAÈ
ÅNÕSÐV`Õ`ÐØŸ™Ð(:ÐL_Ó`‰ˆØ%°KÕ(?Õ?ˆà ×9Ñ9¸-ÓHÈAÐPYÍMÕZÐ]fÕfÐØ—X‘XÐ/Ó0ˆ
Ø%°:Õ(=Õ=ˆØÐr-   )rñ   ró   rk   rô   rò   r~   r€   s   @@r*   rë   rë     s!   ù‡ € Ùj÷:ó :÷÷ ð r-   rë   c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2RotaryEmbeddingi6  zôRotary embedding over physical position (``ref_pos`` = x/y/z) plus a per-atom space UID,
rather than token indices, with separate spatial and UID base frequencies.

Returns cos/sin at the full head dim, so callers apply plain rotate-half RoPE.
c                ó$   <€ V ^8„  d   QhRS[ RR/# )r    rÂ   rJ   N)r   )r(   r)   s   "€r*   r+   Ú$EsmFold2RotaryEmbedding.__annotate__=  s   ø€ ÷ 
ñ 
Ñ$=ð 
À$ñ 
r-   c                ó.  <€ \         SV `  4        VP                  V n        VP                  V n        VP                  V n        VP                  V n        VP                  ^,          ^V P                  ,          ,
          V P
                  ,
          V n	        R# ©r    N)
rg   rh   Únum_spatial_rope_pairs_per_axisÚnum_spatial_pairs_per_axisÚnum_uid_rope_pairsÚnum_uid_pairsÚspatial_rope_base_frequencyÚuid_rope_base_frequencyrÈ   Únum_inactive_channels)rX   rÂ   rl   s   &&€r*   rh   Ú EsmFold2RotaryEmbedding.__init__=  sw   ø€ Ü‰ÑÔØ*5×*UÑ*UˆÔ'Ø(×;Ñ;ˆÔØ+6×+RÑ+RˆÔ(Ø'2×'JÑ'JˆÔ$à× Ñ  AÕ%¨¨D×,KÑ,KÕ(KÕKÈd×N`ÑN`Õ`ð 	Ö"r-   c          
      ó\   <€ V ^8„  d   QhRS[ RS[ RS[P                  RS[S[ S[ 3,          /# )r    r!   r&   rV   rJ   )r   rw   rV   rB   )r(   r)   s   "€r*   r+   r
  G  s:   ø€ ÷ 8ñ 8™vð 8±fð 8ÁUÇ[Á[ð 8ÑUZÑ[aÑciÐ[iÕUjñ 8r-   c           	     óô  € VP                   pR V P                  \        P                  ! ^ V P                  \        P
                  VR7      V P                  ,          ,          ,          pR V P                  \        P                  ! ^ V P                  \        P
                  VR7      V P                  ,          ,          ,          p\        P                  ! VP                  ^4      WeP                  V P                  4      .4      p\        P                  ! VP                  4       P                  V P                  RR7      VP                  4       P                  R4      P                  ! . VP                   OV P                  V P                  ,           N5!  .RR7      pW‡,          p	\        P                  ! W™.RR7      p
V
P#                  4       P%                  V4      V
P'                  4       P%                  V4      3# )ç      ð?)rV   Údevicerr   rÚ   )r  r  rw   Úaranger  Úfloat32r  r  rx   ÚrepeatÚ	new_zerosr  rP   Úrepeat_interleaverµ   Úexpandrt   r¦   rU   r¸   )rX   r!   r&   rV   r  Úspatial_inv_freqÚuid_inv_freqÚinv_freqÚ	positionsÚfreqsÚembs   &&&&       r*   rY   ÚEsmFold2RotaryEmbedding.forwardG  s—  € Ø—‘ˆØØ×,Ñ,ä—’˜Q × ?Ñ ?ÄuÇ}Á}Ð]cÔdØ×1Ñ1õ2õõ
Ðð Ø×(Ñ(Ü—’˜Q × 2Ñ 2¼%¿-¹-ÐPVÔWÐZ^×ZlÑZlÕlõnõ
ˆô —9’9Ø×$Ñ$ QÓ'¨×7QÑ7QÐRV×RlÑRlÓ7mÐnó
ˆô —I’Ià—‘“×1Ñ1°$×2QÑ2QÐWYÐ1ÓZØ×#Ñ#Ó%ß‘˜2“ß‘ðð _à&×,Ñ,ð_à.2×.@Ñ.@À4×C]ÑC]Õ.]ó_ðð ô
ˆ	ð Õ$ˆô �iŠi˜˜¨BÔ/ˆØ�w‰w‹y�|‰|˜EÓ" C§G¡G£I§L¡L°Ó$7Ð7Ð7r-   )r  r  r  r  r  r~   r€   s   @@r*   r  r  6  s#   ù‡ € ñ÷
ó 
÷8÷ 8ð 8r-   r  c          
      ób   € V ^8„  d   QhR\         R\         R\        R\         R,          R\         /# )r    Úatom_featuresÚatom_to_token_idxÚ
num_tokensr?   NrJ   ©r   rd   )r(   s   "r*   r+   r+   g  s>   € ÷ *ñ *Üð*äð*ô ð*ô ˜�}ð	*ô
 ñ*r-   c                ó  € V P                   w  rEpTpVe   VP                  V( V4      pV P                  WB\        VRJ4      ,           V4      pVP	                  ^VP                  R4      P                  V 4      V RRR7       VRRV13,          # )aL  Aggregate per-atom features to per-token features (mean).

Args:
    atom_features: `(batch_size, num_atoms, hidden_size)`
    atom_to_token_idx: `(batch_size, num_atoms)` int64
    num_tokens: the token-axis length to scatter into
    atom_mask: `(batch_size, num_atoms)` bool

Returns:
    `(batch_size, num_tokens, hidden_size)`
NÚmeanF)rs   ÚindexÚsrcÚreduceÚinclude_selfrq   rÚ   )rt   Úmasked_fillr  rd   Úscatter_reduce_rµ   Ú	expand_as)	r'  r(  r)  r?   Ú
batch_sizer  r`   ÚidxÚtoken_featuress	   &&&&     r*   Úscatter_atom_to_tokenr7  g  sŸ   € ð" "/×!4Ñ!4Ñ€J�;Ø
€CØÒØ�o‰o˜y˜j¨*Ó5ˆØ"×,Ñ,¨ZÄcÈ)Ð[_ÐJ_ÓF`Õ9`ÐbmÓn€NØ×"Ñ"ØØ�m‰m˜BÓ×)Ñ)¨-Ó8ØØØð #ô ð ˜!˜[˜j˜[˜.Õ)Ð)r-   c                   óx   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltV3R lR ltV3R	 lR
 ltRt	Vt
V ;t# )ÚEsmFold2AtomEncoderi‡  zçSWA atom encoder: embeds per-atom features, runs the atom layers and pools atoms into tokens.

Dims come from ``atom_config``, the atom sub-config resolved for this call site (the trunk's input
featurizer or the diffusion module).
c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# rÀ   rÃ   )r(   r)   s   "€r*   r+   Ú EsmFold2AtomEncoder.__annotate__Ž  s)   ø€ ÷ kñ k™~ð kÑ<Uð kÐZ^ñ kr-   c           	     ó(  <€ \         SV `  4        VP                  VP                  ,          V n        \
        P                  ! VP                  VP                  R R7      V n	        \        VP                  4      V n        Wn        \        V4      V n        \
        P                  ! \!        VP"                  4       Uu. uF  p\%        W4      NK  	  up4      V n        \
        P                  ! VP                  VP(                  R R7      V n        R# u upi ©Fr†   N)rg   rh   Úchar_vocab_sizeÚ	max_charsÚchar_feature_dimrˆ   r‰   Úatom_feature_dimr`   Úatom_linearrF   Ú	atom_normrÁ   r  Ú
rotary_embÚ
ModuleListru   Únum_hidden_layersrë   ÚlayersÚ
output_dimÚatom_to_token_linear)rX   rÁ   rÂ   r  rl   s   &&& €r*   rh   ÚEsmFold2AtomEncoder.__init__Ž  sË   ø€ Ü‰ÑÔà &× 6Ñ 6¸×9IÑ9IÕ IˆÔÜŸ9š9 V×%<Ñ%<¸k×>UÑ>UÐ\aÔbˆÔÜ*¨;×+BÑ+BÓCˆŒàŒÜ1°+Ó>ˆŒÜ—m’mÜ=BÀ;×C`ÑC`Ô=aÓbÑ=a¸Ô˜vÖ3Ñ=aÑbó
ˆŒô %'§I¢I¨k×.EÑ.EÀ{×G]ÑG]ÐdiÔ$jˆÖ!ùò cs   Â;Dc                óR   <€ V ^8„  d   QhRS[ RS[S[S[S[S[3,          3,          /# )r    Úatom_inputsrJ   )r   rB   r   )r(   r)   s   "€r*   r+   r;  �  s6   ø€ ÷ iñ iÑ'9ð i¹eÁFÉEÑRXÑZ`ÐR`ÕLaÐDaÕ>bñ ir-   c                ó(  € VP                   pVP                  R,          w  r4\        P                  ! VVP                  P                  R4      VP                  P                  R4      VP                  VP                  P                  W4V P                  4      .RR7      pV P                  V P                  VP                  V P                  P                  P                  4      4      4      pW`P!                  W!P"                  VP                  R7      3# )zŒPer-atom base embedding and 3D-RoPE position embeddings.

Noise-independent, so callers compute it once per fold outside the sampling loop.
:Nr    Nrr   ©rV   rÚ   )r!   rt   rw   rx   r"   rµ   r#   r$   r%   rà   r@  rC  rB  rU   rR   rV   rD  r&   )rX   rL  r!   r4  Ú	num_atomsr'  r<   s   &&     r*   Úembed_atomsÚEsmFold2AtomEncoder.embed_atoms�  sã   € ð
 ×%Ñ%ˆØ '§¡¨bÕ 1Ñˆ
ÜŸ	š	àØ×&Ñ&×0Ñ0°Ó4Ø×/Ñ/×9Ñ9¸"Ó=Ø×'Ñ'Ø×/Ñ/×7Ñ7¸
Èt×OdÑOdÓeðð ô	
ˆð —n‘n T×%5Ñ%5°m×6FÑ6FÀt×GWÑGW×G^ÑG^×GdÑGdÓ6eÓ%fÓgˆØŸO™O¨G×5NÑ5NÐVa×VgÑVg˜OÓhÐhÐhr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    r?   r<   rJ   r   )r(   r)   s   "€r*   r+   r;  ²  s"   ø€ ÷ 
ñ 
©fð 
Á6ð 
Éfñ 
r-   c           	     ó|   € \        V P                  VV\        V P                  P                  ^,          4      R7      # )aÎ  Symmetric sliding-window attention mask over atom index.

Noise-independent, so callers build it once per fold outside the sampling loop.

``atom_embeds`` (the ``embed_atoms`` output) only supplies the mask metadata
(dtype/device/shape). ``atom_mask`` is the boolean valid-atom mask, passed as the standard 2D
``attention_mask``. Note ``config.sliding_window`` is the *total* window width here, while the
overlay takes the (inclusive) radius, hence the halving.
)rÁ   Úinputs_embedsr=   Úand_mask_function)r   rÁ   r   Úsliding_window)rX   r?   r<   s   &&&r*   Úbuild_attention_maskÚ(EsmFold2AtomEncoder.build_attention_mask²  s6   € ô )Ø—;‘;Ø%Ø$ÜBÀ4Ç;Á;×C]ÑC]ÐabÕCbÓcô	
ð 	
r-   c                óv   <€ V ^8„  d   QhRS[ RS[ RS[ RS[S[ S[ 3,          RS[ RS[ RS[RS[S[ S[ 3,          /# )	r    rI   r÷   r=   r>   r?   r'   r)  rJ   )r   rB   rd   )r(   r)   s   "€r*   r+   r;  Ã  sm   ø€ ÷ 2ñ 2áð2ñ "ð2ñ ð	2ñ
 #¡6©6 >Õ2ð2ñ ð2ñ ð2ñ ð2ñ 
‰v‘vˆ~Õ	ñ2r-   c                ó¨   € V P                    F  pV! WW44      pK  	  \        P                  ! V P                  V4      4      p	\	        V	VVVR7      p
W¡3# )a]  Returns ``(token_hidden_states, hidden_states)``. Every argument is already at the caller's
batch size (for the diffusion stack, ``batch_size * num_diffusion_samples``).

``atom_conditioning`` is the ``embed_atoms`` output; the trunk passes it as ``hidden_states``
too, while the diffusion module passes coord-augmented embeds as ``hidden_states``.
)r?   )rG  rN   ÚrelurI  r7  )rX   rI   r÷   r=   r>   r?   r'   r)  Úlayerr6  Útoken_hidden_statess   &&&&&&&&   r*   rY   ÚEsmFold2AtomEncoder.forwardÃ  s[   € ð  —[”[ˆEÙ! -ÀNÓhŠMñ !ô Ÿš × 9Ñ 9¸-Ó HÓIˆÜ3ØØØØô	
Ðð #Ð1Ð1r-   )rB  rC  rI  r@  rÁ   rG  rD  )r0   r1   r2   r3   r4   rh   rP  rW  rY   r6   r7   r   r€   s   @@r*   r9  r9  ‡  s;   ù‡ € ñ÷kó k÷ið i÷*
ð 
÷"2÷ 2ð 2r-   r9  c                ó<   € V ^8„  d   QhR\         R\         R\         /# )r    Úsourcer-  rJ   r   )r(   s   "r*   r+   r+   á  s!   € ÷ (ñ (œvð (¬fð (¼ñ (r-   c                ó”   € VP                  R4      P                  RRV P                  R4      4      p\        P                  ! V ^V4      # )z_Gather ``source`` (``[B, N, d]``) along dim 1 with a ``[B, M]`` index, returning ``[B, M, d]``.rÚ   )rµ   r  Úsizerw   Úgather)r`  r-  r5  s   && r*   Ú_gather_along_dim1rd  á  s:   € à
�/‰/˜"Ó
×
$Ñ
$ R¨¨V¯[©[¸«_Ó
=€CÜ�<Š<˜  3Ó'Ð'r-   c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2AtomDecoderiç  z€SWA atom decoder. Only used inside the diffusion module, so its atom dims are always the
structure-prediction (diffusion) ones.
c                ó$   <€ V ^8„  d   QhRS[ RR/# ©r    rÁ   rJ   N©r   )r(   r)   s   "€r*   r+   Ú EsmFold2AtomDecoder.__annotate__ì  s   ø€ ÷ Oñ O™~ð O°$ñ Or-   c           	     óè  <€ \         SV `  4        VP                  P                  pVP                  p\
        P                  ! VP                  VP                  R R7      V n        \
        P                  ! \        VP                  4       Uu. uF  p\        W4      NK  	  up4      V n        \        VP                  4      V n        \
        P                  ! VP                  ^R R7      V n        R# u upi r=  )rg   rh   Ústructure_headÚdiffusion_moduleÚatom_encoderrˆ   r‰   r`   Útoken_to_atom_linearrE  ru   rF  rë   rG  rF   ri   Úoutput_linear)rX   rÁ   Údiffusion_configrÂ   r  rl   s   &&   €r*   rh   ÚEsmFold2AtomDecoder.__init__ì  s¸   ø€ Ü‰ÑÔØ!×0Ñ0×AÑAÐØ&×3Ñ3ˆÜ$&§I¢IÐ.>×.JÑ.JÈK×LcÑLcÐjoÔ$pˆÔ!ä—m’mÜ=BÀ;×C`ÑC`Ô=aÓbÑ=a¸Ô˜vÖ3Ñ=aÑbó
ˆŒô & k×&=Ñ&=Ó>ˆŒ	ÜŸYšY {×'>Ñ'>ÀÈÔNˆÖùò	 cs   ÂC/c                óZ   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[S[ S[ 3,          RS[ RS[ /# )r    r]  rI   r÷   r=   r>   r'   rJ   rø   )r(   r)   s   "€r*   r+   rj  ù  sZ   ø€ ÷ ñ á#ðñ ðñ "ð	ñ
 ðñ #¡6©6 >Õ2ðñ ðñ 
ñr-   c                óÆ   € V P                  V4      p\        Wv4      pW',           pV P                   F  pV! W#WE4      pK  	  V P                  V P	                  V4      4      p	V	# )zReturns coord_update.)ro  rd  rG  rp  ri   )
rX   r]  rI   r÷   r=   r>   r'   Útoken_to_atom_featuresr\  Úatom_coordss
   &&&&&&&   r*   rY   ÚEsmFold2AtomDecoder.forwardù  se   € ð "&×!:Ñ!:Ð;NÓ!OÐÜ!3Ð4JÓ!ZÐØ%Õ>ˆà—[”[ˆEÙ! -ÀNÓhŠMñ !ð ×(Ñ(¨¯©°=Ó)AÓBˆØÐr-   )rG  ri   rp  ro  r~   r€   s   @@r*   rf  rf  ç  s%   ù‡ € ñ÷Oó O÷÷ ð r-   rf  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2DiffusionAttentioni  z÷Gated multi-head self-attention over the token stream, taking a ready-made additive pair bias.

Dims come from ``diffusion_config``, the diffusion sub-config resolved for this call site; the bias
is built by the owning ``EsmFold2DiffusionLayer``.
c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r    rÁ   rq  rJ   N)r   r   )r(   r)   s   "€r*   r+   Ú'EsmFold2DiffusionAttention.__annotate__  s)   ø€ ÷ hñ h™~ð hÑA^ð hÐcgñ hr-   c                ó’  <€ \         SV `  4        Wn        VP                  V n        V P                  R,          V n        ^V n        RV n        \        P                  ! VP                  VP                  RR7      V n
        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        \        P                  ! VP                  VP                  RR7      V n        R# )rÆ   FTr†   NrÇ   )rg   rh   rÁ   rÈ   rÉ   rÊ   rË   rˆ   r‰   r`   rÌ   rÍ   rÎ   rŠ   rÏ   ©rX   rÁ   rq  rl   s   &&&€r*   rh   Ú#EsmFold2DiffusionAttention.__init__  sî   ø€ Ü‰ÑÔØŒØ(×1Ñ1ˆŒØ—}‘} dÕ*ˆŒà$%ˆÔ!ØˆŒä—i’iÐ 0× <Ñ <Ð>N×>ZÑ>ZÐaeÔfˆŒÜ—i’iÐ 0× <Ñ <Ð>N×>ZÑ>ZÐafÔgˆŒÜ—i’iÐ 0× <Ñ <Ð>N×>ZÑ>ZÐafÔgˆŒÜŸšÐ#3×#?Ñ#?ÐAQ×A]ÑA]ÐdiÔjˆŒÜ—i’iÐ 0× <Ñ <Ð>N×>ZÑ>ZÐafÔgˆŽr-   c                óf   <€ V ^8„  d   QhRS[ RS[ RS[S[,          RS[S[ S[ R,          3,          /# )r    rI   Úattention_biasrÕ   rJ   N)r   r   r   rB   )r(   r)   s   "€r*   r+   r{  $  sG   ø€ ÷ 6ñ 6áð6ñ ð6ñ Ñ+Õ,ð	6ñ
 
‰v‘v •}Ð$Õ	%ñ6r-   c                ó¦  € VP                   R R p. VORNV P                  N5pV P                  V4      P                  V4      P	                  ^^4      pV P                  V4      P                  V4      P	                  ^^4      pV P                  V4      P                  V4      P	                  ^^4      p\        P                  ! V P                  P                  \        4      p	V	! V VVVV3RRRV P                  /VB w  r«V
P                  ! . VORN5!  p
V
\        P                  ! V P!                  V4      4      ,          p
V P#                  V
4      V3# r×   )rt   rÈ   rÌ   rÛ   rÜ   rÍ   rÎ   r   rÝ   rÁ   rÞ   r   rÉ   rà   rw   r�   rŠ   rÏ   )rX   rI   r€  rÕ   rá   râ   rã   rä   rå   ræ   rç   rè   s   &&&,        r*   rY   Ú"EsmFold2DiffusionAttention.forward$  sQ  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆØ—[‘[ Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆ
Ø—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆô )@×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØñ	%
ð ð	%
ð —L‘Lð	%
ð ñ	%
Ñ!ˆð "×)Ò)Ð;¨;Ð;¸Ó;ˆØ!¤E§M¢M°$·.±.ÀÓ2OÓ$PÕPˆØ�{‰{˜;Ó'¨Ð5Ð5r-   )
rÁ   rŠ   rÈ   rË   rÍ   rÊ   rÏ   rÌ   rÉ   rÎ   r~   r€   s   @@r*   ry  ry    s%   ù‡ € ñ÷hó h÷6÷ 6ð 6r-   ry  c                   ój   a a€ ] tR tRt oRtV3R lV 3R lltR
V3R lR lltV3R lR ltR	tVt	V ;t
# )ÚEsmFold2DiffusionLayeriE  a0  adaLN-Zero conditioned pair-bias attention and SwiGLU FFN, each gated on the single stream.

Everything that conditions the two halves lives here -- the adaLN pre-norms, the two residual
gates and the per-head pair bias -- so ``EsmFold2DiffusionAttention`` sees only normed states and a
ready-made bias.
c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú#EsmFold2DiffusionLayer.__annotate__M  s   ø€ ÷ wñ w™~ð w°$ñ wr-   c                ó‚  <€ \         SV `  4        VP                  P                  p\	        VP
                  4      V n        \        W4      V n        \        P                  ! VP
                  VP
                  R R7      V n        \	        VP
                  4      V n        \        VP
                  VP                  4      V n        \        P                  ! VP
                  VP
                  R R7      V n        \#        VP$                  4      V n        \        P                  ! VP$                  VP(                  RR7      V n        R# )Tr†   FN)rg   rh   rl  rm  r‚   r`   ró   ry  rò   rˆ   r‰   rþ   rô   rj   ra   rk   r  rF   Úpairwise_hidden_sizeÚ	pair_normÚnum_attention_headsÚpair_bias_projr}  s   && €r*   rh   ÚEsmFold2DiffusionLayer.__init__M  së   ø€ Ü‰ÑÔØ!×0Ñ0×AÑAÐÜ8Ð9I×9UÑ9UÓVˆÔÜ3°FÓMˆŒÜŸšÐ#3×#?Ñ#?ÐAQ×A]ÑA]ÐdhÔiˆŒÜ(AÐBR×B^ÑB^Ó(_ˆÔ%Ü!Ð"2×">Ñ">Ð@P×@bÑ@bÓcˆŒÜŸ	š	Ð"2×">Ñ">Ð@P×@\Ñ@\ÐcgÔhˆŒä*¨6×+FÑ+FÓGˆŒÜ Ÿiši¨×(CÑ(CÐEU×EiÑEiÐpuÔvˆÖr-   c                ó:   <€ V ^8„  d   QhRS[ RS[ R,          RS[ /# ©r    Úpair_statesr=   NrJ   r   )r(   r)   s   "€r*   r+   r†  Z  s'   ø€ ÷ ñ ©Vð ÁVÈdÅ]ð Ñ^dñ r-   c                óP  € V P                  V P                  V4      4      pVP                  ^ ^^^4      pVen   V\        P                  ! VR,          VP                  R4      VP                  R\        P                  ! VP                  4      P                  4      4      ,           pV# )a'  This layer's additive attention bias, ``[batch_size, num_attention_heads, num_queries, num_keys]``:
the per-head projection of the normed pair representation with token padding folded in.

Step-invariant, so it is built once per fold outside the sampling loop and ``forward`` never
sees a mask.
©rq   NNrq   r.   )
r‹  r‰  Úpermuterw   Úwherer  Únew_fullÚfinforV   Úmin)rX   r�  r=   Ú	pair_biasr€  s   &&&  r*   Úcompute_pair_biasÚ(EsmFold2DiffusionLayer.compute_pair_biasZ  s’   € ð ×'Ñ'¨¯©°{Ó(CÓDˆ	Ø"×*Ñ*¨1¨a°°AÓ6ˆØÒ%à+¬e¯kªkØÐ/Õ0Ø×(Ñ(¨Ó,Ø×'Ñ'¨¬E¯KªK¸×8LÑ8LÓ,M×,QÑ,QÓRó/õ ˆNð
 Ðr-   c          
      óH   <€ V ^8„  d   QhRS[ RS[ RS[ RS[S[,          RS[ /# )r    rI   rŽ   r€  rÕ   rJ   )r   r   r   )r(   r)   s   "€r*   r+   r†  l  sJ   ø€ ÷ 
Xñ 
Xáð
Xñ ð
Xñ ð	
Xñ
 Ñ+Õ,ð
Xñ 
ñ
Xr-   c                óX  € V P                   ! V P                  W4      V3/ VB w  rVV\        P                  ! V P	                  V4      4      V,          ,           pV P                  V P                  W4      4      pV\        P                  ! V P                  V4      4      V,          ,           # rM   )rò   ró   rw   r�   rþ   rk   rô   r  )rX   rI   rŽ   r€  rÕ   rç   r  r  s   &&&&,   r*   rY   ÚEsmFold2DiffusionLayer.forwardl  s…   € ð Ÿš¨×(<Ñ(<¸]Ó(ZÐ\jÑuÐntÑu‰ˆØ%¬¯ª°d·n±nÀ]Ó6SÓ(TÐWbÕ(bÕbˆØ—X‘X˜d×;Ñ;¸MÓYÓZˆ
ØœuŸ}š}¨T¯]©]¸=Ó-IÓJÈZÕWÕWÐWr-   )rþ   ró   rk   r  r‹  r‰  rô   rò   rM   )r0   r1   r2   r3   r4   rh   r˜  rY   r6   r7   r   r€   s   @@r*   r„  r„  E  s2   ù‡ € ñ÷wó w÷ò ÷$
X÷ 
Xð 
Xr-   r„  c                   ój   a a€ ] tR tRt oRtV3R lV 3R lltR
V3R lR lltV3R lR ltR	tVt	V ;t
# )ÚEsmFold2DiffusionTransformeriy  z9Diffusion denoising transformer with attention pair bias.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú)EsmFold2DiffusionTransformer.__annotate__|  s   ø€ ÷ 
ñ 
™~ð 
°$ñ 
r-   c                óè   <€ \         SV `  4        VP                  P                  p\        P
                  ! \        VP                  4       Uu. uF  p\        V4      NK  	  up4      V n	        R # u upi rM   )
rg   rh   rl  rm  rˆ   rE  ru   rF  r„  rG  )rX   rÁ   rq  r  rl   s   &&  €r*   rh   Ú%EsmFold2DiffusionTransformer.__init__|  sY   ø€ Ü‰ÑÔØ!×0Ñ0×AÑAÐÜ—m’mÜ5:Ð;K×;]Ñ;]Ô5^Ó_Ñ5^°Ô# FÖ+Ñ5^Ñ_ó
ˆŽùÚ_s   ÁA/c                óJ   <€ V ^8„  d   QhRS[ RS[ R,          RS[S[ ,          /# rŽ  ©r   rC   )r(   r)   s   "€r*   r+   r   ƒ  s3   ø€ ÷ _ñ _©vð _ÁvÐPTÅ}ð _Ñ`dÑekÕ`lñ _r-   c                ó`   € V P                    Uu. uF  q3P                  W4      NK  	  up# u upi )z…Per-layer additive attention biases, built once per fold outside the sampling loop; see
``EsmFold2DiffusionLayer.compute_pair_bias``.)rG  r˜  )rX   r�  r=   r\  s   &&& r*   Úcompute_pair_biasesÚ0EsmFold2DiffusionTransformer.compute_pair_biasesƒ  s/   € ð SW×R]ÒR]Ó^ÑR]È×'Ñ'¨ÖDÑR]Ñ^Ð^ùÒ^s   �+c                óB   <€ V ^8„  d   QhRS[ RS[ RS[S[ ,          RS[ /# )r    r]  rŽ   Úattention_biasesrJ   r¤  )r(   r)   s   "€r*   r+   r   ˆ  s1   ø€ ÷ ñ ©6ð Á&ð Ñ\`ÑagÕ\hð Ñmsñ r-   c                óZ   € Tp\        V P                  V4       F  w  rVV! WBV4      pK  	  V# rM   )ÚziprG  )rX   r]  rŽ   r©  rI   r\  r€  s   &&&&   r*   rY   Ú$EsmFold2DiffusionTransformer.forwardˆ  s3   € Ø+ˆÜ%(¨¯©Ð6FÖ%GÑ!ˆEÙ! -ÀÓOŠMñ &HàÐr-   ©rG  rM   )r0   r1   r2   r3   r4   rh   r¦  rY   r6   r7   r   r€   s   @@r*   rž  rž  y  s-   ù‡ € ÙC÷
ó 
÷_ò _÷
÷ ð r-   rž  c                   óx   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltV3R lR ltV3R	 lR
 ltRt	Vt
V ;t# )ÚEsmFold2DiffusionConditioningi�  z=Conditions pair and single representations on noise timestep.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú*EsmFold2DiffusionConditioning.__annotate__’  s   ø€ ÷ 
ñ 
™~ð 
°$ñ 
r-   c                óÂ  <€ \         SV `  4        VP                  P                  pVP                  V n        \        ^VP                  ,          4      V n        \        P                  ! ^VP                  ,          VP                  RR7      V n
        \        VP                  VP                  RR7      V n        \        VP                  VP                  RR7      V n        \        VP                  4      V n        \        P                  ! VP                  VP"                  RR7      V n        \'        VP(                  4      V n        \        VP(                  4      V n        \        P                  ! VP(                  VP"                  RR7      V n        \        VP"                  VP0                  RR7      V n        \        VP"                  VP0                  RR7      V n        R# )r    Fr†   N)rb   )rg   rh   rl  rm  Ú
sigma_datarF   rˆ  Úpair_input_normrˆ   r‰   Ú	pair_projr^   Úpair_intermediate_sizeÚpair_transition_0Úpair_transition_1Úsingle_inputs_sizeÚsingle_input_normr`   Úsingle_projr—   Úfourier_dimÚfourierÚ
noise_normÚ
noise_projra   Úsingle_transition_0Úsingle_transition_1r}  s   && €r*   rh   Ú&EsmFold2DiffusionConditioning.__init__’  sx  ø€ Ü‰ÑÔØ!×0Ñ0×AÑAÐØ*×5Ñ5ˆŒä0°°V×5PÑ5PÕ1PÓQˆÔÜŸš 1 v×'BÑ'BÕ#BÀF×D_ÑD_ÐfkÔlˆŒÜ!3Ø×'Ñ'Ð)9×)PÑ)PÐ]aô"
ˆÔô "4Ø×'Ñ'Ð)9×)PÑ)PÐ]aô"
ˆÔô "3°6×3LÑ3LÓ!MˆÔÜŸ9š9 V×%>Ñ%>Ð@P×@\Ñ@\ÐchÔiˆÔÜ/Ð0@×0LÑ0LÓMˆŒÜ+Ð,<×,HÑ,HÓIˆŒÜŸ)š)Ð$4×$@Ñ$@ÐBR×B^ÑB^ÐejÔkˆŒÜ#5Ø×(Ñ(Ð*:×*LÑ*LÐY]ô$
ˆÔ ô $6Ø×(Ñ(Ð*:×*LÑ*LÐY]ô$
ˆÖ r-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    Ú
pair_trunkÚrelative_position_encodingrJ   r   )r(   r)   s   "€r*   r+   r±  ¬  s$   ø€ ÷ ñ ©Fð ÑPVð Ñ[añ r-   c                ó  € \         P                  ! W.RR7      pV P                  V P                  V4      P	                  V P                  P
                  P                  4      4      pV P                  V4      pV P                  V4      pV# )z˜The pair half of the conditioning. Noise-independent, so it is built once per fold outside
the sampling loop; ``forward`` owns the noise-dependent half.rr   rÚ   )	rw   rx   rµ  r´  rU   rR   rV   r·  r¸  )rX   rÄ  rÅ  r�  s   &&& r*   Úcompute_pair_reprÚ/EsmFold2DiffusionConditioning.compute_pair_repr¬  sq   € ô —i’i Ð HÈbÔQˆØ—n‘n T×%9Ñ%9¸+Ó%F×%IÑ%IÈ$Ï.É.×J_ÑJ_×JeÑJeÓ%fÓgˆØ×,Ñ,¨[Ó9ˆØ×,Ñ,¨[Ó9ˆØÐr-   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# )r    Úsingle_inputsrJ   r   )r(   r)   s   "€r*   r+   r±  ¶  s   ø€ ÷ Gñ G±ð G¹Fñ Gr-   c                óB   € V P                  V P                  V4      4      # )zÖProject the single-inputs tensor into the diffusion token width.

Noise-independent, so it is built once per fold outside the sampling loop; only the Fourier
noise embedding ``forward`` adds to it varies per step.
)r»  rº  )rX   rÊ  s   &&r*   Úcompute_single_reprÚ1EsmFold2DiffusionConditioning.compute_single_repr¶  s    € ð ×Ñ × 6Ñ 6°}Ó EÓFÐFr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    r¢   rŽ   rJ   r   )r(   r)   s   "€r*   r+   r±  ¾  s"   ø€ ÷ 
ñ 
¡6ð 
¹&ð 
ÁVñ 
r-   c                ó®  € R\         P                  ! WP                  ,          P                  RR7      4      ,          pV P	                  V4      pV P                  V P                  V4      P                  V P
                  P                  P                  4      4      pW$P                  ^4      ,           pV P                  V4      pV P                  V4      pV# )z’The noise-dependent half of the single conditioning: add the Fourier noise embedding to the
precomputed ``single_states`` and run the transitions.g      Ð?g#B’¡œÇ;©r–  )rw   Úlogr³  Úclampr½  r¿  r¾  rU   rR   rV   rµ   rÀ  rÁ  )rX   r¢   rŽ   Úlog_noise_levelÚnoise_embedss   &&&  r*   rY   Ú%EsmFold2DiffusionConditioning.forward¾  s¦   € ð ¤§¢¨K¿/¹/Õ,I×+PÑ+PÐUZÐ+PÓ+[Ó!\Õ\ˆØ—|‘| OÓ4ˆØ—‘ t§¡°|Ó'D×'GÑ'GÈÏÉ×H^ÑH^×HdÑHdÓ'eÓfˆØ%×(>Ñ(>¸qÓ(AÕAˆà×0Ñ0°Ó?ˆØ×0Ñ0°Ó?ˆØÐr-   )r½  r¾  r¿  r´  rµ  r·  r¸  r³  rº  r»  rÀ  rÁ  )r0   r1   r2   r3   r4   rh   rÇ  rÌ  rY   r6   r7   r   r€   s   @@r*   r¯  r¯  �  s7   ù‡ € ÙG÷
ó 
÷4ð ÷Gð G÷
÷ 
ð 
r-   r¯  c                   ój   a a€ ] tR tRt oRtV3R lV 3R lltR
V3R lR lltV3R lR ltR	tVt	V ;t
# )ÚEsmFold2DiffusionModuleiË  z4Diffusion denoising module for structure prediction.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú$EsmFold2DiffusionModule.__annotate__Î  s   ø€ ÷ Jñ J™~ð J°$ñ Jr-   c                ó6  <€ \         SV `  4        VP                  P                  pVP                  V n        \        V4      V n        \        P                  ! ^VP                  P                  RR7      V n        \        WP                  4      V n	        \        V4      V n        \        P                  ! VP                  VP                  RR7      V n        \!        V4      V n        \%        VP                  4      V n        \%        VP                  4      V n        R# rï   )rg   rh   rl  rm  r³  r¯  Úconditioningrˆ   r‰   rn  r`   Úcoords_linearr9  rf  Úatom_decoderÚsingle_to_tokenrž  Útoken_transformerrF   Úsingle_step_normÚ
token_normr}  s   && €r*   rh   Ú EsmFold2DiffusionModule.__init__Î  sÕ   ø€ Ü‰ÑÔà!×0Ñ0×AÑAÐØ*×5Ñ5ˆŒä9¸&ÓAˆÔÜŸYšY qÐ*:×*GÑ*G×*SÑ*SÐZ_Ô`ˆÔÜ/°×8UÑ8UÓVˆÔÜ/°Ó7ˆÔÜ!ŸyšyÐ)9×)EÑ)EÐGW×GcÑGcÐjoÔpˆÔÜ!=¸fÓ!EˆÔÜ 1Ð2B×2NÑ2NÓ OˆÔÜ+Ð,<×,HÑ,HÓIˆŽr-   c                óR   <€ V ^8„  d   QhRS[ RS[RS[RS[RS[R,          RS[RS[/# )	r    rL  rÄ  rÅ  rÊ  r=   NÚnum_diffusion_samplesrJ   )r   r   rd   r:   )r(   r)   s   "€r*   r+   rÙ  Ý  sU   ø€ ÷ 6
ñ 6
á'ð6
ñ ð6
ñ %+ð	6
ñ
 ð6
ñ  �ð6
ñ  #ð6
ñ 
&ñ6
r-   c           
     ó  € TpVP                   ^ ,          ^8H  pV P                  P                  V4      w  ršV P                  P                  VP                  V	4      pV P
                  P                  W#4      pV P                  P                  WÅ4      pV'       g3   VP                  V^ 4      pV Uu. uF  qîP                  V^ 4      NK  	  ppV
w  ppV	P                  V^ 4      p	VP                  V^ 4      pVP                  V^ 4      pVP                  P                  V^ 4      pVP                  P                  V^ 4      pVP                  V^ 4      p\        V	VVV3VVV P
                  P                  V4      VR7      # u upi )aÆ  Precompute the conditioning that every denoising step reuses.

Order matters: the featurization and the projections run at the unexpanded batch size and only
their (much narrower) results are expanded.

``num_diffusion_samples`` is a replica axis rather than a batch axis -- every tensor built here
is identical across samples, while the sampler runs the denoiser at
``batch_size * num_diffusion_samples``. The two attention masks are only ever broadcast
against, so they stay at the unexpanded batch size whenever that broadcasts over the sample
batch (``batch_size == 1``, i.e. every single-sequence fold) and are materialized only when it
cannot. They are also the only large tensors here: at length 1000 the per-layer token biases
are ~366 MiB unexpanded, against ~11.4 GiB expanded across the 32 samples the released
checkpoints ask for (the class default is 8). Everything else is a few MB, and expanding it
keeps the scatter/gather helpers on a single shape.
)r<   r=   r>   r?   r'   r@   rA   )rt   rn  rP  rW  r#   rÛ  rÇ  rß  r¦  r  r'   r:   rÌ  )rX   rL  rÄ  rÅ  rÊ  r=   rä  ÚsamplesÚmasks_broadcastabler<   r>   Úatom_window_maskr�  rA   rS   r¦   r¸   r?   r'   Úexpanded_single_inputss   &&&&&&&             r*   Úprepare_conditioningÚ,EsmFold2DiffusionModule.prepare_conditioningÝ  s�  € ð0 (ˆà+×1Ñ1°!Õ4¸Ñ9Ðð ,0×+<Ñ+<×+HÑ+HÈÓ+UÑ(ˆØ×,Ñ,×AÑAÀ+×BaÑBaÐcnÓoÐØ×'Ñ'×9Ñ9¸*ÓaˆØ#×5Ñ5×IÑIÈ+ÓfÐß"Ø/×AÑAÀ'È1ÓMÐÙSgÓ#hÑSgÈ4×$:Ñ$:¸7ÀAÖ$FÑSgÐ Ð#hð '‰ˆˆSØ!×3Ñ3°G¸QÓ?ˆØ×#Ñ# G¨QÓ/ˆØ×#Ñ# G¨QÓ/ˆØ×3Ñ3×EÑEÀgÈqÓQˆ	Ø#×1Ñ1×CÑCÀGÈQÓOˆØ!.×!@Ñ!@ÀÈ!Ó!LÐÜ+Ø#Ø+Ø!$ c 
ØØ'à$(×$5Ñ$5×$IÑ$IÐJ`Ó$aØ!5ô	
ð 		
ùò $is   Â0E>c                ó2   <€ V ^8„  d   QhRS[ RS[ RS[RS[ /# )r    Únoisy_coordsr¢   rÛ  rJ   )r   r:   )r(   r)   s   "€r*   r+   rÙ    s3   ø€ ÷ <ñ <áð<ñ ð<ñ 3ð	<ñ
 
ñ<r-   c           
     ót  € V P                   pV P                  W#P                  R 7      p\        P                  ! W",          WD,          ,           4      pWR,          ,          p\        P
                  ! V\        P                  ! V4      .RR7      pV P                  VP                  V P                  P                  P                  4      4      p	V P                  VP                  V	,           VP                  VP                  VP                  VP                  VP                   VP"                  ^,          R7      w  r«W P%                  V P'                  V4      4      ,           p
V P)                  W¥VP*                  4      p
V P-                  V
4      p
V P/                  V
VVP                  VP                  VP                  VP                   R7      pWD,          pW",          pWÝV,           ,          R,          V,          pVWB,          \        P                  ! WÞ,           4      ,          R,          V,          ,           pV# ))r¢   rŽ   rr   ©rI   r÷   r=   r>   r?   r'   r)  )r]  rI   r÷   r=   r>   r'   )rq   NNrÚ   )r³  rÛ  r@   rw   Úsqrtrx   Ú
zeros_likerÜ  rU   rR   rV   rn  r<   r=   r>   r?   r'   rt   rÞ  rà  rß  rA   rá  rÝ  )rX   rí  r¢   rÛ  r³  rŽ   ÚdenominatorÚnormalized_coordsÚcoord_inputÚcoord_embedsr]  Úatom_hidden_statesÚcoord_updateÚsigma_data_sqÚnoise_level_sqÚdenoised_coordss   &&&&            r*   rY   ÚEsmFold2DiffusionModule.forward  sú  € ð —_‘_ˆ
ð ×)Ñ)°k×QuÑQuÐ)Óvˆô —j’j Õ!:¸ZÕ=TÕ!TÓUˆØ(°}Õ+EÕEÐô —i’iÐ!2´E×4DÒ4DÐEVÓ4WÐ XÐ^`ÔaˆØ×)Ñ)¨+¯.©.¸×9KÑ9K×9RÑ9R×9XÑ9XÓ*YÓZˆØ26×2CÑ2CØ&×2Ñ2°\ÕAØ*×6Ñ6Ø'×6Ñ6Ø ,× @Ñ @Ø"×,Ñ,Ø&×4Ñ4Ø$×*Ñ*¨1Õ-ð 3Dó 3
Ñ/Ðð 2×4HÑ4HÈ×I^ÑI^Ð_lÓImÓ4nÕnÐð #×4Ñ4Ø°×0QÑ0Qó
Ðð
 #Ÿo™oÐ.AÓBÐð ×(Ñ(Ø 3Ø,Ø*×6Ñ6Ø'×6Ñ6Ø ,× @Ñ @Ø&×4Ñ4ð )ó 
ˆð #Õ/ˆØ$Õ2ˆØ(¸NÕ,JÕKÈ]Õ[Ð^jÕjˆàØÕ(¬E¯JªJ°}Õ7UÓ,VÕVÐXeÕfÐiuÕuõvð 	ð
 Ðr-   )	rÝ  rn  rÛ  rÜ  r³  rà  rÞ  rá  rß  )Nrp   )r0   r1   r2   r3   r4   rh   rê  rY   r6   r7   r   r€   s   @@r*   r×  r×  Ë  s.   ù‡ € Ù>÷Jó J÷6
ò 6
÷p<÷ <ð <r-   r×  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2RowAttentionPoolingiT  z0Row-wise attention pooling: attn_proj, out_proj.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú(EsmFold2RowAttentionPooling.__annotate__W  s   ø€ ÷ _ñ _™~ð _°$ñ _r-   c                óØ   <€ \         SV `  4        \        P                  ! VP                  ^RR7      V n        \        P                  ! VP                  VP                  RR7      V n        R# ©rp   Fr†   N)rg   rh   rˆ   r‰   rˆ  Ú	attn_projr`   Úout_proj©rX   rÁ   rl   s   &&€r*   rh   Ú$EsmFold2RowAttentionPooling.__init__W  sI   ø€ Ü‰ÑÔÜŸš 6×#>Ñ#>ÀÈÔNˆŒÜŸ	š	 &×"=Ñ"=¸v×?QÑ?QÐX]Ô^ˆŽr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    r�  r=   rJ   r   )r(   r)   s   "€r*   r+   rÿ  \  s"   ø€ ÷ %ñ %¡6ð %¹6ð %Áfñ %r-   c                ó¶  € V P                  V4      P                  R4      pVP                  VR,          ( \        P                  ! VP
                  4      P                  4      p\        P                  ! VR\        P                  R7      P                  VP
                  4      pVP                  R4      V,          P                  R4      pV P                  V4      # )rp   ©rs   rV   rÚ   ©rq   Nrq   éþÿÿÿ)r  Úsqueezer1  rw   r•  rV   r–  rN   Úsoftmaxr  rU   rµ   r  )rX   r�  r=   ÚscoresÚweightsÚpooleds   &&&   r*   rY   Ú#EsmFold2RowAttentionPooling.forward\  sž   € Ø—‘ Ó,×4Ñ4°RÓ8ˆð ×#Ñ# ^°JÕ%?Ð$?ÄÇÂÈVÏ\É\ÓAZ×A^ÑA^Ó_ˆÜ—)’)˜F¨´%·-±-Ô@×CÑCÀFÇLÁLÓQˆØ×#Ñ# BÓ'¨+Õ5×>Ñ>¸rÓBˆØ�}‰}˜VÓ$Ð$r-   )r  r  r~   r€   s   @@r*   rý  rý  T  s#   ù‡ € Ù:÷_ó _÷
%÷ %ð %r-   rý  c                   óf   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltV3R lR ltR	tVt	V ;t
# )
Ú EsmFold2RelativePositionEncodingif  a%  Pair encoding of relative residue index, token index, chain (sym_id) offset and same-entity.

``embed.weight`` is ``[pairwise_hidden_size, num_features]`` where ``num_features =
2*(2*residue_bins+2) + 1 + (2*chain_bins+2)``. For the defaults residue_bins=32, chain_bins=2:
2*66 + 1 + 6 = 139.
c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú-EsmFold2RelativePositionEncoding.__annotate__n  s   ø€ ÷ 
Vñ 
V™~ð 
V°$ñ 
Vr-   c                ó‚  <€ \         SV `  4        VP                  V n        VP                  V n        ^V P                  ,          ^,           p^V P                  ,          ^,           p^V P                  ,          ^,           p^pW#,           V,           V,           p\        P
                  ! WaP                  RR7      V n        R# )r    Fr†   N)rg   rh   Únum_relative_residx_binsÚnum_relative_chain_binsrˆ   r‰   rˆ  Úembed)rX   rÁ   Únum_residue_featuresÚnum_token_featuresÚnum_chain_featuresÚnum_same_entity_featuresÚnum_featuresrl   s   &&     €r*   rh   Ú)EsmFold2RelativePositionEncoding.__init__n  sž   ø€ Ü‰ÑÔØ(.×(GÑ(GˆÔ%Ø'-×'EÑ'EˆÔ$à  4×#@Ñ#@Õ@À1ÕDÐØ ×!>Ñ!>Õ>ÀÕBÐØ ×!=Ñ!=Õ=ÀÕAÐØ#$Ð Ø+Õ@ÐCUÕUÐXpÕpˆÜ—Y’Y˜|×-HÑ-HÈuÔUˆŽ
r-   c                ó2   <€ V ^8„  d   QhRS[ RS[RS[ RS[ /# )r    ÚdiffÚnum_binsÚ	keep_maskrJ   r*  )r(   r)   s   "€r*   r+   r  z  s+   ø€ ÷ 	=ñ 	=©vð 	=Áð 	=ÑQWð 	=Ñ\bñ 	=r-   c                ót  € \         P                  ! W,           ^ ^V,          4      p\         P                  ! W4^V,          ^,           4      pVP                  ! . VP                  O^V,          ^,           N5RV P
                  P                  P                  / pVP                  RVP                  R4      ^4      # )zßOne-hot encode a relative index difference into ``2 * num_bins + 2`` classes, at the dtype
``embed`` expects: the clipped offset, plus a final "out-of-context" bin wherever ``keep_mask``
is False (e.g. a cross-chain pair).
rV   rÚ   )
rw   Úclipr“  r  rt   r  rR   rV   Úscatter_rµ   )rX   r   r!  r"  ÚbinnedÚone_hots   &&&&  r*   Ú_relative_position_one_hotÚ;EsmFold2RelativePositionEncoding._relative_position_one_hotz  s�   € ô
 —’˜D�O¨Q°°HµÓ=ˆÜ—’˜Y°°Hµ¸qÕ0@ÓAˆà×"Ò"Ðb F§L¡LÐb°!°hµ,ÀÕ2BÒbÈ$Ï*É*×J[ÑJ[×JaÑJaÑbˆØ×Ñ  F×$4Ñ$4°RÓ$8¸!Ó<Ð<r-   c                ó>   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ /# )r    Úresidue_indexÚasym_idÚsym_idÚ	entity_idÚtoken_indexrJ   r   )r(   r)   s   "€r*   r+   r  …  sG   ø€ ÷ !$ñ !$áð!$ñ ð!$ñ ð	!$ñ
 ð!$ñ ð!$ñ 
ñ!$r-   c                ó.  € VP                  ^4      VP                  ^4      8H  pVP                  ^4      VP                  ^4      8H  pVP                  ^4      VP                  ^4      8H  pV P                  V P                  r©V P                  VP                  ^4      VP                  ^4      ,
          W–4      pV P                  VP                  ^4      VP                  ^4      ,
          W–V,          4      pV P                  VP                  ^4      VP                  ^4      ,
          W¦( 4      p\        P
                  ! VVVP                  R4      P                  V P                  P                  P                  4      V.RR7      pV P                  V4      # rú   )
rµ   r  r  r(  rw   rx   rU   r  rR   rV   )rX   r+  r,  r-  r.  r/  Ú
same_chainÚsame_residueÚsame_entityÚresidue_binsÚ
chain_binsÚrelative_residue_one_hotÚrelative_token_one_hotÚrelative_chain_one_hotÚfeaturess   &&&&&&         r*   rY   Ú(EsmFold2RelativePositionEncoding.forward…  su  € ð ×&Ñ& qÓ)¨W×->Ñ->¸qÓ-AÑAˆ
Ø$×.Ñ.¨qÓ1°]×5LÑ5LÈQÓ5OÑOˆØ×)Ñ)¨!Ó,°	×0CÑ0CÀAÓ0FÑFˆð $(×#@Ñ#@À$×B^ÑB^�jØ#'×#BÑ#BØ×#Ñ# AÓ&¨×)@Ñ)@ÀÓ)CÕCÀ\ó$
Ð ð "&×!@Ñ!@Ø×!Ñ! !Ó$ {×'<Ñ'<¸QÓ'?Õ?ÀÐ\hÕOhó"
Ðð "&×!@Ñ!@Ø×Ñ˜QÓ &×"2Ñ"2°1Ó"5Õ5°zÀ;ó"
Ðô —9’9à(Ø&Ø×%Ñ% bÓ)×,Ñ,¨T¯Z©Z×->Ñ->×-DÑ-DÓEØ&ð	ð ô
ˆð �z‰z˜(Ó#Ð#r-   )r  r  r  )r0   r1   r2   r3   r4   rh   r(  rY   r6   r7   r   r€   s   @@r*   r  r  f  s/   ù‡ € ñ÷
Vó 
V÷	=ð 	=÷!$÷ !$ð !$r-   r  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2SingleToPairi©  zZdownproject -> outer product/difference -> two-layer MLP, all at ``pairwise_hidden_size``.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú!EsmFold2SingleToPair.__annotate__¬  s   ø€ ÷ ^ñ ^™~ð ^°$ñ ^r-   c                óR  <€ \         SV `  4        \        P                  ! VP                  VP                  4      V n        \        P                  ! ^VP                  ,          VP                  4      V n        \        P                  ! VP                  VP                  4      V n        R# r  )rg   rh   rˆ   r‰   rˆ  ÚdownprojectÚ
output_fc1Ú
output_fc2r  s   &&€r*   rh   ÚEsmFold2SingleToPair.__init__¬  sn   ø€ Ü‰ÑÔÜŸ9š9 V×%@Ñ%@À&×B]ÑB]Ó^ˆÔÜŸ)š) A¨×(CÑ(CÕ$CÀV×E`ÑE`ÓaˆŒÜŸ)š) F×$?Ñ$?À×A\ÑA\Ó]ˆŽr-   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# rH   r   )r(   r)   s   "€r*   r+   r>  ²  s   ø€ ÷ 	Gñ 	G¡Vð 	G±ñ 	Gr-   c                óT  € V P                  V4      p\        P                  ! VP                  ^4      VP                  ^4      ,          VP                  ^4      VP                  ^4      ,
          .^R7      pV P	                  \
        P                  ! V P                  V4      4      4      # )r    rr   )r@  rw   rx   rµ   rB  rN   ÚgelurA  rW   s   &&r*   rY   ÚEsmFold2SingleToPair.forward²  s‰   € Ø×(Ñ(¨Ó7ˆÜŸ	š	à×(Ñ(¨Ó+¨m×.EÑ.EÀaÓ.HÕHØ×(Ñ(¨Ó+¨m×.EÑ.EÀaÓ.HÕHðð ô
ˆð �‰œqŸvšv d§o¡o°mÓ&DÓEÓFÐFr-   )r@  rA  rB  r~   r€   s   @@r*   r<  r<  ©  s&   ù‡ € Ùd÷^ó ^÷	G÷ 	Gð 	Gr-   r<  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2LanguageModelEncoderi¾  zxProjects the ESMC hidden states into a pair representation, learning a per-layer mixture
(``base_z_combine``) over them.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú)EsmFold2LanguageModelEncoder.__annotate__Â  s   ø€ ÷ añ a™~ð a°$ñ ar-   c                óÌ  <€ \         SV `  4        \        V4      V n        \	        VP
                  4      V n        \	        VP                  P                  4      V n	        \        P                  ! VP                  P                  VP
                  R R7      V n        \        P                  ! \        P                  ! VP                  P                   ^,           4      4      V n        R# r=  )rg   rh   r<  Úsingle_to_pairrF   rˆ  Úpair_output_normÚesmc_configr`   r´  rˆ   r‰   rµ  Ú	Parameterrw   ÚzerosrF  Úlayer_weightsr  s   &&€r*   rh   Ú%EsmFold2LanguageModelEncoder.__init__Â  sš   ø€ Ü‰ÑÔä2°6Ó:ˆÔÜ 1°&×2MÑ2MÓ NˆÔÜ0°×1CÑ1C×1OÑ1OÓPˆÔÜŸš 6×#5Ñ#5×#AÑ#AÀ6×C^ÑC^ÐejÔkˆŒÜŸ\š\¬%¯+ª+°f×6HÑ6H×6ZÑ6ZÐ]^Õ6^Ó*_Ó`ˆÖr-   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# rH   r   )r(   r)   s   "€r*   r+   rK  Ë  s   ø€ ÷ ñ ¡Vð ±ñ r-   c                óP  € VP                  V P                  P                  P                  4      pV P	                  V4      pV P                  V4      pV P
                  P                  ^ 4      pWC,          P                  R4      pV P                  V4      pV P                  V4      pV# )z°Project ESMC hidden states ``[batch_size, num_tokens, num_layers + 1, lm_hidden_size]`` to a
``[batch_size, num_tokens, num_tokens, pairwise_hidden_size]``
pair representation.r
  )
rU   rµ  rR   rV   r´  rR  r  r  rM  rN  )rX   rI   ÚnormedÚlm_pair_statesr  r�  s   &&    r*   rY   Ú$EsmFold2LanguageModelEncoder.forwardË  s–   € ð &×(Ñ(¨¯©×)>Ñ)>×)DÑ)DÓEˆØ×%Ñ% mÓ4ˆØŸ™¨Ó/ˆØ×$Ñ$×,Ñ,¨QÓ/ˆØ!Õ2×;Ñ;¸BÓ?ˆØ×)Ñ)¨.Ó9ˆØ×.Ñ.Øó
ˆð Ðr-   )rR  r´  rN  rµ  rM  r~   r€   s   @@r*   rI  rI  ¾  s%   ù‡ € ñ'÷aó a÷÷ ð r-   rI  ÚEsmFold2TriangleMultiplicationc                   ón   a a€ ] tR tRt oRtR
V3R lV 3R llltV3R lR ltRV3R lR lltR	tVt	V ;t
# )Ú$EsmFold2TriangleMultiplicativeUpdateiÛ  zêTriangle multiplicative update with gated signal routing and explicit orientation.

The O(N^3) contraction is the trunk's dominant cost, so ``use_kernels=True`` swaps this forward
for a fused Triton Hub kernel (CUDA, inference only).
c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r    rÁ   ÚoutgoingrJ   N©r   Úbool)r(   r)   s   "€r*   r+   Ú1EsmFold2TriangleMultiplicativeUpdate.__annotate__ã  s"   ø€ ÷ 8ñ 8™~ð 8¹ð 8Èñ 8r-   c                ó,  <€ \         SV `  4        VP                  V n        V'       d   R MRV n        \        V P                  4      V n        \        V P                  4      V n        \        P                  ! V P                  ^V P                  ,          RR7      V n
        \        P                  ! V P                  V P                  RR7      V n        \        P                  ! V P                  V P                  RR7      V n        VP                  V n        R# )r]  ÚincomingFr†   N)rg   rh   rˆ  rs   ÚflowrF   Ú
norm_startÚnorm_mixrˆ   r‰   Úproj_bundleÚ	proj_emitÚ	proj_gaterb   )rX   rÁ   r]  rl   s   &&&€r*   rh   Ú-EsmFold2TriangleMultiplicativeUpdate.__init__ã  s®   ø€ Ü‰ÑÔØ×.Ñ.ˆŒß"*‘J°
ˆŒ	Ü+¨D¯H©HÓ5ˆŒÜ)¨$¯(©(Ó3ˆŒÜŸ9š9 T§X¡X¨q°4·8±8­|À%ÔHˆÔÜŸš 4§8¡8¨T¯X©X¸EÔBˆŒÜŸš 4§8¡8¨T¯X©X¸EÔBˆŒð '-×&7Ñ&7ˆŽr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    Úleft_streamÚright_streamrJ   r   )r(   r)   s   "€r*   r+   r`  ð  s#   ø€ ÷ (ñ (±ð (Áfð (ÑQWñ (r-   c           
     ó  € V P                   R8X  d   VP                  ^,          MVP                  ^,          pV P                  ;'       g    Tp. p\        ^ W44       F‰  p\	        WfV,           4      pV P                   R8X  d3   VP                  \        P                  ! RVRV3,          V4      4       KX  VP                  \        P                  ! RVRRV3,          V4      4       K‹  	  \        P                  ! V^R7      # )z}Triangular einsum, chunked along the output i-dimension (a falsy ``chunk_size`` means one
full-length chunk, i.e. unchunked).r]  zbikd,bjkd->bijdrq   zbkid,bkjd->bijdrr   )	rc  rt   rb   ru   Úslicerv   rw   Úeinsumrx   )rX   rk  rl  ry   rb   rz   r{   Úwindows   &&&     r*   Ú_triangular_contractÚ9EsmFold2TriangleMultiplicativeUpdate._triangular_contractð  sÍ   € ð +/¯)©)°zÔ*A�+×#Ñ# AÖ&À{×GXÑGXÐYZÕG[ˆØ—_‘_×/Ð/¨ˆ
ØˆÜ˜1˜gÖ2ˆEÜ˜5¨*Õ"4Ó5ˆFØ�y‰y˜JÔ&Ø—‘œeŸlšlÐ+<¸kÈ!ÈVÈ)Õ>TÐVbÓcÖdà—‘œeŸlšlÐ+<¸kÈ!ÈQÐPVÈ,Õ>WÐYeÓfÖgñ 3ô �yŠy˜ QÔ'Ð'r-   c                ó:   <€ V ^8„  d   QhRS[ RS[ R,          RS[ /# )r    Ú	pair_gridÚ
visibilityNrJ   r   )r(   r)   s   "€r*   r+   r`  þ  s&   ø€ ÷ #ñ #¡ð #±V¸dµ]ð #Éfñ #r-   c                óV  € Vf   VP                  VP                  R R 4      pV P                  V4      pV P                  V4      pVP	                  ^V P
                  ,          RR7      w  rVV\        P                  ! V4      ,          pWrP                  R4      P                  VP                  4      ,          pVP                  ^RR7      w  r‰V P                  W‰4      p
V P                  V P                  V
4      4      p\        P                  ! V P                  V4      4      pW¼,          # )Nrr   rÚ   )Únew_onesrt   rd  rf  Úsplitrs   rw   r�   rµ   rU   rV   r|   rq  rg  re  rh  )rX   rt  ru  Únormalized_gridÚbundledÚsignalÚgate_logitsÚroutedrk  rl  Ú
contractedÚmixedÚoutput_gates   &&&          r*   rY   Ú,EsmFold2TriangleMultiplicativeUpdate.forwardþ  sï   € ØÒØ"×+Ñ+¨I¯O©O¸C¸RÐ,@ÓAˆJàŸ/™/¨)Ó4ˆØ×"Ñ" ?Ó3ˆØ%Ÿm™m¨A°·±­L¸b˜mÓAÑˆØœ%Ÿ-š-¨Ó4Õ4ˆà×.Ñ.¨rÓ2×5Ñ5°f·l±lÓCÕCˆà$*§L¡L°¸ LÓ$;Ñ!ˆØ×.Ñ.¨{ÓIˆ
Ø—‘˜tŸ}™}¨ZÓ8Ó9ˆÜ—m’m D§N¡N°?Ó$CÓDˆØÕ"Ð"r-   )rb   rs   rc  re  rd  rf  rg  rh  ©TrM   )r0   r1   r2   r3   r4   rh   rq  rY   r6   r7   r   r€   s   @@r*   r[  r[  Û  s-   ù‡ € ñ÷8õ 8÷(ð (÷#÷ #ò #r-   r[  c                   óX   a a€ ] tR tRt oRtV3R lV 3R lltRV3R lR lltRtVtV ;t	# )	ÚEsmFold2PairUpdateLayeri  z)tri_mul_out, tri_mul_in, pair_transition.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú$EsmFold2PairUpdateLayer.__annotate__  s   ø€ ÷ 
ñ 
™~ð 
°$ñ 
r-   c                óÌ   <€ \         SV `  4        \        VR R7      V n        \        VRR7      V n        \        VP                  VP                  VP                  4      V n	        R# )T)r]  FN)
rg   rh   r[  Útri_mul_outÚ
tri_mul_inr^   rˆ  Ú!pair_transition_intermediate_sizerb   Úpair_transitionr  s   &&€r*   rh   Ú EsmFold2PairUpdateLayer.__init__  sT   ø€ Ü‰ÑÔÜ?ÀÐQUÔVˆÔÜ>¸vÐPUÔVˆŒÜ1Ø×'Ñ'¨×)QÑ)QÐSY×SdÑSdó 
ˆÖr-   c                ó:   <€ V ^8„  d   QhRS[ RS[ R,          RS[ /# ©r    r�  Úpair_attention_maskNrJ   r   )r(   r)   s   "€r*   r+   r†    s'   ø€ ÷ ñ ¡6ð ÁÈÅð ÑY_ñ r-   c                óˆ   € WP                  WR 7      ,           pWP                  WR 7      ,           pV P                  V4      pV# ))ru  )rˆ  r‰  r‹  )rX   r�  r�  s   &&&r*   rY   ÚEsmFold2PairUpdateLayer.forward  sA   € à!×$4Ñ$4°[Ð$4Ó$aÕaˆØ!§O¡O°K OÓ$`Õ`ˆØ×*Ñ*¨;Ó7ˆØÐr-   )r‹  r‰  rˆ  rM   r~   r€   s   @@r*   r„  r„    s!   ù‡ € Ù3÷
ó 
÷÷ ò r-   r„  c                   óX   a a€ ] tR tRt oRtV3R lV 3R lltRV3R lR lltRtVtV ;t	# )	ÚEsmFold2PairUpdateStacki#  z\A stack of ``num_layers`` `EsmFold2PairUpdateLayer` layers refining the pair representation.c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r    rÁ   Ú
num_layersrJ   N)r   rd   )r(   r)   s   "€r*   r+   Ú$EsmFold2PairUpdateStack.__annotate__&  s'   ø€ ÷ bñ b™~ð b¹3ð bÀ4ñ br-   c                ó¨   <€ \         SV `  4        \        P                  ! \	        V4       Uu. uF  p\        V4      NK  	  up4      V n        R # u upi rM   )rg   rh   rˆ   rE  ru   r„  rG  )rX   rÁ   r•  r  rl   s   &&& €r*   rh   Ú EsmFold2PairUpdateStack.__init__&  s>   ø€ Ü‰ÑÔÜ—m’mÌeÐT^ÔN_Ó$`ÑN_ÈÔ%<¸VÖ%DÑN_Ñ$`ÓaˆŽùÒ$`s   ­Ac                ó:   <€ V ^8„  d   QhRS[ RS[ R,          RS[ /# rŽ  r   )r(   r)   s   "€r*   r+   r–  *  s'   ø€ ÷ ñ ¡6ð ÁÈÅð ÑY_ñ r-   c                ó>   € V P                    F  pV! WR 7      pK  	  V# )©r�  r­  )rX   r�  r�  r\  s   &&& r*   rY   ÚEsmFold2PairUpdateStack.forward*  s    € Ø—[”[ˆEÙ ÔUŠKñ !àÐr-   r­  rM   r~   r€   s   @@r*   r“  r“  #  s#   ù‡ € Ùf÷bó b÷÷ ò r-   r“  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2OuterProductMeani0  zBOuter-product mean: maps an MSA representation into a pair update.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú%EsmFold2OuterProductMean.__annotate__3  s   ø€ ÷ 
hñ 
h™~ð 
h°$ñ 
hr-   c                óº  <€ \         SV `  4        VP                  pVP                  V n        VP                  V n        VP
                  V n        \        V P                  4      V n        \        P                  ! V P                  ^V P                  ,          RR7      V n        \        P                  ! V P                  ^,          VP                  RR7      V n        R# )r    Fr†   TN)rg   rh   Úmsa_encoderr`   Úouter_hidden_sizeÚouter_product_chunk_sizerb   rF   ri   rˆ   r‰   Ú
input_projrˆ  Úoutput_proj)rX   rÁ   Ú
msa_configrl   s   && €r*   rh   Ú!EsmFold2OuterProductMean.__init__3  s¡   ø€ Ü‰ÑÔØ×'Ñ'ˆ
Ø%×1Ñ1ˆÔØ!+×!=Ñ!=ˆÔà&0×&IÑ&IˆŒä% d×&6Ñ&6Ó7ˆŒ	ÜŸ)š) D×$4Ñ$4°a¸$×:PÑ:PÕ6PÐW\Ô]ˆŒÜŸ9š9 T×%;Ñ%;¸QÕ%>À×@[Ñ@[ÐbfÔgˆÖr-   c                ó,   <€ V ^8„  d   QhRS[ RS[ RS[ /# )r    Ú
msa_statesÚmsa_attention_maskrJ   r   )r(   r)   s   "€r*   r+   r   ?  s"   ø€ ÷ ,ñ ,¡&ð ,¹fð ,Éñ ,r-   c                óþ  € V P                  V4      pV P                  V4      VP                  R4      P                  VP                  4      ,          pVP                  ^RR7      w  rVVP                  VP                  4      pWwP                  RR4      ,          P                  R4      P                  RR7      pVP                  ^,          p	V P                  ;'       g    T	p
VP                  R,          pVP                  ^ ^^^4      P                  ^^4      p. p\        ^ Wš4       F¼  p\        WîV
,           4      pVRV3,          P                  ^^4      P                  ^^4      V,          pVP                  ^RV34      P                  RRV34      P                  ^^4      P                  R4      pVP                  V P!                  V4      VRV3,          ,          4       K¾  	  \"        P$                  ! V^R7      # )rp   rr   r  rÐ  rq   rÚ   r
  )ri   r¥  rµ   rU   rV   r|   rÜ   rÒ  rt   rb   r’  Úflattenru   rn  Ú	unflattenrv   r¦  rw   rx   )rX   rª  r«  Ú
msa_normedÚprojected_msaÚleftÚrightÚ
mask_floatÚnum_valid_pairsry   rb   Ú	outer_dimÚ
right_flatÚ
out_chunksr{   rp  Úouters   &&&              r*   rY   Ú EsmFold2OuterProductMean.forward?  s´  € Ø—Y‘Y˜zÓ*ˆ
ØŸ™¨
Ó3Ð6H×6RÑ6RÐSUÓ6V×6YÑ6YÐZd×ZjÑZjÓ6kÕkˆØ#×)Ñ)¨!°Ð)Ó4‰ˆØ'×*Ñ*¨4¯:©:Ó6ˆ
Ø%×(<Ñ(<¸RÀÓ(DÕD×OÑOÐPRÓS×YÑYÐ^aÐYÓbˆà—*‘*˜Q•-ˆØ—_‘_×/Ð/¨ˆ
Ø—J‘J˜r•Nˆ	Ø—]‘] 1 a¨¨AÓ.×6Ñ6°q¸!Ó<ˆ
Ø#%ˆ
Ü˜1˜gÖ2ˆEÜ˜5¨*Õ"4Ó5ˆFØ˜˜F˜•O×-Ñ-¨a°Ó3×;Ñ;¸A¸qÓAÀJÕNˆEØ—O‘O A¨¨I Ó7×AÑAÀ"ÀrÈ9ÀoÓV×`Ñ`ÐabÐdeÓf×nÑnÐoqÓrˆEØ×Ñ˜d×.Ñ.¨uÓ5¸ÈÈ6È	Õ8RÕRÖSñ	 3ô
 �yŠy˜¨Ô+Ð+r-   )rb   r`   r¥  ri   r£  r¦  r~   r€   s   @@r*   rž  rž  0  s#   ù‡ € ÙL÷
hó 
h÷,÷ ,ð ,r-   rž  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )Ú EsmFold2MSAPairWeightedAveragingiS  z9Pair-biased MSA row update (AF3 Supplement Algorithm 10).c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú-EsmFold2MSAPairWeightedAveraging.__annotate__V  s   ø€ ÷ 
Wñ 
W™~ð 
W°$ñ 
Wr-   c                óÔ  <€ \         SV `  4        VP                  P                  V n        VP                  P                  V n        V P                  V P                  ,          p\        VP                  P                  4      V n        \        VP                  4      V n	        \        P                  ! VP                  V P                  R R7      V n        \        P                  ! VP                  P                  VR R7      V n        \        P                  ! VP                  P                  VR R7      V n        \        P                  ! W!P                  P                  R R7      V n        R# r=  )rg   rh   r¢  rŠ  rÈ   rF   r`   Únorm_singlerˆ  Ú	bias_normrˆ   r‰   Ú	bias_projrÎ   rŠ   rÏ   )rX   rÁ   Ú	inner_dimrl   s   && €r*   rh   Ú)EsmFold2MSAPairWeightedAveraging.__init__V  sö   ø€ Ü‰ÑÔØ#)×#5Ñ#5×#IÑ#IˆÔ Ø×*Ñ*×3Ñ3ˆŒØ×,Ñ,¨t¯}©}Õ<ˆ	Ü,¨V×-?Ñ-?×-KÑ-KÓLˆÔÜ*¨6×+FÑ+FÓGˆŒÜŸš 6×#>Ñ#>À×@XÑ@XÐ_dÔeˆŒÜ—i’i × 2Ñ 2× >Ñ >À	ÐPUÔVˆŒÜŸš 6×#5Ñ#5×#AÑ#AÀ9ÐSXÔYˆŒÜ—i’i 	×+=Ñ+=×+IÑ+IÐPUÔVˆŽr-   c                ó2   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ /# )r    rª  r�  r�  rJ   r   )r(   r)   s   "€r*   r+   r½  b  s1   ø€ ÷ Tñ T¡&ð T±vð TÑTZð TÑ_eñ Tr-   c                óò  € VP                   w  rErgWEW`P                  V P                  3pV P                  V4      p	V P	                  V P                  V4      4      p
V
P                  VP                  R4      ( \        P                  ! V
P                  4      P                  4       \        P                  ! V
R\        P                  R7      P                  V
P                  4      pV P                  V	4      P!                  V4      p\        P"                  ! V P%                  V	4      4      P!                  V4      p\        P&                  ! RW¼4      pWÞ,          pV P)                  VP!                  WEVR4      4      # )a)  
Args:
    msa_states:          [batch_size, num_tokens, msa_depth, msa_hidden_size]
    pair_states:         [batch_size, num_tokens, num_tokens, pairwise_hidden_size]
    pair_attention_mask: [batch_size, num_tokens, num_tokens]
Returns:
    [batch_size, num_tokens, msa_depth, msa_hidden_size]
r  zbijh,bjmhd->bimhdrÚ   r
  )rt   rŠ  rÈ   r¿  rÁ  rÀ  Úmasked_fill_rµ   rw   r•  rV   r–  r  r  rU   rÎ   rà   r�   rŠ   ro  rÏ   )rX   rª  r�  r�  r4  ry   Ú	msa_depthr  râ   r¯  r€  rè   rå   r“   rç   s   &&&&           r*   rY   Ú(EsmFold2MSAPairWeightedAveraging.forwardb  s%  € ð -7×,<Ñ,<Ñ)ˆ
˜YØ"¨Y×8PÑ8PÐRV×R_ÑR_Ð`ˆà×%Ñ% jÓ1ˆ
ð
 Ÿ™¨¯©°{Ó(CÓDˆØ×#Ñ#Ð%8×%BÑ%BÀ2Ó%FÐ$FÌÏÊÐTb×ThÑThÓHi×HmÑHmÔnä—}’} ^¸Ä5Ç=Á=ÔQ×TÑTÐUc×UiÑUiÓjˆà—{‘{ :Ó.×6Ñ6°|ÓDˆÜ�}Š}˜TŸ^™^¨JÓ7Ó8×@Ñ@ÀÓNˆä—l’lÐ#6¸ÓSˆØÕ(ˆØ�{‰{˜;×.Ñ.¨zÀIÈrÓRÓSÐSr-   )rÀ  rÁ  rŠ   rÈ   r¿  rŠ  rÏ   rÎ   r~   r€   s   @@r*   r»  r»  S  s&   ù‡ € ÙC÷
Wó 
W÷T÷ Tð Tr-   r»  z”
    Output of [`EsmFold2Model`]. All confidence scores are on a 0-1 scale; per-sample tensors
    have a leading `num_diffusion_samples` axis.
    ©Úcustom_introc                   óp   a € ] tR tRt o RtRtRtRtRtRt	Rt
RtRtRtRtRtRtRtRtRtRtV 3R ltRtV tR# )ÚEsmFold2Outputi€  u²  
distogram_logits (`torch.FloatTensor` of shape `(batch_size, num_tokens, num_tokens, distogram_bins)`):
    Predicted distance-distribution logits over residue pairs (RNG-independent; no diffusion sampling).
sample_atom_coords (`torch.FloatTensor` of shape `(num_diffusion_samples, num_atoms, 3)`):
    Predicted all-atom Cartesian coordinates for each diffusion sample.
plddt_logits (`torch.FloatTensor` of shape `(num_diffusion_samples, num_atoms, num_plddt_bins)`):
    Per-atom pLDDT bin logits.
plddt (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
    Per-residue predicted lDDT confidence.
plddt_per_atom (`torch.FloatTensor` of shape `(num_diffusion_samples, num_atoms)`):
    Per-atom predicted lDDT confidence.
plddt_ca (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens)`):
    Predicted lDDT at the representative (CÎ±) atom of each token.
complex_plddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
    Mean pLDDT over all atoms of the complex.
complex_iplddt (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
    Interface-weighted complex pLDDT.
pae_logits (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens, num_tokens, num_pae_bins)`):
    Predicted-aligned-error bin logits.
pae (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens, num_tokens)`):
    Expected predicted aligned error (Ã…) for each residue pair.
pde_logits (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens, num_tokens, num_pde_bins)`):
    Predicted-distance-error bin logits.
pde (`torch.FloatTensor` of shape `(num_diffusion_samples, num_tokens, num_tokens)`):
    Expected predicted distance error (Ã…) for each residue pair.
resolved_logits (`torch.FloatTensor` of shape `(num_diffusion_samples, num_atoms, 2)`):
    Per-atom resolved/unresolved logits.
ptm (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
    Predicted TM-score for each sample.
iptm (`torch.FloatTensor` of shape `(num_diffusion_samples,)`):
    Predicted interface TM-score for each sample.
pair_chains_iptm (`torch.FloatTensor` of shape `(num_diffusion_samples, num_chains, num_chains)`):
    Predicted interface TM-score for each ordered chain pair.
Nc                óº  <€ V ^8„  d   Qh/ S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R	&   S[ R,          ;R
&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   # )r    NÚdistogram_logitsÚsample_atom_coordsÚplddt_logitsÚplddtÚplddt_per_atomÚplddt_caÚcomplex_plddtÚcomplex_iplddtÚ
pae_logitsÚpaeÚ
pde_logitsÚpdeÚresolved_logitsÚptmÚiptmÚpair_chains_iptmr   )r(   r)   s   "€r*   r+   ÚEsmFold2Output.__annotate__€  s5  ø‡ ‚ ñV ˜t•mÑ*ñW ñX  �Ñ,ñY ñZ ˜4•-Ñ&ñ[ ñ\ �D�=Ññ] ñ^ ˜T•MÑ(ñ_ ñ` �t�mÑ"ña ñb ˜D•=Ñ'ñc ñd ˜T•MÑ(ñe ñf ˜•Ñ$ñg ñh 
�$�Ññi ñj ˜•Ñ$ñk ñl 
�$�Ññm ñn ˜d•]Ñ)ño ñp 
�$�Ññq ñr �4�-Ññs ñt ˜t•mÑ*òu r-   r.   )r0   r1   r2   r3   r4   rÎ  rÏ  rÐ  rÑ  rÒ  rÓ  rÔ  rÕ  rÖ  r×  rØ  rÙ  rÚ  rÛ  rÜ  rÝ  r5   r6   r7   r8   s   @r*   rÌ  rÌ  €  sh   ø‡ € ñ!ðF '+ÐØ(,ÐØ"&€LØ€EØ$(€NØ"€HØ#'€MØ$(€NØ $€JØ€CØ $€JØ€CØ%)€OØ€CØ€DØ&*Ð÷u ƒ r-   rÌ  a,  
    Output of [`EsmFold2Model.forward`]: the folding trunk's pair representation, the distogram read
    off it, and the conditioning tensors that the structure and confidence heads consume. Everything
    here is deterministic given the inputs apart from the trunk's random initial pair state.
    c                   óH   a € ] tR tRt o RtRtRtRtRtRt	Rt
V 3R ltRtV tR# )ÚEsmFold2TrunkOutputi½  a¤  
distogram_logits (`torch.FloatTensor` of shape `(batch_size, num_tokens, num_tokens, distogram_bins)`):
    Predicted distance-distribution logits over residue pairs.
pair_states (`torch.FloatTensor` of shape `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`):
    The trunk's final pair representation, in fp32.
single_inputs (`torch.FloatTensor` of shape `(batch_size, num_tokens, single_inputs_size)`):
    Concatenated single-input features built by the inputs embedder.
relative_position_encoding (`torch.FloatTensor` of shape `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`):
    Relative-position pair encoding.
token_bonds_encoding (`torch.FloatTensor` of shape `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`):
    Embedded inter-token covalent-bond feature.
atom_inputs ([`EsmFold2AtomInputs`]):
    The featurized reference-conformer atom inputs, reused by the diffusion atom stack.
Nc                ó¶   <€ V ^8„  d   Qh/ S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[ R,          ;R&   S[R,          ;R&   # )r    NrÎ  r�  rÊ  rÅ  Útoken_bonds_encodingrL  )r   r   )r(   r)   s   "€r*   r+   Ú EsmFold2TrunkOutput.__annotate__½  sl   ø‡ ‚ ñ0 ˜t•mÑ*ñ1 ñ2 ˜$•Ñ%ñ3 ñ4 ˜D•=Ñ'ñ5 ñ6 !'¨¥Ñ4ñ7 ñ8 ! 4�-Ñ.ñ9 ñ: $ dÕ*Ñ1ò; r-   r.   )r0   r1   r2   r3   r4   rÎ  r�  rÊ  rÅ  râ  rL  r5   r6   r7   r8   s   @r*   rà  rà  ½  s4   ø‡ € ñð '+ÐØ!%€KØ#'€MØ04ÐØ*.ÐØ-1€K÷; ƒ r-   rà  c                ó0   € V ^8„  d   QhR\         R\         /# )r    r'   rJ   r   )r(   s   "r*   r+   r+   Ý  s   € ÷ 
 ñ 
 ¬Fð 
 ´vñ 
 r-   c                ó2  € \         P                  ! V R,          V RRR13,          8H  RRR7      p\        P                  ! V 4      p\        P                  ! VRR7      pVP                  V^ 4      p\        P                  ! VRR7      P                  pW4,
          # )	z©Local atom index within each token, from the ``[B, A]`` atom->token map.

A token's atoms are contiguous, so this is a running count that resets at each token boundary.
rq   NF©Úvaluerr   )rq   ºrp   NNrÚ   )rp   r   )rN   Úpadrw   Ú	ones_likeÚcumsumr1  ÚcummaxÚvalues)r'   Úsame_as_prevÚonesrë  Úgroup_starts   &    r*   Ú_compute_intra_token_idxrñ  Ý  s}   € ô
 —5’5˜ uÕ-°¸qÀ#À2À#¸vÕ1FÑFÈÐV[Ô\€LÜ�?Š?˜=Ó)€DÜ�\Š\˜$ BÔ'€FØ×$Ñ$ \°1Ó5€KÜ—,’,˜{°Ô3×:Ñ:€KØÕÐr-   c                óH   € V ^8„  d   QhR\         R\        R\        R\         /# )r    Úlogitsr{   ÚendrJ   )r   rP   )r(   s   "r*   r+   r+   ê  s.   € ÷ Oñ Oœfð O¬Uð O¼ð OÄ6ñ Or-   c                óV  € V P                   R,          p\        P                  ! WV^,           V P                  \        P                  R7      pVRR VR,          ,           ^,          pV P                  4       P                  R4      VP                  ^4      ,          P                  R4      # )ztExpected value of a categorical distribution over ``logits.shape[-1]`` evenly-spaced bins
spanning ``[start, end]``.©r  rV   Nrè  rÚ   )	rt   rw   Úlinspacer  r  rP   r  rµ   r  )ró  r{   rô  r!  ÚedgesÚbin_centerss   &&&   r*   Ú_categorical_meanrú  ê  s€   € ð �|‰|˜BÕ€HÜ�NŠN˜5 x°!¥|¸F¿M¹MÔQV×Q^ÑQ^Ô_€EØ˜˜"�:  b¥	Õ)¨QÕ.€KØ�L‰L‹N×"Ñ" 2Ó&¨×)>Ñ)>¸qÓ)AÕA×JÑJÈ2ÓNÐNr-   c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2ConfidenceInputEmbedderió  z¼Builds the confidence head's base pair representation from the trunk pair representation and
the single-inputs tensor (input norms + single->pair projections, including the outer product).c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú,EsmFold2ConfidenceInputEmbedder.__annotate__÷  s   ø€ ÷ wñ w™~ð w°$ñ wr-   c                ó€  <€ \         SV `  4        \        VP                  4      V n        \        VP
                  4      V n        \        P                  ! VP                  VP
                  R R7      V n	        \        P                  ! VP                  VP
                  R R7      V n
        \        P                  ! VP                  VP
                  R R7      V n        \        P                  ! VP                  VP
                  R R7      V n        \        P                  ! VP
                  VP
                  R R7      V n        R# r=  )rg   rh   rF   r¹  Úsingle_inputs_normrˆ  r‰  rˆ   r‰   rM  Úsingle_to_pair_transposeÚsingle_to_pair_prod_in1Úsingle_to_pair_prod_in2Úsingle_to_pair_prod_outr  s   &&€r*   rh   Ú(EsmFold2ConfidenceInputEmbedder.__init__÷  sÝ   ø€ Ü‰ÑÔÜ"3°F×4MÑ4MÓ"NˆÔÜ*¨6×+FÑ+FÓGˆŒÜ Ÿiši¨×(AÑ(AÀ6×C^ÑC^ÐejÔkˆÔÜ(*¯	ª	°&×2KÑ2KÈV×MhÑMhÐotÔ(uˆÔ%Ü')§y¢y°×1JÑ1JÈF×LgÑLgÐnsÔ'tˆÔ$Ü')§y¢y°×1JÑ1JÈF×LgÑLgÐnsÔ'tˆÔ$Ü')§y¢y°×1LÑ1LÈf×NiÑNiÐpuÔ'vˆÖ$r-   c          
      ó8   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ /# )r    rÊ  r�  rÅ  râ  rJ   r   )r(   r)   s   "€r*   r+   rþ    s=   ø€ ÷ ñ áðñ ðñ %+ð	ñ
 %ðñ 
ñr-   c                ó’  € V P                  V4      pV P                  V4      V,           V,           pW P                  V4      P                  ^4      ,           pW P	                  V4      P                  ^4      ,           pW P                  V P                  V4      R,          V P                  V4      R,          ,          4      ,           pV# )r    )rq   rq   Nrq   )rq   Nrq   rq   )r   r‰  rM  rµ   r  r  r  r  )rX   rÊ  r�  rÅ  râ  Úsingle_inputs_normeds   &&&&& r*   rY   Ú'EsmFold2ConfidenceInputEmbedder.forward  sº   € ð  $×6Ñ6°}ÓEÐà—n‘n [Ó1Ð4NÕNÐQeÕeˆØ!×$7Ñ$7Ð8LÓ$M×$WÑ$WÐXYÓ$ZÕZˆØ!×$AÑ$AÐBVÓ$W×$aÑ$aÐbcÓ$dÕdˆØ!×$@Ñ$@Ø×(Ñ(Ð)=Ó>¸}ÕMØ×*Ñ*Ð+?Ó@ÀÕOõPó%
õ 
ˆð Ðr-   )r‰  r   rM  r  r  r  r  r~   r€   s   @@r*   rü  rü  ó  s&   ù‡ € ñg÷wó w÷÷ ð r-   rü  c                   óÂ   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltV3R lR lt]P                  ! 4       V3R	 lR
 l4       t
RV3R lR lltV3R ltRtVtV ;t# )ÚEsmFold2ConfidenceHeadi  zGPredicts pLDDT, PAE, PDE, resolved-atom probability and distogram bins.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú#EsmFold2ConfidenceHead.__annotate__  s   ø€ ÷ !lñ !l™~ð !l°$ñ !lr-   c                ó:  <€ \         SV `  4        VP                  P                  V n        \        P
                  ! \        P                  ! VP                  P                  VP                  P                  VP                  P                  ^,
          4      4      V n        \        P                  ! VP                  P                  VP                  4      V n        \        V4      V n        \#        V4      V n        \'        WP                  P(                  4      V n        \-        VP.                  4      V n        \        P2                  ! \        P4                  ! VP6                  VP.                  VP                  P8                  4      4      V n        \-        VP                  4      V n        \        P>                  ! VP                  VP                  P@                  RR7      V n!        \-        VP                  4      V n"        \        P>                  ! VP                  VP                  PF                  RR7      V n$        \-        VP.                  4      V n%        \        P2                  ! \        P4                  ! VP6                  VP.                  ^4      4      V n&        R# r  )'rg   rh   Úconfidence_headrT   rˆ   rœ   rw   r÷  Úmin_distÚmax_distÚdistogram_binsÚ
boundariesÚ	Embeddingrˆ  Údist_bin_pairwise_embedrü  Úinput_embedderrý  Úrow_attention_poolingr“  rF  Úfolding_trunkrF   r`   Úplddt_layernormrP  rQ  Úmax_atoms_per_tokenÚnum_plddt_binsÚplddt_weightÚpae_layernormr‰   Únum_pae_binsÚpae_headÚpde_layernormÚnum_pde_binsÚpde_headÚresolved_layernormÚresolved_weightr  s   &&€r*   rh   ÚEsmFold2ConfidenceHead.__init__  sÍ  ø€ Ü‰ÑÔØ×)Ñ)×-Ñ-ˆŒäŸ)š)Ü�NŠNØ×&Ñ&×/Ñ/Ø×&Ñ&×/Ñ/Ø×&Ñ&×5Ñ5¸Õ9óó
ˆŒô (*§|¢|°F×4JÑ4J×4YÑ4YÐ[a×[vÑ[vÓ'wˆÔ$ä=¸fÓEˆÔä%@ÀÓ%HˆÔ"ä4°V×=SÑ=S×=eÑ=eÓfˆÔô  1°×1CÑ1CÓDˆÔÜŸLšLÜ�KŠK˜×2Ñ2°F×4FÑ4FÈ×H^ÑH^×HmÑHmÓnó
ˆÔô /¨v×/JÑ/JÓKˆÔÜŸ	š	 &×"=Ñ"=¸v×?UÑ?U×?bÑ?bÐinÔoˆŒä.¨v×/JÑ/JÓKˆÔÜŸ	š	 &×"=Ñ"=¸v×?UÑ?U×?bÑ?bÐinÔoˆŒä"3°F×4FÑ4FÓ"GˆÔä!Ÿ|š|¬E¯KªK¸×8RÑ8RÐTZ×TfÑTfÐhiÓ,jÓkˆÖr-   c                óŠ   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ RS[ RS[R	S[ R
S[ RS[S[ S[ S[ S[ S[ S[ S[ S[3,          /# )r    rÊ  r�  Úpredicted_coordsÚdistogram_atom_idxr=   r'   r#   rä  rÅ  râ  rJ   ©r   rd   rB   )r(   r)   s   "€r*   r+   r  <  s�   ø€ ÷ 8
ñ 8
áð8
ñ ð8
ñ !ð	8
ñ
 #ð8
ñ ð8
ñ ð8
ñ $ð8
ñ  #ð8
ñ %+ð8
ñ %ð8
ñ 
‰v‘v™v¡v©v±v¹vÁsÐJÕ	Kñ8
r-   c                óØ  € V P                  WWš4      pVP                  V^ 4      pVP                  V^ 4      pVP                  V^ 4      pVP                  V^ 4      pVP                  V^ 4      pVP                  ^8X  d"   VP                  ! R.VP                  RR O5!  MTpVP                  ^ ,          p\        Wý4      p\        P                  ! VVRR7      pVP                  R4      V P                  8„  P                  RR7      pW P                  V4      ,           pVR,          P                  4       VR	,          P                  4       ,          pV P                  VP                  V P                  P                   P"                  4      VR7      pVP%                  V4       ?VP                  V P                  P                   P"                  4      pV P'                  W.4      pVVVVVVVV3# )
aC  Build the per-sample pair + single representations shared by every confidence head.

Returns ``(single_states, pair_states, token_mask, rep_distances, rep_idx_expanded,
atom_to_token_expanded, atom_mask_expanded, expanded_batch_size)``, where the ``*_expanded``
tensors are repeated across the diffusion-sample batch axis.
NÚdonot_use_mm_for_euclid_dist)Úcompute_moderr   r›  rÚ   r
  ©rq   rq   Nr	  )r  r  Úndimrà   rt   rd  rw   Úcdistrµ   r  Úsumr  rP   r  rU   r  rR   rV   Úadd_r  )rX   rÊ  r�  r'  r(  r=   r'   r#   rä  rÅ  râ  Úatom_to_token_expandedÚatom_mask_expandedÚrep_idx_expandedÚ
token_maskÚflat_predicted_coordsÚexpanded_batch_sizeÚ
rep_coordsÚrep_distancesr  Ú	pair_maskÚ
pair_deltarŽ   s   &&&&&&&&&&&            r*   Ú_build_pair_and_singleÚ-EsmFold2ConfidenceHead._build_pair_and_single<  sÝ  € ð& ×)Ñ)¨-ÐF`Ówˆà!×3Ñ3Ð4IÈ1ÓMˆØ!.×!@Ñ!@ÐAVÐXYÓ!ZÐØ0×BÑBÐCXÐZ[Ó\ÐØ-×?Ñ?Ð@UÐWXÓYÐØ#×5Ñ5Ð6KÈQÓOˆ
ð  ×$Ñ$¨Ô)ð ×$Ò$ RÐFÐ*:×*@Ñ*@ÀÀÐ*EÔFà!ð 	ð
 *×/Ñ/°Õ2Ðä'Ð(=ÓPˆ
ÜŸš J°
ÐIgÔhˆØ'×1Ñ1°"Ó5¸¿¹ÑG×LÑLÐQSÐLÓTˆØ!×$@Ñ$@ÀÓ$PÕPˆà˜zÕ*×0Ñ0Ó2°ZÀ
Õ5K×5QÑ5QÓ5SÕSˆ	ð ×'Ñ'¨¯©°t·}±}×7KÑ7K×7QÑ7QÓ(RÐhqÐ'Órˆ
Ø×Ñ˜Ô$ØØ!—n‘n T§]¡]×%9Ñ%9×%?Ñ%?Ó@ˆØ×2Ñ2°;ÓKˆð ØØØØØ"ØØð	
ð 		
r-   c                óf   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ RS[ RS[R	S[S[S[ 3,          /	# )
r    rŽ   r2  r3  r4  r9  Úexpanded_typeÚexpanded_asymr7  rJ   ©r   rd   ÚdictÚstr)r(   r)   s   "€r*   r+   r  v  sy   ø€ ÷ D
ñ D
áðD
ñ !'ðD
ñ #ð	D
ñ
 !ðD
ñ ðD
ñ ðD
ñ ðD
ñ !ðD
ñ 
‰c‘6ˆkÕ	ñD
r-   c	                óÔ  € VP                  4       p	\        W4      p
V P                  V
4      p\        V4      pVP	                  V P
                  P                  ^ ,          ^,
          R7      pV P
                  V,          p\        P                  ! RW½4      p\        P                  ! 4       ;_uu_ 4        \        VRRR7      pVP                  ^,          p\        P                  ! VVVP                  VP                  R7      p\        P                  ! VVVP                  VP                  R7      pVP                  ^W/V	,          4       VP                  ^W)4       VVP	                  RR7      ,          pWù,          P                  RR	7      V	P                  RR	7      V P                   ,           ,          pV^8H  P                  4       pVP#                  R4      VP#                  R4      8g  P                  4       pV^8  P                  4       pVV,          RV,
          P#                  R4      ,          P%                  RR	7      p\        P&                  ! VP)                  4       \        P*                  ! VR
4      V4      p\        VP#                  R4      V4      P-                  R4      pV	V,          pVV,          P                  RR	7      VP                  RR	7      V P                   ,           ,          pVP/                  ^V4      pRRR4       V P1                  V
4      pV P2                  V,          p\        P                  ! RVV4      p RVRXRXRXRXRXRV /#   + '       g   i     L\; i)zTPer-atom confidence outputs off the single representation (pLDDT family + resolved).)Úmaxz...c,...cb->...brÙ   r  ©r{   rô  rö  g�íµ ÷Æ°>rÐ  rr   r¤   NrÐ  rÑ  rÒ  rÓ  rÔ  rÕ  rÚ  rÚ   r
  )rP   rd  r  rñ  rÒ  r  rt   rw   ro  Úno_gradrú  rQ  r  rV   Úscatter_add_r0  rT   rµ   Úamaxr“  r_  Ú	full_liker  rc  r#  r$  )!rX   rŽ   r2  r3  r4  r9  r?  r@  r7  Úatom_mask_floatÚsingle_at_atomsÚnormed_single_at_atomsÚ	intra_idxÚplddt_weightsrÐ  rÒ  r)  Ú	plddt_sumÚ
atom_countrÑ  rÔ  Ú	is_ligandÚinter_chainÚnear_contactÚinterface_per_tokenÚiplddt_weightÚiplddt_weight_atomsÚatom_iplddt_wrÕ  rÓ  Úresolved_single_at_atomsÚresolved_weightsrÚ  s!   &&&&&&&&&                        r*   Ú_compute_atom_confidencesÚ0EsmFold2ConfidenceHead._compute_atom_confidencesv  s	  € ð -×2Ñ2Ó4ˆÜ,¨]ÓSˆØ!%×!5Ñ!5°oÓ!FÐä,Ð-CÓDˆ	Ø—O‘O¨×(9Ñ(9×(?Ñ(?ÀÕ(BÀQÕ(F�OÓGˆ	Ø×)Ñ)¨)Õ4ˆÜ—|’|Ð$6Ð8NÓ^ˆô �]Š]�_�_Ü.¨|À3ÈCÔPˆNà&×,Ñ,¨QÕ/ˆJÜŸšØ# Z¸×8LÑ8LÐTb×ThÑThôˆIô ŸšØ# Z¸×8LÑ8LÐTb×ThÑThôˆJð ×"Ñ" 1Ð&<ÈÕ>^Ô_Ø×#Ñ# AÐ'=ÔOØ 
× 0Ñ 0°TÐ 0Ó :Õ:ˆEà+Õ=×BÑBÀrÐBÓJÈo×NaÑNaÐfhÐNaÓNiÐlp×ltÑltÕNtÕuˆMà&¨!Ñ+×2Ñ2Ó4ˆIØ(×2Ñ2°2Ó6¸-×:QÑ:QÐRTÓ:UÑU×\Ñ\Ó^ˆKØ)¨AÑ-×4Ñ4Ó6ˆLØ#/°+Õ#=ÀÀyÅ×@[Ñ@[Ð\^Ó@_Õ#_×"eÑ"eÐjlÐ"eÓ"mÐä!ŸKšKØ—‘Ó Ü—’Ð 3°SÓ9Ø#óˆMô
 #5°]×5LÑ5LÈRÓ5PÐRhÓ"i×"qÑ"qÐrtÓ"uÐØ+Ð.AÕAˆMØ,¨}Õ<×AÑAÀbÐAÓIÈ]×M^ÑM^ÐceÐM^ÓMfÐim×iqÑiqÕMqÕrˆNà%×,Ñ,¨QÐ0@ÓAˆH÷? ðD $(×#:Ñ#:¸?Ó#KÐ Ø×/Ñ/°	Õ:ÐÜŸ,š,Ð'9Ð;SÐUeÓfˆð ˜LØ�UØ˜nØ˜Ø˜]Ø˜nØ˜ð
ð 	
÷M �_ús   Â3IMÍM'	c                óR   <€ V ^8„  d   QhRS[ RS[ RS[ RS[RS[S[ S[ S[ 3,          /# )r    rÖ  r5  r@  r7  rJ   r)  )r(   r)   s   "€r*   r+   r  ½  sA   ø€ ÷ (+ñ (+Ù ð(+Ù.4ð(+ÙEKð(+Ùbeð(+á	‰v‘v™vÐ%Õ	&ñ(+r-   c                ó&  € VP                   R,          pRV,          p\        P                  ! RV,          RWaP                  R7      pVP	                  4       pVP                  RRR7      p	RV	P                  ^R7      ^,
          R,          ,          R,
          p
^^Wz,          ^,          ,           ,          p\        P                  ! VR\        P                  R	7      pWËR,          ,          P                  RR7      pVP                  R4      VP                  R4      ,          pWÞ,          P                  RR7      VP                  RR7      V P                  ,           ,          pVP                  RR7      P                  pVP                  R4      VP                  R4      8g  P	                  4       V,          pVV,          P                  RR7      VP                  RR7      V P                  ,           ,          pVP                  RR7      P                  pV^ 8”  d(   \        VP                  4       P                  4       4      M^ pV^,           p\        P                   ! VVVVP                  VP"                  R7      p\%        V4       EF  pVV8H  P	                  4       V,          pVP                  4       ^ 8X  d   K5  VP                  R4      pVV,          P                  RR7      VP                  RR7      V P                  ,           ,          p\%        V4       Fm  pVV8H  P	                  4       V,          pVP'                  V^ 8H  \	        R4      4      pVP                  RR7      P                  P                  RR7      VR
VV3&   Ko  	  EK  	  VVV3# )zUpTM / ipTM / per-chain-pair ipTM derived from the PAE logits (reported metrics only).ç      @@rÆ   ©r  T)rs   Úkeepdimg×£p=
×ó?rÐ  gÍÌÌÌÌÌü?r  rq   rr   rö  z-infrÙ   rÚ   gUUUUUUÕ?r‘  r
  )rt   rw   r  r  rP   r0  rÒ  rN   r  r  rµ   rT   rE  rí  rd   ÚitemrQ  rV   ru   r1  )rX   rÖ  r5  r@  r7  r!  Ú	bin_widthrù  r³  Únum_residuesÚd0Ú
tm_per_binÚ	pae_probsÚtm_expectedÚpair_mask_2dÚptm_per_rowrÛ  Úinter_chain_maskÚiptm_per_rowrÜ  Úmax_chain_idÚ
num_chainsrÝ  Úchain_iÚchain_c1Úcol_maskÚavg_tmÚchain_jÚchain_c2Úrow_valss   &&&&&                         r*   Ú_compute_ptm_iptmÚ(EsmFold2ConfidenceHead._compute_ptm_iptm¼  s  € ð
 ×#Ñ# BÕ'ˆØ˜8•Oˆ	Ü—l’l 3¨¥?°D¸)×L]ÑL]Ô^ˆØ×%Ñ%Ó'ˆ
Ø!—~‘~¨"°d�~Ó;ˆà�\×'Ñ'¨BÐ'Ó/°"Õ4¸%Õ@Õ@À3ÕFˆØ˜!˜{Õ/°AÕ5Õ5Õ6ˆ
Ü—I’I˜j¨b¼¿¹ÔFˆ	Ø Ð.>Õ#?Õ?×DÑDÈÐDÓLˆà!×+Ñ+¨BÓ/°*×2FÑ2FÀrÓ2JÕJˆØ"Õ1×6Ñ6¸2Ð6Ó>À,×BRÑBRÐWYÐBRÓBZÐ]a×]eÑ]eÕBeÕfˆØ�o‰o "ˆoÓ%×,Ñ,ˆà)×3Ñ3°BÓ7¸=×;RÑ;RÐSUÓ;VÑV×]Ñ]Ó_ÐbnÕnÐØ#Ð&6Õ6×;Ñ;ÀÐ;ÓCÐGW×G[ÑG[Ð`bÐG[ÓGcÐfj×fnÑfnÕGnÕoˆØ×Ñ BÐÓ'×.Ñ.ˆà:MÐPQÔ:Q”s˜=×,Ñ,Ó.×3Ñ3Ó5Ô6ÐWXˆØ! AÕ%ˆ
Ü Ÿ;š;Ø ¨ZÀ×@RÑ@RÐZe×ZkÑZkô
Ðô ˜Z×(ˆGØ%¨Ñ0×7Ñ7Ó9¸JÕFˆHØ�|‰|‹~ Ô"ÙØ×)Ñ)¨"Ó-ˆHØ! HÕ,×1Ñ1°bÐ1Ó9¸X¿\¹\Èb¸\Ó=QÐTX×T\ÑT\Õ=\Õ]ˆFÜ  Ö,�Ø)¨WÑ4×;Ñ;Ó=À
ÕJ�Ø!×-Ñ-¨h¸!©m¼UÀ6»]ÓK�Ø8@¿¹È¸Ó8L×8SÑ8S×8YÑ8YÐ^aÐ8YÓ8bÐ   G¨WÐ!4Ó5ô -ñ )ð �DÐ*Ð*Ð*r-   c                ó~   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ RS[ RS[ R	S[ R
S[ RS[ RS[RS[S[S[ 3,          /# )r    rÊ  r�  r'  r(  r=   r'   r#   r,  Úmol_typerÅ  râ  rä  rJ   rA  )r(   r)   s   "€r*   r+   r  ç  s¥   ø€ ÷ G
ñ G
áðG
ñ ðG
ñ !ð	G
ñ
 #ðG
ñ ðG
ñ ðG
ñ $ðG
ñ ðG
ñ ðG
ñ %+ðG
ñ %ðG
ñ  #ðG
ñ 
‰c‘6ˆkÕ	ñG
r-   c                óF  € V P                  VVVVVVVVV
VR 7
      w  ppppppppV	P                  V^ 4      pVP                  V^ 4      pV P                  VVVVVVVVR7      pV P                  V P	                  V4      4      pV P                  V P                  V4      4      p\        P                  ! 4       ;_uu_ 4        \        VRRR7      p\        VRRR7      pRRR4       V P                  VVVV4      w  ppp/ VCRVRXRVR	XR
VRVRV/C#   + '       g   i     L<; i))
rÊ  r�  r'  r(  r=   r'   r#   rä  rÅ  râ  )rŽ   r2  r3  r4  r9  r?  r@  r7  rÙ   r_  rF  NrÖ  r×  rØ  rÙ  rÛ  rÜ  rÝ  )r<  r  r[  r  r  r"  r   rw   rG  rú  rv  )rX   rÊ  r�  r'  r(  r=   r'   r#   r,  ry  rÅ  râ  rä  rŽ   r5  r9  r4  r2  r3  r7  r?  r@  Úatom_confidencesrÖ  rØ  r×  rÙ  rÛ  rÜ  rÝ  s   &&&&&&&&&&&&&                 r*   rY   ÚEsmFold2ConfidenceHead.forwardç  sq  € ð0 ×'Ñ'Ø'Ø#Ø-Ø1Ø)Ø'Ø 3Ø"7Ø'AØ!5ð (ó 
ñ		
ØØØØØØ"ØØð !×2Ñ2Ð3HÈ!ÓLˆØ×1Ñ1Ð2GÈÓKˆØ×9Ñ9Ø'Ø#9Ø1Ø-Ø'Ø'Ø'Ø 3ð :ó 	
Ðð —]‘] 4×#5Ñ#5°kÓ#BÓCˆ
Ø—]‘] 4×#5Ñ#5°kÓ#BÓCˆ
ô �]Š]�_�_Ü# J°c¸tÔDˆCÜ# J°c¸tÔDˆC÷ ð '+×&<Ñ&<Ø˜
 MÐ3Fó'
Ñ#ˆˆTÐ#ð	
Øð	
à˜*Ø�3Ø˜*Ø�3Ø�3Ø�DØÐ 0ñ	
ð 		
÷ �_ús   Â?DÄD 	c                ó&   <€ V ^8„  d   Qh/ S[ ;R&   # )r    r  r   )r(   r)   s   "€r*   r+   r    s   ø‡ ‚ ñ Ñò r-   )r  r  rT   r  r  r  r  r"  r   r  r  r#  r$  r  ©rp   )r0   r1   r2   r3   r4   rh   r<  r[  rw   rG  rv  rY   r5   r6   r7   r   r€   s   @@r*   r  r    s\   ù‡ € ÙQ÷!ló !l÷F8
ð 8
÷tD
ð D
ðL ‡]‚]ƒ_÷(+ó ð(+÷TG
ò G
÷g … r-   r  c                ó0   € V ^8„  d   QhR\         R\         /# )r    rç  rJ   )rP   )r(   s   "r*   r+   r+   1  s   € ÷ 1ñ 1œUð 1¤uñ 1r-   c                 óh   € V \         P                  ! \         P                  ! V ) 4      ) 4      ,           # rM   )ÚmathrÑ  Úexpm1ræ  s   &r*   Ú_inverse_softplusrƒ  1  s$   € Ø”4—8’8œTŸZšZ¨¨Ó/Ð/Ó0Õ0Ð0r-   c                   ó^   a a€ ] tR tRt oRtRV3R lV 3R llltV3R lV 3R lltRtVtV ;t	# )	ÚEsmFold2MSAEncoderLayeri5  a  One MSA encoder layer: OPM into pair, MSA pair-weighted averaging, then the pair update.

The pair half is exactly an `EsmFold2PairUpdateLayer`, so it is inherited rather than repeated.

The final layer updates only the pair stream, so it does not build the two MSA-stream submodules:
the released checkpoints carry no weights for them (the MSA representation it would produce is
never read), and `nn.Identity` is not a substitute -- these sit on residuals, so an identity would
double the stream rather than leave it alone.
c                ó*   <€ V ^8„  d   QhRS[ RS[RR/# )r    rÁ   Úupdates_msarJ   Nr^  )r(   r)   s   "€r*   r+   Ú$EsmFold2MSAEncoderLayer.__annotate__@  s"   ø€ ÷ 
ñ 
™~ð 
¹Dð 
ÈDñ 
r-   c                ó  <€ \         SV `  V4       W n        \        V4      V n        V'       dW   \        V4      V n        \        VP                  P                  VP                  P                  VP                  4      V n        R # R # rM   )rg   rh   r‡  rž  Úouter_product_meanr»  Úmsa_pair_weighted_averagingr^   r¢  r`   ra   rb   Úmsa_transition)rX   rÁ   r‡  rl   s   &&&€r*   rh   Ú EsmFold2MSAEncoderLayer.__init__@  sn   ø€ Ü‰Ñ˜Ô Ø&ÔÜ":¸6Ó"BˆÔ÷ Ü/OÐPVÓ/WˆDÔ,Ü"4Ø×"Ñ"×.Ñ.°×0BÑ0B×0TÑ0TÐV\×VgÑVgó#ˆDÖñ r-   c                óN   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[S[ S[ 3,          /# )r    rª  r�  r«  r�  rJ   rø   )r(   r)   s   "€r*   r+   rˆ  L  sM   ø€ ÷ Mñ MáðMñ ðMñ #ð	Mñ
 $ðMñ 
‰v‘vˆ~Õ	ñMr-   c                óÊ   <€ W P                  W4      ,           pV P                  '       d*   WP                  WV4      ,           pV P                  V4      pV\        SV `  W$4      3# rM   )rŠ  r‡  r‹  rŒ  rg   rY   )rX   rª  r�  r«  r�  rl   s   &&&&&€r*   rY   ÚEsmFold2MSAEncoderLayer.forwardL  s^   ø€ ð "×$;Ñ$;¸JÓ$[Õ[ˆØ××ÐØ#×&FÑ&FÀzÐ`sÓ&tÕtˆJØ×,Ñ,¨ZÓ8ˆJØœ5™7™?¨;ÓLÐLÐLr-   )r‹  rŒ  rŠ  r‡  r‚  r~   r€   s   @@r*   r…  r…  5  s&   ù‡ € ñ÷
õ 
÷M÷ Mó Mr-   r…  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2MSAEncoderiZ  zMStack of `EsmFold2MSAEncoderLayer` layers that conditions the pair on an MSA.c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   ÚEsmFold2MSAEncoder.__annotate__]  s   ø€ ÷ 

ñ 

™~ð 

°$ñ 

r-   c                ó  <€ \         SV `  4        \        P                  ! VP                  ^,           VP
                  P                  RR7      V n        \        P                  ! VP                  VP
                  P                  RR7      V n	        \        P                  ! \        VP
                  P                  4       Uu. uF-  p\        WVP
                  P                  ^,
          8g  R7      NK/  	  up4      V n        R# u upi )r    Fr†   )r‡  N)rg   rh   rˆ   r‰   Únum_res_typesr¢  r`   r  r¹  Úproject_inputsrE  ru   rF  r…  rG  )rX   rÁ   Úirl   s   && €r*   rh   ÚEsmFold2MSAEncoder.__init__]  sÁ   ø€ Ü‰ÑÔä—Y’Y˜v×3Ñ3°aÕ7¸×9KÑ9K×9WÑ9WÐ^cÔdˆŒ
Ü Ÿiši¨×(AÑ(AÀ6×CUÑCU×CaÑCaÐhmÔnˆÔÜ—m’mô ˜v×1Ñ1×CÑCÔDóáD�Aô (¨À&×BTÑBT×BfÑBfÐijÕBjÑ=j×lÙDñó
ˆŽùòs   Ã 3Dc                óD   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ RS[ /# )r    r�  rÊ  Úmsa_one_hotÚhas_deletionÚdeletion_valuer«  rJ   r   )r(   r)   s   "€r*   r+   r”  i  sQ   ø€ ÷ ñ áðñ ðñ ð	ñ
 ðñ ðñ #ðñ 
ñr-   c                óô  € \         P                  ! W4P                  R4      VP                  R4      .RR7      pV P                  VP	                  V P                  P
                  P                  4      4      V P                  V4      P                  ^4      ,           pVR,          P                  4       p	V	P                  ^4      V	P                  ^4      ,          p
V P                   F  pV! W�Wj4      w  r�K  	  V# )rp   rr   rÚ   )rq   rq   r   )
rw   rx   rµ   r  rU   rR   rV   r—  r_  rG  )rX   r�  rÊ  r›  rœ  r�  r«  Úmsa_featuresrª  r5  r�  r\  s   &&&&&&&     r*   rY   ÚEsmFold2MSAEncoder.forwardi  sÓ   € ô —y’y +×/EÑ/EÀbÓ/IÈ>×KcÑKcÐdfÓKgÐ!hÐnpÔqˆØ—Z‘Z §¡°·
±
×0AÑ0A×0GÑ0GÓ HÓIÈD×L_ÑL_ØóM
ç
‰)�A‹,õˆ
ð (¨Õ0×5Ñ5Ó7ˆ
Ø(×2Ñ2°1Ó5¸
×8LÑ8LÈQÓ8OÕOÐØ—[”[ˆEÙ&+¨JÐEWÓ&mÑ#ˆJ™ñ !àÐr-   )r  rG  r—  r~   r€   s   @@r*   r’  r’  Z  s!   ù‡ € ÙW÷

ó 

÷÷ ð r-   r’  c                   ó|   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltV3R lR ltRV3R	 lR
 lltRt	Vt
V ;t# )ÚEsmFold2Parcaei~  a®  The trunk's linear-recurrence state update (internally "parcae").

A diagonal state-space recurrence whose time axis is the *recycling loop*, not the sequence: each
trunk loop injects the refreshed pair representation into the state, which decays geometrically and
so converges however many loops run (the fork sampled the loop count during training). The final
state is projected by ``out_proj`` and refined by ``output_stack``.
c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   ÚEsmFold2Parcae.__annotate__‡  s   ø€ ÷ 	[ñ 	[™~ð 	[°$ñ 	[r-   c                ó|  <€ \         SV `  4        \        VP                  4      V n        \
        P                  ! \        P                  ! VP                  4      4      V n	        \
        P                  ! \        P                  ! VP                  \        P                  R 7      4      V n        \
        P                  ! \        P                  ! VP                  VP                  4      4      V n        \
        P                  ! VP                  VP                  RR7      V n        \!        WP"                  4      V n        R# )rN  Fr†   N)rg   rh   rF   rˆ  Ú
input_normrˆ   rP  rw   rQ  Úlog_state_decayÚemptyr  Ú	log_deltaÚinput_matrix_continuousr‰   r  r“  Úparcae_num_coda_layersÚoutput_stackr  s   &&€r*   rh   ÚEsmFold2Parcae.__init__‡  sÉ   ø€ Ü‰ÑÔÜ+¨F×,GÑ,GÓHˆŒÜ!Ÿ|š|¬E¯KªK¸×8SÑ8SÓ,TÓUˆÔÜŸš¤e§k¢k°&×2MÑ2MÔUZ×UbÑUbÔ&cÓdˆŒÜ')§|¢|Ü�KŠK˜×3Ñ3°V×5PÑ5PÓQó(
ˆÔ$ô Ÿ	š	 &×"=Ñ"=¸v×?ZÑ?ZÐafÔgˆŒÜ3°F×<YÑ<YÓZˆÖr-   c                ó6   <€ V ^8„  d   QhRS[ S[S[3,          /# )r    rJ   )rB   r   )r(   r)   s   "€r*   r+   r¤  ’  s   ø€ ÷ 	)ñ 	)™E¡&©& .Õ1ñ 	)r-   c                óô   € \         P                  ! V P                  4      p\        P                  ! V) \        P                  ! V P
                  4      ,          4      pVR,          V P                  ,          pW#3# )uå   ``(state_decay, input_matrix)`` -- the per-channel state transition (Ä€) and the discretized
input projection (BÌ„) of the recurrence.

Loop-invariant, so the trunk computes it once outside the loop and passes it to ``forward``.
r¥   )rN   Úsoftplusr©  rw   Úexpr§  rª  )rX   ÚdeltaÚstate_decayÚinput_matrixs   &   r*   Ú
discretizeÚEsmFold2Parcae.discretize’  sW   € ô —
’
˜4Ÿ>™>Ó*ˆÜ—i’i  ¬¯ª°4×3GÑ3GÓ)HÕ HÓIˆØ˜W•~¨×(DÑ(DÕDˆØÐ(Ð(r-   c          
      ó8   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ /# )r    ÚstateÚinjected_pair_statesr³  r´  rJ   r   )r(   r)   s   "€r*   r+   r¤  �  s<   ø€ ÷ cñ cÙðcÙ39ðcÙHNðcÙ^dðcá	ñcr-   c                óh   € W1,          \         P                  ! V P                  V4      V4      ,           # )zROne recurrence step: decay the state and inject the refreshed pair representation.)rN   Úlinearr¦  )rX   r¸  r¹  r³  r´  s   &&&&&r*   rY   ÚEsmFold2Parcae.forward�  s(   € ð Õ"¤Q§X¢X¨d¯o©oÐ>RÓ.SÐUaÓ%bÕbÐbr-   c                ó:   <€ V ^8„  d   QhRS[ RS[ R,          RS[ /# )r    r¸  r�  NrJ   r   )r(   r)   s   "€r*   r+   r¤  £  s,   ø€ ÷ `ñ `¡&ð `¹vÈ½}ð `ÑX^ñ `r-   c                óF   € V P                  V P                  V4      VR7      # )zUProject the final state to a pair representation and refine it with the output stack.r›  )r¬  r  )rX   r¸  r�  s   &&&r*   Údecode_stateÚEsmFold2Parcae.decode_state£  s"   € à× Ñ  §¡¨uÓ!5ÐK^Ð Ó_Ð_r-   )rª  r¦  r©  r§  r  r¬  rM   )r0   r1   r2   r3   r4   rh   rµ  rY   r¿  r6   r7   r   r€   s   @@r*   r¢  r¢  ~  s>   ù‡ € ñ÷	[ó 	[÷	)ð 	)÷cð c÷`÷ `ò `r-   r¢  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚEsmFold2InputEmbedderi¨  aZ  Embeds the raw token and atom features into the trunk's single and pair representations.

Runs the atom encoder, concatenates its per-token output with the residue-type, profile and
deletion-mean features into ``single_inputs``, then initialises the pair representation from
``single_inputs`` plus the relative-position and token-bond encodings.
c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   Ú"EsmFold2InputEmbedder.__annotate__°  s   ø€ ÷ Qñ Q™~ð Q°$ñ Qr-   c                ó�  <€ \         SV `  4        \        WP                  4      V n        \        P
                  ! VP                  VP                  R R7      V n        \        P
                  ! VP                  VP                  R R7      V n	        \        V4      V n        \        P
                  ! ^VP                  R R7      V n        R# r=  )rg   rh   r9  rn  rˆ   r‰   r¹  rˆ  Úpair_init_1Úpair_init_2r  Úrel_posÚtoken_bondsr  s   &&€r*   rh   ÚEsmFold2InputEmbedder.__init__°  sŒ   ø€ Ü‰ÑÔÜ/°×8KÑ8KÓLˆÔÜŸ9š9 V×%>Ñ%>À×@[Ñ@[ÐbgÔhˆÔÜŸ9š9 V×%>Ñ%>À×@[Ñ@[ÐbgÔhˆÔÜ7¸Ó?ˆŒÜŸ9š9 Q¨×(CÑ(CÈ%ÔPˆÖr-   c                ó€   <€ V ^8„  d   QhRS[ RS[RS[RS[RS[RS[RS[RS[R	S[R
S[RS[RS[S[S[S[S[3,          /# )r    rL  Úres_type_one_hotÚprofileÚdeletion_meanr/  r+  r,  r-  r.  rÉ  r)  rJ   )r   r   rd   rB   )r(   r)   s   "€r*   r+   rÄ  ¸  sŸ   ø€ ÷ 8dñ 8dá'ð8dñ !ð8dñ ð	8dñ
 ð8dñ ð8dñ ð8dñ ð8dñ ð8dñ ð8dñ ð8dñ ð8dñ 
‰v‘v™v¡vÐ-Õ	.ñ8dr-   c           
     ó  € V P                   P                  V4      w  rÍV P                  VVV P                   P                  VP                  V4      VVP                  VP                  VR7      ^ ,          pVP
                  p\        P                  ! VVP                  V4      VP                  V4      VP                  R4      P                  V4      .RR7      pV P                  V4      P                  ^4      V P                  V4      P                  ^4      ,           pV P                  VVVV	VR7      pV P                  V
P                  V P                  P                  P
                  4      4      pVV,           V,           pVVVV3# )zðReturns ``(single_inputs, initial_pair_states, relative_position_encoding,
token_bonds_encoding)``. The last two are already folded into ``initial_pair_states`` and are
returned separately only because the confidence head reads them again.
rï  rr   )r+  r,  r-  r.  r/  rÚ   )rn  rP  rW  r#   r'   rV   rw   rx   rU   rµ   rÆ  rÇ  rÈ  rÉ  rR   )rX   rL  rÌ  rÍ  rÎ  r/  r+  r,  r-  r.  rÉ  r)  r<   r>   Úatom_encodingrV   rÊ  Úinitial_pair_statesrÅ  râ  s   &&&&&&&&&&&&        r*   rY   ÚEsmFold2InputEmbedder.forward¸  s‰  € ð& ,0×+<Ñ+<×+HÑ+HÈÓ+UÑ(ˆØ×)Ñ)à%Ø)Ø×,Ñ,×AÑAÀ+×BaÑBaÐcnÓoØ 3Ø!×5Ñ5Ø%×3Ñ3Ø!ð *ó 	
ð õ	ˆð ×#Ñ#ˆÜŸ	š	àØ ×#Ñ# EÓ*Ø—
‘
˜5Ó!Ø×'Ñ'¨Ó+×.Ñ.¨uÓ5ð	ð ô
ˆð #×.Ñ.¨}Ó=×GÑGÈÓJÈT×M]ÑM]Ð^kÓMl×MvÑMvØóN
õ 
Ðð &*§\¡\Ø'ØØØØ#ð &2ó &
Ð"ð  $×/Ñ/°·±¸t×?OÑ?O×?VÑ?V×?\Ñ?\Ó0]Ó^ÐØ1Ð4NÕNÐQeÕeÐàÐ1Ð3MÐOcÐcÐcr-   )rn  rÆ  rÇ  rÈ  rÉ  r~   r€   s   @@r*   rÂ  rÂ  ¨  s(   ù‡ € ñ÷Qó Q÷8d÷ 8dð 8dr-   rÂ  c                   óV   a a€ ] tR tRt o]tRtRt. ROtRt	. ROt
RtV 3R ltRtVtV ;t# )	ÚEsmFold2PreTrainedModelió  Úesmfold2r/  Tc                óì  <€ \         SV `  V4       \        V\        4      '       dÂ   \        P
                  ! VP                  P                  4       \        P
                  ! VP                  4       \        P                  ! VP                  4       \        P                  ! \        P                  ! R4      4      ) p\        P                  ! VP                  \!        V4      4       R# \        V\"        4      '       dC   \        P                  ! VP$                  4       \        P                  ! VP&                  4       R# \        V\(        4      '       d-   \        P                  ! VP*                  P                  4       R# \        V\,        4      '       dc   VP.                  VP0                  3 FD  p\        P                  ! VP                  4       \        P                  ! VP2                  R4       KF  	  R# \        V\4        4      '       d-   \        P                  ! VP6                  P                  4       R# \        V\8        4      '       d#   \        P                  ! VP:                  4       R# R# )r  Ngš™™™™™É?g       À)rg   Ú_init_weightsÚ
isinstancer¢  ÚinitÚeye_r  rR   rª  Úzeros_r§  r�  rÑ  rð  Ú	constant_r©  rƒ  r  r  r$  rë   rñ   r„  rþ   r  rS   r×  rÞ  rI  rR  )rX   ÚmoduleÚparcae_delta_initr“   rl   s   &&  €r*   r×  Ú%EsmFold2PreTrainedModel._init_weights  s{  ø€ ä‰Ñ˜fÔ%Ü�fœn×-Ò-Ü�IŠI�f—o‘o×,Ñ,Ô-Ü�IŠI�f×4Ñ4Ô5Ü�KŠK˜×.Ñ.Ô/ä!%§¢¬$¯)ª)°IÓ*>Ó!?Ð ?ÐÜ�NŠN˜6×+Ñ+Ô->Ð?PÓ-QÖRÜ˜Ô 6×7Ò7Ü�KŠK˜×+Ñ+Ô,Ü�KŠK˜×.Ñ.Ö/Ü˜Ô 1×2Ò2Ü�KŠK˜×+Ñ+×2Ñ2Ö3Ü˜Ô 6×7Ò7Ø×)Ñ)¨6¯?©?Ó;�Ü—’˜DŸK™KÔ(Ü—’˜tŸy™y¨$Ö/ó <ô ˜Ô 7×8Ò8Ü�KŠK˜×.Ñ.×5Ñ5Ö6Ü˜Ô <×=Ò=Ü�KŠK˜×,Ñ,Ö-ñ >r-   r.   )r„  r9  rf  rž  )r½  znorm.weightz	norm.biasre  rd  r¿  r  Údistogram_head)r0   r1   r2   r3   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚ_no_split_modulesÚsupports_gradient_checkpointingÚ_keep_in_fp32_modules_strictÚ_supports_sdpar×  r6   r7   r   r€   s   @@r*   rÔ  rÔ  ó  s>   ù‡ € à!€LØ"ÐØ#€OòÐð '+Ð#ò	$Ð ð €N÷.õ .r-   rÔ  z÷
    ESMFold2 all-atom protein structure predictor with a bundled ESMC protein-language-model backbone. This is the
    standard released ESMFold2 architecture, whose trunk is a linear-recurrent stack (internally referred to as
    "parcae").
    c                   óî   a a€ ] tR tRt oV3R lV 3R llt]P                  ! 4       V3R lR l4       tV3R lR ltV3R lR	 lt	V3R
 lR lt
V3R lR lt]! RR7      RV3R lR ll4       tRtVtV ;t# )ÚEsmFold2Modeli$  c                ó$   <€ V ^8„  d   QhRS[ RR/# rh  ri  )r(   r)   s   "€r*   r+   ÚEsmFold2Model.__annotate__,  s   ø€ ÷ ñ ™~ð °$ñ r-   c                óD  <€ \         SV `  V4       \        V4      V n        \	        V4      V n        \        P                  ! VP                  4      V n	        \        WP                  4      V n        \        WP                  P                  4      V n        \        V4      V n        \#        V4      V n        \&        P(                  ! VP*                  VP$                  P,                  R R7      V n        \1        V4      V n        \5        V4      V n        V P9                  4        R# )Tr†   N)rg   rh   rÂ  r  rI  Úlanguage_modelr   Úfrom_configrO  Úesmcr“  Úfolding_trunk_num_hidden_layersr  Ú
lm_encoderrF  r¢  Úparcaer×  rl  rˆ   r‰   rˆ  Únum_distogram_binsrà  r  r  r’  r¢  Ú	post_initr  s   &&€r*   rh   ÚEsmFold2Model.__init__,  sÙ   ø€ Ü‰Ñ˜Ô ä3°FÓ;ˆÔÜ:¸6ÓBˆÔä×)Ò)¨&×*<Ñ*<Ó=ˆŒ	ä4°V×=cÑ=cÓdˆÔÜ1°&×:KÑ:K×:]Ñ:]Ó^ˆŒä$ VÓ,ˆŒô 6°fÓ=ˆÔÜ ŸišiØ×'Ñ'¨×)>Ñ)>×)QÑ)QÐX\ô
ˆÔô  6°fÓ=ˆÔä-¨fÓ5ˆÔà�‰Ör-   c                ó>   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ /# )r    Ú	input_idsr,  r+  ry  r=   rJ   r   )r(   r)   s   "€r*   r+   rë  F  sO   ø€ ÷ rñ ráðrñ ðrñ ð	rñ
 ðrñ ðrñ 
ñrr-   c           
     óª  € VP                   w  rgVP                  pV P                  P                  p	V	P                  V	P
                  V	P                  rËp
V^ 8H  V,          p. p. p. p^ p\        V4       EFÍ  pVV,          pVV,          V,          pVV,          V,          pVV,          V,          p\        P                  ! VV3^R7      p\        P                  ! V^ RR7      w  ppVP                  ^ 4      p\        P                  ! VP                  ^ 4      V\        P                  R7      p\        P                  ! V3VP                  ^ 4      V\        P                  R7      pVP                  ^ VVRRR7       \        P                   ! V4      pVV,          pVV,          pVV,          p \        P"                  ! V4      p!\        P                  ! VV\        P                  R7      V!V&   V!V,          p"V P                  RR7      p#\%        V\'        V#4      4      p\        P(                  ! V
.VVP*                  R7      .p$\        P,                  ! VV\        P                  R7      p%^p&\/        V#4       Fì  w  p'p(V V(8H  P1                  RR7      ^ ,          p)V$P3                  VV),          4       \        P                  ! V&V&V)P                   ^ ,          ,           V\        P                  R7      V%V)&   V&V)P                   ^ ,          ,          p&V'\'        V#4      ^,
          8  g   K°  V$P3                  \        P(                  ! Wº.VVP*                  R7      4       V&^,          p&Kî  	  V$P3                  \        P(                  ! V.VVP*                  R7      4       \        P4                  ! V$4      p*VP3                  V*4       VP3                  V*P                   ^ ,          4       VP1                  RR7      ^ ,          p+\        P                  ! V3RV\        P                  R7      p,V%V",          V,V+&   VP3                  V,4       EKÐ  	  \%        V4      p-\        P                  ! VV-3WÈVP*                  R7      p.\        V4       F  pVV,          V.VR	VV,          13&   K  	  V.V
8H  P7                  ^R7      ^,
          p/V/P9                  V.V8H  R4      p/V^8”  d   R
V//MRV/^ 8¬  /p0\;        V P<                  P?                  4       4      P*                  \        P@                  8H  p1\        PB                  ! V P                  PD                  \        P@                  V1R7      ;_uu_ 4        V P<                  ! RRV.RR/V0B p2R	R	R	4       \        P                  ! X2PF                  ^ R7      p3V3P                   w  p4 p5p6\        PH                  ! WgV4V6VV3P*                  R7      p7\        V4       FX  pVV,          p8VV,          V8,          p9V3RVV9R3,          PK                  ^^ ^4      p:V:V7VV8P1                  RR7      ^ ,          3&   KZ  	  V7#   + '       g   i     LÑ; i)a‘  Run ESMC with BOS/EOS wrapping; returns hidden states
``[batch_size, num_tokens, num_esmc_layers + 1, lm_hidden_size]``.

Atom-tokenized modified residues (HYP, MSE, ACE, NH2, ...) span several structure tokens but
share one ``(asym_id, residue_index)`` key, so they are collapsed to a single LM token -- the
LM was trained per-residue -- and the hidden states scattered back to the per-token layout.
rr   T)rs   Úreturn_inverserö  Úamin)r/  r0  )Úsorted)Úas_tupleNÚsequence_idr=   )Údevice_typerV   Úenabledr÷  Úoutput_hidden_statesrq   rÚ   r.   )&rt   r  rÁ   rO  Úbos_token_idÚeos_token_idÚpad_token_idru   rw   ÚstackÚuniquerb  r  ÚlongÚfullr2  ÚargsortÚ
empty_likerE  ÚlenÚtensorrV   r¨  Ú	enumerateÚnonzerorv   rx   rë  r1  Únextrï  Ú
parametersÚbfloat16ÚautocastÚtyperI   rQ  r’  );rX   r÷  r,  r+  ry  r=   r4  r)  r  rO  Úbos_idÚeos_idÚpad_idÚprotein_maskÚlm_input_listÚ
lm_lengthsÚexpand_mapsÚ
max_chainsÚbÚmask_rowÚids_rowÚasym_rowÚres_rowÚkeysÚunique_keysÚinverseÚnum_unique_residuesÚtoken_positionsÚ	first_posÚorderedÚfirst_pos_orderedÚids_collapsedÚasym_collapsedÚremapÚinverse_orderedÚ	chain_idsÚpartsÚper_token_lm_posÚcursorr˜  Úchain_idÚin_chainÚlm_seqÚprot_pos_rowÚ
expand_mapÚmax_lenÚlm_input_idsrý  Úmask_kwargsÚuse_ampÚesmc_outÚlm_hidden_statesÚnum_layers_plus_oner  Úlm_hidden_sizeÚresultÚrow_maskÚlm_positionsÚgathereds;   &&&&&&                                                     r*   Ú_compute_lm_hidden_statesÚ'EsmFold2Model._compute_lm_hidden_statesE  sa  € ð  "+§¡Ñˆ
Ø×!Ñ!ˆØ—k‘k×-Ñ-ˆØ!,×!9Ñ!9¸;×;SÑ;SÐU`×UmÑUm˜ˆØ  A™¨Õ7ˆàˆØˆ
à$&ˆàˆ
Ü�z×"ˆAØ# A•ˆHØ •l 8Õ,ˆGØ˜q•z (Õ+ˆHØ# AÕ& xÕ0ˆGô —;’; ¨'Ð2¸Ô:ˆDÜ#(§<¢<°¸!ÈDÔ#QÑ ˆK˜Ø"-×"2Ñ"2°1Ó"5ÐÜ#Ÿlšl¨4¯9©9°Q«<ÀÌeÏjÉjÔYˆOÜŸ
š
Ð$7Ð#9¸4¿9¹9ÀQ»<ÐPVÔ^c×^hÑ^hÔiˆIØ×%Ñ% a¨°/È&Ð_cÐ%ÔdÜ—m’m IÓ.ˆGØ )¨'Õ 2ÐØ#Ð$5Õ6ˆMØ%Ð&7Õ8ˆNÜ×$Ò$ WÓ-ˆEÜ"Ÿ\š\Ð*=ÀfÔTY×T^ÑT^Ô_ˆE�'‰NØ# G�nˆOà&×-Ñ-°TÐ-Ó:ˆIÜ˜Z¬¨Y«Ó8ˆJä#(§<¢<°°ÀÈwÏ}É}Ô#]Ð"^ˆEä$Ÿ{š{Ð+>ÀvÔUZ×U_ÑU_Ô`ÐØˆFÜ(¨Ö3‘��8Ø*¨hÑ6×?Ñ?ÈÐ?ÓNÈqÕQ�Ø—‘˜]¨8Õ4Ô5Ü-2¯\ª\Ø˜F X§^¡^°AÕ%6Õ6¸vÌUÏZÉZô.Ð  Ñ*ð ˜(Ÿ.™.¨Õ+Õ+�Ø”s˜9“~¨Õ)Ö)Ø—L‘L¤§¢¨vÐ.>ÀvÐU\×UbÑUbÔ!cÔdØ˜a•K’Fñ  4ð �L‰LœŸš v h°vÀWÇ]Á]ÔSÔTÜ—Y’Y˜uÓ%ˆFØ× Ñ  Ô(Ø×Ñ˜fŸl™l¨1�oÔ.ð $×+Ñ+°TÐ+Ó:¸1Õ=ˆLÜŸš Z M°2¸fÌEÏJÉJÔWˆJØ'7¸Õ'HˆJ�|Ñ$Ø×Ñ˜z×*ñ_ #ôd �j“/ˆÜ—z’z :¨wÐ"7¸ÐV_×VeÑVeÔfˆÜ�zÖ"ˆAØ/<¸QÕ/?ˆL˜˜O˜j¨�m˜OÐ+Ó,ñ #ð $ vÑ-×5Ñ5¸!Ð5Ó<¸qÕ@ˆØ!×-Ñ-¨l¸fÑ.DÀbÓIˆð 7AÀ1´n�} kÑ2ÐK[Ð]hÐlmÑ]mÐJnˆä�t—y‘y×+Ñ+Ó-Ó.×4Ñ4¼¿¹ÑFˆÜ�^Š^¨¯©×(8Ñ(8ÄÇÁÐX_×`Ö`Ø—y’yÑb¨<ÐbÈdÐbÐVaÑbˆH÷ aô !Ÿ;š;Ø×"Ñ"¨ô
Ðð 5E×4JÑ4JÑ1Ð˜Q  >Ü—’ØÐ$7¸ÐPVÐ^n×^tÑ^tô
ˆô �zÖ"ˆAØ# A•ˆHØ& q�>¨(Õ3ˆLà'¨¨1¨l¸AÐ(=Õ>×FÑFÀqÈ!ÈQÓOˆHØ<DˆF�1�h×&Ñ&°Ð&Ó5°aÕ8Ð8Ó9ñ #ð ˆ÷% a×`ús   Õ"YÙY	c                ó&   <€ V ^8„  d   QhRS[ RS[ /# )r    Ú	referencerJ   r   )r(   r)   s   "€r*   r+   rë  º  s   ø€ ÷ /ñ /©&ð /±Vñ /r-   c                óT  € \         P                  ! R RVP                  R,          ,          ,          4      p\        P                  ! V\        P
                  R7      p\        P                  P                  VRVRV,          ^V,          R7       VP                  VP                  R7      # )r¤   g      @rN  rÙ   )r,  ÚstdÚar  rÚ   éýÿÿÿ)r�  rð  rt   rw   r	  r  rˆ   rÙ  Útrunc_normal_rU   rV   )rX   rD  rF  r¸  s   &&  r*   Ú_init_pair_stateÚEsmFold2Model._init_pair_stateº  ss   € ä�iŠi˜˜s Y§_¡_°RÕ%8Õ8Õ9Ó:ˆÜ× Ò  ´%·-±-Ô@ˆÜ
�‰×Ñ˜e¨#°3¸"¸s½(ÀaÈ#ÅgÐÔNØ�x‰x˜iŸo™oˆxÓ.Ð.r-   c                ó¦   <€ V ^8„  d   QhRS[ RS[ RS[ R,          RS[ R,          RS[ R,          RS[ RS[ R	S[ R
S[ RS[S[ S[ S[ S[ S[ S[ 3,          /
# )r    Úres_typer=   ÚmsaNr«  rÎ  r$   r%   r#   r'   rJ   rø   )r(   r)   s   "€r*   r+   rë  Á  s�   ø€ ÷ 5
ñ 5
áð5
ñ ð5
ñ �d�]ð	5
ñ
 # T�Mð5
ñ  •}ð5
ñ ð5
ñ $ð5
ñ $ð5
ñ ð5
ñ 
‰v‘v™v¡v©v±vÐ=Õ	>ñ5
r-   c
                ó  € VP                  4       ^8X  d`   \        P                  ! WP                  P                  R7      P                  4       p
W¢P                  R4      P                  4       ,          p
MVP                  4       p
VeÑ   \        P                  ! W0P                  P                  R7      P                  4       pVe�   VP                  4       P                  R4      pW¼,          pVP                  4       P                  ^R7      P                  ^R7      pVP                  ^R7      VP                  R4      ,          pMVP                  ^R7      pMT
pVfF   \        P                  ! VP                  ^ ,          VP                  ^,          VP                  R7      p\        P                  ! W`P                  P                  R7      P                  4       p\        P                  ! WpP                  P                  R7      P                  4       pVP                  4       pVVP                  R4      ,          pVVP                  R4      P                  R4      ,          pW˜P!                  4       ,          p	V
VVVVV	3# )zêOne-hot / mask the raw structural inputs into embedder-ready features.

Returns ``(res_type_one_hot, profile, deletion_mean, ref_element_one_hot,
ref_atom_name_chars_one_hot, atom_to_token)`` with ``atom_to_token`` zeroed at padding.
©Únum_classesrr   rÐ  r`  rÚ   )rs   rN   r'  rÁ   r–  rP   rµ   r0  rÒ  r,  rw   rQ  rt   r  Úmax_atomic_numberr>  r  )rX   rM  r=   rN  r«  rÎ  r$   r%   r#   r'   rÌ  Úmsa_profile_one_hotr³  Úvalid_seq_countrÍ  Úref_element_one_hotÚref_atom_name_chars_one_hotrK  s   &&&&&&&&&&        r*   Ú_prepare_featuresÚEsmFold2Model._prepare_featuresÁ  s  € ð" �<‰<‹>˜QÔÜ Ÿyšy¨¿{¹{×?XÑ?XÔY×_Ñ_ÓaÐØ/×2JÑ2JÈ2Ó2N×2TÑ2TÓ2VÕVÑà'Ÿ~™~Ó/ÐàŠ?Ü"#§)¢)¨C¿[¹[×=VÑ=VÔ"W×"]Ñ"]Ó"_ÐØ!Ò-Ø/×5Ñ5Ó7×AÑAÀ"ÓE�
Ø&9Õ&FÐ#Ø"4×":Ñ":Ó"<×"@Ñ"@ÀQÐ"@Ó"G×"MÑ"MÐRSÐ"MÓ"T�Ø-×1Ñ1°aÐ1Ó8¸?×;TÑ;TÐUWÓ;XÕX‘à-×2Ñ2°qÐ2Ó9‘à&ˆGàÒ Ü!ŸKšK¨¯©°qÕ(9¸8¿>¹>È!Õ;LÐU]×UdÑUdÔeˆMäŸiši¨ÇÁ×A^ÑA^Ô_×eÑeÓgÐÜ&'§i¢iÐ0C×Q\ÑQ\×QlÑQlÔ&m×&sÑ&sÓ&uÐ#à-×3Ñ3Ó5ˆØ1°O×4MÑ4MÈbÓ4QÕQÐØ&AÀO×D]ÑD]Ð^`ÓDa×DkÑDkÐlnÓDoÕ&oÐ#Ø%×(@Ñ(@Ó(BÕBˆð ØØØØ'Øð
ð 	
r-   c                óŠ   <€ V ^8„  d   QhRS[ R,          RS[ R,          RS[ R,          RS[ R,          RS[ RS[ RS[R,          /# )	r    rN  Nr«  rœ  r�  r=   rÊ  rJ   )r   rB  )r(   r)   s   "€r*   r+   rë  ø  se   ø€ ÷ %
ñ %
á�d�]ð%
ñ # T�Mð%
ñ ˜t•mð	%
ñ
  �ð%
ñ ð%
ñ ð%
ñ 
��ñ%
r-   c           
     ó¢  € Vf   R# VP                   w  rxp	\        P                  ! VP                  ^ ^^4      V P                  P
                  R7      P                  4       p
Ve"   VP                  ^ ^^4      P                  4       M'VR	,          P                  R
R
V4      P                  4       pW«P                  R
4      ,          p
Ve"   VP                  ^ ^^4      P                  4       M!\        P                  ! WyW�P                  R7      pVe   VP                  ^ ^^4      M!\        P                  ! WyW�P                  R7      pRVRV
RVRVRV/# )zLAssemble the transposed/padded one-hot MSA tensors the MSA encoder consumes.NrP  r`  rÊ  r›  rœ  r�  r«  r-  rÚ   )rt   rN   r'  r’  rÁ   r–  rP   r  rµ   rw   rQ  r  )rX   rN  r«  rœ  r�  r=   rÊ  r4  rÇ  r)  r›  Úmsa_maskÚhas_deletion_tÚdeletion_value_ts   &&&&&&&       r*   Ú_build_msa_kwargsÚEsmFold2Model._build_msa_kwargsø  s>  € ð Š;ÙØ,/¯I©IÑ)ˆ
˜zÜ—i’i §¡¨A¨q°!Ó 4À$Ç+Á+×B[ÑB[Ô\×bÑbÓdˆð "Ò-ð ×&Ñ& q¨!¨QÓ/×5Ñ5Ô7à 
Õ+×2Ñ2°2°r¸9ÓE×KÑKÓMð 	ð "×$6Ñ$6°rÓ$:Õ:ˆð Ò'ð × Ñ   A qÓ)×/Ñ/Ô1ä—’˜Z°YÇzÁzÔRð 	ð Ò)ð ×"Ñ" 1 a¨Ô+ä—’˜Z°YÇzÁzÔRð 	ð ˜]Ø˜;Ø˜NØÐ.Ø  (ð
ð 	
r-   c                ól   <€ V ^8„  d   QhRS[ RS[ RS[ R,          RS[R,          RS[ RS[ RS[ R	S[R
S[ /	# )r    r�  rÑ  rW  NÚ
msa_kwargsr:  r³  r´  Útotal_stepsrJ   )r   rB  rd   )r(   r)   s   "€r*   r+   rë    sm   ø€ ÷ &ñ &áð&ñ $ð&ñ  �ð	&ñ
 ˜4•Kð&ñ ð&ñ ð&ñ ð&ñ ð&ñ 
ñ&r-   c	                óæ  € V P                   P                  P                  p	VR J;'       d.    V P                   P                  P                  ;'       d    V	R8„  p
\	        V4       Fˆ  pV
'       d   \
        P                  ! W9RR7      pMTpR pVe   V P                  WÅR7      pTpVe   V P                  ! RRV/VB pVe	   Wí,           pV P                  WWg4      pV P                  WR7      pKŠ  	  V# )NrÙ   T)ÚpÚtrainingr›  r�  r.   )
rÁ   rñ  Ú
lm_dropoutÚper_loop_lm_dropoutru   rN   rØ   r¢  rò  r  )rX   r�  rÑ  rW  ra  r:  r³  r´  rb  Úlm_dropout_prg  r  Údropped_lm_pair_statesÚrefined_lm_pair_statesr¹  s   &&&&&&&&&      r*   Ú_run_trunk_loopsÚEsmFold2Model._run_trunk_loops  sø   € ð —{‘{×-Ñ-×8Ñ8ˆà $Ð&×lÐl¨4¯;©;×+AÑ+A×+UÑ+U×lÐlÐZfÐilÑZlð 	ô �{Ö#ˆAß"ä89¿	º	À.ÐkoÔ8pÑ&à)7Ð&à48Ð"Ø%Ò1Ø)-¯©Ð9O¨Ó)oÐ&à#6Ð ØÒ%Ø'+×'7Ò'7Ñ'gÐDXÐ'gÐ\fÑ'gÐ$à%Ò1Ø';Õ'TÐ$àŸ+™+ kÈÓcˆKØ×,Ñ,¨[Ð,ÓXŠKñ' $ð* Ðr-   uå  
        Run the folding trunk: featurize the inputs, embed them into a pair representation, refine it over
        `num_loops` recycling iterations, and read off the distogram. This is the deterministic half of a
        structure prediction; the diffusion sampler that turns the returned pair representation into 3D
        coordinates lives in `EsmFold2FoldingMixin` â€” call [`~EsmFold2Model.fold`] or
        [`~EsmFold2Model.infer_protein`] for an end-to-end prediction.
        rÉ  c          (      ó  <€ V ^8„  d   QhRS[ RS[ RS[ RS[ RS[ RS[ RS[ RS[ R	S[ R
S[RS[ R,          RS[ R,          RS[ R,          RS[ R,          RS[ R,          RS[ R,          RS[ R,          RS[R,          RS[S[,          RS[/# )r    r/  r+  r,  r-  r.  ry  rM  rÉ  r=   rL  rÎ  NrN  rœ  r�  r«  r÷  r:  Ú	num_loopsrÕ   rJ   )r   r   rd   r   r   rà  )r(   r)   s   "€r*   r+   rë  P  s  ø€ ÷ Z
ñ Z
áðZ
ñ ðZ
ñ ð	Z
ñ
 ðZ
ñ ðZ
ñ ðZ
ñ ðZ
ñ ðZ
ñ ðZ
ñ (ðZ
ñ  •}ðZ
ñ �d�]ðZ
ñ ˜t•mðZ
ñ  �ðZ
ñ  # T�Mð!Z
ñ" ˜D•=ð#Z
ñ$ ! 4�-ð%Z
ñ& ˜•:ð'Z
ñ( Ñ+Õ,ð)Z
ñ* 
ñ+Z
r-   c                ó¼  € Ve   TMV P                   P                  p\        ^V^,           4      pV P                  VV	VVVV
P                  V
P
                  V
P                  V
P                  R7	      w  pppppp\        V
VVVR7      p
V P                  V
VVVVVVVVVV	P                  ^,          R7      w  ppppVf   Ve   V P                  VW2Wi4      pRpVe   V P                  V4      p?V	R	,          P                  4       V	R
,          P                  4       ,          pV P                  V4      p V P                  P!                  4       w  p!p"V!P#                  ^^^R4      P%                  V P&                  4      p!V"P%                  V P&                  4      p"V P)                  VVVVV	VR7      p#V P+                  V VVV#VV!V"VR7      p ???#?!?"V P                  P-                  V VR7      p V P                  4       p V P/                  V V P1                  RR4      ,           P%                  V P.                  P2                  P&                  4      4      p$\5        V$V VVVV
R7      # )a  
token_index (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Per-token positional index within the full complex; feeds the relative-position encoding.
residue_index (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Residue index within each chain; feeds the relative-position encoding.
asym_id (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Asymmetric-unit (chain) ID for each token.
sym_id (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Symmetry-copy ID distinguishing identical chains of a homomer.
entity_id (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Entity ID grouping tokens that belong to the same molecular entity.
mol_type (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Molecule-type code for each token (``0`` = protein).
res_type (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Residue-type (amino-acid identity) index for each token.
token_bonds (`torch.Tensor` of shape `(batch_size, num_tokens, num_tokens, 1)`):
    Pairwise inter-token covalent-bond feature.
attention_mask (`torch.Tensor` of shape `(batch_size, num_tokens)`):
    Mask marking valid tokens (``1``) versus padding (``0``). Inputs must be right-padded.
atom_inputs ([`EsmFold2AtomInputs`]):
    The raw reference-conformer atom tensors, bundled: positions, atomic numbers, formal
    charges, encoded atom names, per-atom group IDs, the atom padding mask and the atom->token
    map.
deletion_mean (`torch.Tensor` of shape `(batch_size, num_tokens)`, *optional*):
    Mean MSA deletion count per column. Defaults to zeros (no MSA).
msa (`torch.Tensor` of shape `(batch_size, msa_depth, num_tokens)`, *optional*):
    MSA residue-type tokens (row 0 is the query sequence). Defaults to a single-sequence MSA.
has_deletion (`torch.Tensor` of shape `(batch_size, msa_depth, num_tokens)`, *optional*):
    Boolean flag marking MSA positions preceded by a deletion.
deletion_value (`torch.Tensor` of shape `(batch_size, msa_depth, num_tokens)`, *optional*):
    Per-position MSA deletion counts.
msa_attention_mask (`torch.Tensor` of shape `(batch_size, msa_depth, num_tokens)`, *optional*):
    Validity mask for the MSA rows/columns.
input_ids (`torch.Tensor` of shape `(batch_size, num_tokens)`, *optional*):
    ESMC-vocabulary token ids for the sequence. Fed to the bundled ESMC backbone to produce
    `lm_hidden_states` when those are not passed directly; ignored when `lm_hidden_states` is given.
lm_hidden_states (`torch.Tensor` of shape `(batch_size, num_tokens, num_esmc_layers + 1, esmc_hidden_size)`, *optional*):
    Precomputed ESMC backbone hidden states, one per backbone layer plus the embeddings. When
    provided, the backbone is not run and `input_ids` is unused.
num_loops (`int`, *optional*):
    Number of trunk refinement loops. Defaults to `config.num_loops`.
N)	rM  r=   rN  r«  rÎ  r$   r%   r#   r'   )r$   r%   r'   )rL  rÌ  rÍ  rÎ  r/  r+  r,  r-  r.  rÉ  r)  )rN  r«  rœ  r�  r=   rÊ  )r�  rÑ  rW  ra  r:  r³  r´  rb  r›  )rÎ  r�  rÊ  rÅ  râ  rL  r-  r	  rÚ   r
  rH  )rÁ   rn  rE  rW  r$   r%   r#   r'   r   r  rt   rA  rí  rP   rJ  rò  rµ  rÛ   rU   rV   r^  rk  r¿  rà  rÜ   rR   rà  )%rX   r/  r+  r,  r-  r.  ry  rM  rÉ  r=   rL  rÎ  rN  rœ  r�  r«  r÷  r:  rn  rÕ   rb  rÌ  rÍ  rU  rV  r'   rÊ  rÑ  rÅ  râ  rW  r:  r�  r³  r´  ra  rÎ  s%   &&&&&&&&&&&&&&&&&&&,                 r*   rY   ÚEsmFold2Model.forwardG  s³  € ðR "+Ò!6‘I¸D¿K¹K×<QÑ<Qˆ	Ü˜!˜Y¨�]Ó+ˆð ×"Ñ"Ø!Ø-ØØ#5Ø+Ø'×3Ñ3Ø$/×$CÑ$CØ$/×$CÑ$CØ)×7Ñ7ð #ó 
ñ 	rÐ˜' =Ð2EÐGbÐdqô ØØ+Ø ;Ø'ô	
ˆð `d×_rÑ_rØ#Ø-ØØ'Ø#Ø'ØØØØ#Ø%×+Ñ+¨AÕ.ð `só `
Ñ\ˆÐ*Ð,FÐH\ð Ò#¨	Ò(=Ø#×=Ñ=Ø˜7°8ó Ðð )-ˆØÒ'Ø!×0Ñ0Ð1AÓBˆNØà" :Õ.×4Ñ4Ó6¸È
Õ9S×9YÑ9YÓ9[Õ[ˆ	à×+Ñ+Ð,?Ó@ˆà$(§K¡K×$:Ñ$:Ó$<Ñ!ˆ�\Ø!×&Ñ& q¨!¨Q°Ó3×6Ñ6°{×7HÑ7HÓIˆØ#—‘ {×'8Ñ'8Ó9ˆà×+Ñ+ØØ1Ø%Ø)Ø)Ø'ð ,ó 
ˆ
ð ×+Ñ+Ø#Ø 3Ø)Ø!ØØ#Ø%Ø#ð ,ó 	
ˆð   °¸[È,à—k‘k×.Ñ.¨{ÐPYÐ.ÓZˆà!×'Ñ'Ó)ˆØ×.Ñ.Ø˜;×0Ñ0°°RÓ8Õ8×<Ñ<¸T×=PÑ=P×=WÑ=W×=]Ñ=]Ó^ó
Ðô #Ø-Ø#Ø'Ø'AØ!5Ø#ô
ð 	
r-   )
r  rà  rï  r  r  rí  rñ  r¢  rò  rl  )NNNNNNNN)r0   r1   r2   r3   rh   rw   rG  rA  rJ  rW  r^  rk  r   rY   r6   r7   r   r€   s   @@r*   ré  ré  $  sƒ   ù‡ € ÷ó ð2 ‡]‚]ƒ_÷ró ðr÷h/ð /÷5
ð 5
÷n%
ð %
÷N&ð &ñP ðô÷Z
ñ Z
ó÷Z
ð Z
r-   ré  r~  rM   )`r�  Úcollections.abcr   Údataclassesr   r   rw   Útorch.nnrˆ   Útorch.nn.functionalÚ
functionalrN   r   Ú r   rÙ  Úactivationsr	   Úintegrationsr
   Úmasking_utilsr   r   Úmodeling_layersr   Úmodeling_outputsr   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   Úautor   Úllama.modeling_llamar   r   Únanochat.modeling_nanochatr   Úphi3.modeling_phi3r   Úconfiguration_esmfold2r   r   r   Úgeneration_esmfold2r   r   r:   Ú	LayerNormrF   r\   r¯   r^   r‚   r—   rj   r¼   r¾   rë   r  r7  r9  rd  rf  ry  r„  rž  r¯  r×  rý  r  r<  rI  r[  r„  r“  rž  r»  rÌ  rà  rñ  rú  rü  r  rƒ  r…  r’  r¢  rÂ  rÔ  ré  Ú__all__r.   r-   r*   Ú<module>r‡     sw  ðó Ý $ß *ã Ý ß Ð Ý å &Ý !Ý 7ß \Ý 9Ý +ß FÝ &ß 7Ý ß GÝ 8Ý (ß lÑ lÝ 5ð ÷ð ó ððB ÷'ð 'ó ð'ô(
˜Ÿ™ô 
ôP�oô Pô(˜Ÿ™ô (ô2M §	¡	ô Mô,u˜rŸy™yô uô",�Wô ,ôô.>6˜BŸI™Iô >6ôB Ð2ô  ôF.8˜bŸi™iô .8÷b*ô@W2˜"Ÿ)™)ô W2õt(ô$˜"Ÿ)™)ô $ôN46 §¡ô 46ôn1XÐ7ô 1Xôh 2§9¡9ô ô,9 B§I¡Iô 9ôxF˜bŸi™iô FôR% "§)¡)ô %ô$@$ r§y¡yô @$ôFG˜2Ÿ9™9ô Gô* 2§9¡9ô ñ: Ð=Ó>ô1#¨2¯9©9ó 1#ó ?ð1#ôhÐ8ô ô&
˜bŸi™iô 
ô ,˜rŸy™yô  ,ôF*T r§y¡yô *TñZ ðôð ô3+�[ó 3+ó óð3+ñl ðôð ô2˜+ó 2ó óð2õ0
 õOô b§i¡iô ôBZ
˜RŸY™Yô Z
õz1ô"MÐ5ô "MôJ!˜Ÿ™ô !ôH'`�R—Y‘Yô '`ôTHd˜BŸI™Iô HdðV ô-.˜oó -.ó ð-.ñ` ðôô
Ð+Ð-Aó 
óð
ðD Ð5Ð
6‚r-   