Ë
    ÌÓ^jÕÌ  ã            %       óV  — d dl Z d dlmZ d dlZg Zd+d„Zd+d„Zd„ Ze j                   G d„ d«      «       Z	e j                   G d„ d	«      «       Z
	 d,d
ej                  dej                  dej                  dej                  dz  dej                  dz  dedededededej                  dedededej                  dz  deej                  ej                  ej                  ej                  f   f d„Zej&                  j)                  dd¬«      d
ej                  dej                  dej                  dej                  dz  dej                  dz  dedededededej                  dededededeej                  ej                  ej                  ej                  f   f d„«       Zd Zej.                  defd!„«       Zej2                  d"„ «       Zd#„ Zej9                  ee¬$«       ej&                  j)                  d%d¬«      d
ej                  dej                  dej                  dej                  dz  dej                  dz  dedededej                  dej                  fd&„«       Zd'„ Zej.                  defd(„«       Zej2                  d)„ «       Zd*„ Z ej9                  e e¬$«       y)-é    N)Úcached_propertyc                 óT   — t        j                  |r| ndt        | «      z  ||d¬«      S ©N©r   F)ÚdeviceÚdtypeÚrequires_grad)ÚtorchÚemptyÚlen©Úshaper   r   Úwhens       úp/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/nn/modules/linear_cross_entropy.pyÚ_make_emptyr   
   s,   € ä�;‰;Ù‰˜4¤# e£*Ñ,ØØØô	ð ó    c                 óT   — t        j                  |r| ndt        | «      z  ||d¬«      S r   )r
   Úzerosr   r   s       r   Ú_make_zerosr      s,   € Ü�;‰;Ù‰˜4¤# e£*Ñ,ØØØô	ð r   c                 óü   — |�^ }}}}}|| _         || _        || _        || _        |\  }}}	}
|r|j	                  «       nd | _        |r|	j	                  «       nd | _        |r|
j	                  «       | _        y d | _        y ©N)Úallow_retain_graphÚcompute_input_gradÚcompute_linear_weight_gradÚcompute_linear_bias_gradÚdetachÚ_giÚ_gwÚ_gb)ÚctxÚinputsÚoutputÚ_r   r   r   r   Ú
grad_inputÚgrad_linear_weightÚgrad_linear_biass              r   Ú1_linear_cross_entropy_batch_chunked_setup_contextr'      s�   € ð 	ñØ	
ØØØ"Ø à/€CÔØ/€CÔØ%?€CÔ"Ø#;€CÔ Ø:@Ñ7€A€zÐ%Ð'7ñ &8ˆj×ÑÔ!¸T€C„GÙ-GÐ ×'Ñ'Ô)ÈT€C„GÙ+CÐ×%Ñ%Ó'€C…GÈ€C…Gr   c                   ó@  — e Zd ZU dZded<   eed<   eed<   ej                  ed<   ej                  ed<   ej                  ed<   ej                  ed	<   ej                  ed
<   edej                  fd„«       Z	edej                  fd„«       Z
edej                  fd„«       Zedej                  fd„«       Zedej                  fd„«       Zedej                  fd„«       Zedej                  fd„«       Zedej                  fd„«       Zedej                  fd„«       Zy)Ú_ChunkViewsz…Per-iteration tensor views; each property picks the right operand
    or scratch from ctx dispatch flags so call sites read raw.
    Ú_ChunkContextr    Úbchunk_startÚbchunk_sizeÚinput_chunkÚtarget_chunkÚweight_chunkÚlogitsÚinput_chunk_accÚreturnc                 ó^   — | j                   j                  r| j                  S | j                  S r   )r    Úforward_uses_acc_inputr1   r-   ©Úselfs    r   Úinputz_ChunkViews.inputF   s1   € ð �x‰x×.Ò.ð × Ñ ð	
ð ×!Ñ!ð	
r   c                 ób   — | j                   }|j                  r|j                  S |j                  S r   )r    Úforward_uses_cuda_out_dtypeÚlinear_weightÚlinear_weight_cast©r6   r    s     r   r:   z_ChunkViews.linear_weightN   s6   € à�h‰hˆð ×.Ò.ð ×Ñð	
ð ×'Ñ'ð	
r   c                 ó^   — | j                   j                  r| j                  S | j                  S r   )r    Úinput_grad_uses_logits_lwÚlogits_downcastr0   r5   s    r   Úinput_grad_logitsz_ChunkViews.input_grad_logitsW   s%   € à�8‰8×-Ò-Ø×'Ñ'Ð'Ø�{‰{Ðr   c                 ób   — | j                   }|j                  r|j                  S |j                  S r   )r    r>   r:   r;   r<   s     r   Úinput_grad_linear_weightz$_ChunkViews.input_grad_linear_weight]   s6   € à�h‰hˆð ×,Ò,ð ×Ñð	
ð ×'Ñ'ð	
r   c                 óz   — | j                   }|j                  r|j                  s| j                  S | j                  S r   )r    Úis_cudaÚweight_grad_mm_same_dtyper-   r1   r<   s     r   Úweight_grad_inputz_ChunkViews.weight_grad_inputf   s2   € à�h‰hˆØ�;Š;˜s×<Ò<Ø×#Ñ#Ð#Ø×#Ñ#Ð#r   c                 óâ   — | j                   }|j                  s|j                  r| j                  S |j                  j                  dd| j                  «      j                  | j                  «      S ©Nr   )r    rD   rE   r0   Úlogits_acc_bufÚnarrowr,   Úcopy_r<   s     r   Úlogits_upcastz_ChunkViews.logits_upcastm   sV   € ð �h‰hˆØ�;Š;˜#×7Ò7Ø—;‘;ÐØ×!Ñ!×(Ñ(¨¨A¨t×/?Ñ/?Ó@×FÑFÀtÇ{Á{ÓSÐSr   c                 óâ   — | j                   }|j                  r'|j                  j                  dd| j                  «      S |j
                  j                  d| j                  | j                  «      S rH   )r    Úalloc_input_grad_acc_bufÚinput_grad_acc_bufrJ   r,   r$   r+   r<   s     r   Úgrad_input_chunkz_ChunkViews.grad_input_chunku   s\   € ð �h‰hˆØ×'Ò'Ø×)Ñ)×0Ñ0°°A°t×7GÑ7GÓHÐHØ�~‰~×$Ñ$ Q¨×(9Ñ(9¸4×;KÑ;KÓLÐLr   c                 ób   — | j                   }|j                  r|j                  S |j                  S r   )r    Úalloc_linear_bias_grad_chunkÚlinear_bias_grad_chunkr&   r<   s     r   Úbias_grad_accz_ChunkViews.bias_grad_acc}   s.   € ð �h‰hˆØ×+Ò+Ø×-Ñ-Ð-Ø×#Ñ#Ð#r   c                 ó¨   — | j                   }|j                  r/| j                  j                  |j                  j
                  «      S | j                  S r   )r    Úloop_caches_logits_downcastr0   Útor:   r   r<   s     r   r?   z_ChunkViews.logits_downcastŒ   s?   € ð �h‰hˆØ×*Ò*Ø—;‘;—>‘> #×"3Ñ"3×"9Ñ"9Ó:Ð:Ø�{‰{Ðr   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__Úintr
   ÚTensorÚpropertyr7   r:   r@   rB   rF   rL   r   rP   rT   r?   © r   r   r)   r)   7   sh  … ñð 
ÓØÓØÓØ—‘ÓØ—,‘,ÓØ—,‘,ÓØ�L‰LÓØ—\‘\Ó!àð
�u—|‘|ò 
ó ð
ð ð
˜uŸ|™|ò 
ó ð
ð ð 5§<¡<ò ó ðð
 ð
¨%¯,©,ò 
ó ð
ð ð$ 5§<¡<ò $ó ð$ð ðT˜uŸ|™|ò Tó ðTð ðM %§,¡,ò Mó ðMð ð$˜uŸ|™|ò $ó ð$ð ð §¡ò ó ñr   r)   c            "       ó,  — e Zd ZU dZej
                  ed<   eed<   eed<   eed<   eed<   eed<   ej
                  ed<   ej
                  ed	<   ej
                  ed
<   ej
                  ed<   ej                  ed<   ej                  ed<   ej                  dz  ed<   eed<   e
ed<   ej                  ed<   ej                  dz  ed<   ej                  dz  ed<   ej                  ed<   ej                  ed<   ej                  ed<   eed<   eed<   eed<   eed<   eed<   eed<   eed<   eed<   eed <   eed!<   eed"<   eed#<   eed$<   eed%<   ed&ej                  fd'„«       Zed&ej                  fd(„«       Zed&ej                  fd)„«       Zed&ej                  fd*„«       Zed&ej                  dz  fd+„«       Zed&ej                  fd,„«       Zed&ej                  fd-„«       Zed&ej                  fd.„«       Zed&ej                  fd/„«       Zed&ej                  fd0„«       Zed&ej                  fd1„«       Zed&ej                  fd2„«       Zed&ej                  fd3„«       Ze	 dMdej                  dej                  dej                  dej                  dz  dej                  dz  de
ded4ed5ed6e
dej
                  dedededej                  dz  d&d f d7„«       Zd8„ Zd9ed:ed&efd;„Zd<ej                  d=ej                  d>ej                  d&dfd?„Zd@ej                  d&ej                  fdA„Z dej                  d@ej                  dBej                  d&ej                  fdC„Z!d@ej                  dDed&ej                  fdE„Z"d@ej                  dDed&ej                  fdF„Z#dGej                  dHej                  d&ej                  fdI„Z$d@ej                  dJej                  d&ej                  fdK„Z%d@ej                  dej
                  d&ej                  fdL„Z&y)Nr*   ad  Per-call state for the chunked loop, built once via ``build``.
    Methods hide dtype/device/acc_policy dispatch behind single math ops;
    dispatch-free per-iter math is inlined into the loop body. Buffers
    dispatch decided are not needed are rank-matching empty tensors
    (``when=False`` in ``_make_*``) so the dataclass surface stays uniform.
    r   Únum_batchesÚin_featuresÚnum_classesrD   Úuse_acc_dtypeÚ	acc_dtypeÚweight_chunk_dtypeÚgrad_input_dtypeÚlinear_weight_cast_dtyper7   ÚtargetNÚweightÚignore_indexÚ	reductionr:   Úlinear_biasÚloss_grad_outputÚ
logits_bufÚtmpr"   r   r   r   Úalloc_weight_grad_chunkrR   rN   Úalloc_input_chunk_acc_bufÚalloc_logits_acc_bufr4   r9   rE   r>   rV   Ú weight_grad_uses_logits_buf_tempr2   c                 ó4   — | j                   | j                  k(  S r   )rj   rl   r5   s    r   Ú_maskz_ChunkContext._maskÌ   s   € à�{‰{˜d×/Ñ/Ñ/Ð/r   c                 óÀ   — | j                   dk  s| j                   | j                  k\  r+t        j                  | j                  d| j
                  «      S | j
                  S rH   )rl   rd   r
   Úwhererw   rj   r5   s    r   Úcorrected_targetz_ChunkContext.corrected_targetÐ   sJ   € ð ×Ñ˜qÒ  D×$5Ñ$5¸×9IÑ9IÒ$IÜ—;‘;˜tŸz™z¨1¨d¯k©kÓ:Ð:Ø�{‰{Ðr   c                 ó<  — | j                   }| j                  }| j                  }| j                  }|€| j	                  |«      }nŽ|j                  «       |j                  «       kD  r7t        j                  |d|j	                  |«      j                  d|«      «      }n6t        j                  |d|j                  d|«      j	                  |«      «      }| j                  dk(  rJ|j                  «       }|j                  t        j                  |dk(  t        j                  | «      «       |S | j                  dk(  r|j                  «        |S | j                  �B|j                  «       j                  | j                  j	                  |j                   «      «       |S )Nr   ÚmeanÚsum)rw   rz   rk   rg   rW   Únumelr
   ry   Úindex_selectrm   r}   Údiv_ÚnanÚneg_ro   Úmul_r   )r6   Úmaskrj   rk   rg   Úneg_weight_targetÚds          r   r…   z_ChunkContext.neg_weight_targetØ   si  € ð
 �z‰zˆØ×&Ñ&ˆØ—‘ˆØ!×4Ñ4ÐØˆ>Ø"& §
¡
Ð+=Ó >ÑØ�\‰\‹^˜fŸl™l›nÒ,Ü %§¡Ø�a˜Ÿ™Ð#5Ó6×CÑCÀAÀvÓNó!Ñô !&§¡Ø�a˜×,Ñ,¨Q°Ó7×:Ñ:Ð;MÓNó!Ðð �>‰>˜VÒ#Ø!×%Ñ%Ó'ˆAØ×"Ñ"¤5§;¡;¨q°A©v´u·y±yÀ1À"Ó#EÔFð !Ð ð �^‰^˜uÒ$Ø×"Ñ"Ô$ð !Ð ð	 ×$Ñ$Ð0Ø!×&Ñ&Ó(×-Ñ-Ø×)Ñ)×,Ñ,Ð->×-DÑ-DÓEôð !Ð r   c                 ó–   — | j                   | j                  k7  r%| j                  j                  | j                   «      S | j                  S r   )ri   r   r:   rW   r5   s    r   r;   z _ChunkContext.linear_weight_castü   s=   € à×(Ñ(¨D¯J©JÒ6Ø×%Ñ%×(Ñ(¨×)FÑ)FÓGÐGØ×!Ñ!Ð!r   c                 óì   — | j                   €y | j                   j                  | j                  j                  k7  r/| j                   j                  | j                  j                  «      S | j                   S r   )rn   r   rp   rW   r5   s    r   Úlinear_bias_castz_ChunkContext.linear_bias_cast  s^   € ð ×ÑÐ#ØØ×Ñ×!Ñ! T§_¡_×%:Ñ%:Ò:Ø×#Ñ#×&Ñ& t§¡×'<Ñ'<Ó=Ð=Ø×ÑÐr   c                 óœ   — t        | j                  | j                  f| j                  | j                  j
                  | j                  ¬«      S ©N©r   )r   rd   rc   rf   r7   r   rr   r5   s    r   Úweight_grad_chunkz_ChunkContext.weight_grad_chunk  sB   € ô Ø×Ñ˜t×/Ñ/Ð0Ø�N‰NØ�J‰J×ÑØ×-Ñ-ô	
ð 	
r   c                 ó¶   — t        | j                  j                  d   | j                  f| j                  | j
                  j                  | j                  ¬«      S ©Nr   rŒ   )r   rp   r   rd   rf   r7   r   rt   r5   s    r   rI   z_ChunkContext.logits_acc_buf  sK   € ô Ø�_‰_×"Ñ" 1Ñ% t×'7Ñ'7Ð8Ø�N‰NØ�J‰J×ÑØ×*Ñ*ô	
ð 	
r   c                 ó¶   — t        | j                  j                  d   | j                  f| j                  | j
                  j                  | j                  ¬«      S r�   )r   rp   r   rc   ri   r7   r   rN   r5   s    r   rO   z _ChunkContext.input_grad_acc_buf#  sM   € ô Ø�_‰_×"Ñ" 1Ñ% t×'7Ñ'7Ð8Ø×)Ñ)Ø�J‰J×ÑØ×.Ñ.ô	
ð 	
r   c                 ó¶   — t        | j                  j                  d   | j                  f| j                  | j
                  j                  | j                  ¬«      S r�   )r   rp   r   rc   rf   r7   r   rs   r5   s    r   Úinput_chunk_acc_bufz!_ChunkContext.input_chunk_acc_buf.  sI   € äØ�_‰_×"Ñ" 1Ñ% t×'7Ñ'7Ð8Ø�N‰NØ�J‰J×ÑØ×/Ñ/ô	
ð 	
r   c                 ó˜   — t        | j                  j                  | j                  | j                  j                  | j
                  ¬«      S r‹   )r   r7   r   rh   r   r   r5   s    r   r$   z_ChunkContext.grad_input7  s;   € äØ�J‰J×ÑØ×!Ñ!Ø�J‰J×ÑØ×(Ñ(ô	
ð 	
r   c                 ó˜   — t        | j                  j                  | j                  | j                  j
                  | j                  ¬«      S r‹   )r   r:   r   r   r7   r   r   r5   s    r   r%   z _ChunkContext.grad_linear_weight@  s;   € äØ×Ñ×$Ñ$Ø�J‰JØ�J‰J×ÑØ×0Ñ0ô	
ð 	
r   c                 óž   — t        | j                  j                  d d | j                  | j                  j
                  | j                  ¬«      S ©NéÿÿÿÿrŒ   )r   r:   r   r   r7   r   r   r5   s    r   r&   z_ChunkContext.grad_linear_biasI  sD   € ô
 Ø×Ñ×$Ñ$ S bÐ)Ø�J‰JØ�J‰J×ÑØ×.Ñ.ô	
ð 	
r   c                 óž   — t        | j                  j                  d d | j                  | j                  j
                  | j                  ¬«      S r–   )r   r:   r   rf   r7   r   rR   r5   s    r   rS   z$_ChunkContext.linear_bias_grad_chunkU  sD   € ô Ø×Ñ×$Ñ$ S bÐ)Ø�N‰NØ�J‰J×ÑØ×2Ñ2ô	
ð 	
r   Úlabel_smoothingÚbatch_chunk_sizeÚ
acc_policyc                 ó  — |j                   t        j                  k7  rt        d|j                   › d�«      ‚|dkD  rt	        d«      ‚|dvrt	        d|›�«      ‚|�W|j
                  |j
                  d d k7  r;t        dt        |j
                  d d «      › d	t        |j
                  «      › d�«      ‚|j                  }|j                   }|j
                  \  }}|j
                  \  }}|j                  d
k(  }|j                  dk(  }||k7  rG|t        j                  t        j                  hv r|t        j                  k(  st        d|› d|› d�«      ‚||k7  }|
dv }|r9|t        j                  k(  r|n|}|r|n|}|t        j                  k(  r|r|n|}|}n|x}x}x}}|xr | xs	 |xr ||k(  }|r|n|}|xr |
dk(  xr	 |xs ||k(   } |xr |}!|xr | xr	 ||k7  xs |}"|xr |xs
 | xr ||k7  }#|xr
 | xr ||k7  }$|xr |}%||k(  }&|xr	 |xr ||k7  }'|'xs |xr
 |  xr ||k7  }(| xr
 | xr ||k7  })|  xr# |xr ||j                  z  ||j                  z  k\  }* | d(i d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d |“d!|“d"|“d#t        j                  |	|f||d$¬%«      “d&t        j                  |	f||d$¬%«      “d't        d(||«      “d)|“d*|“d+|“d,| “d-|!“d.|"“d/|#“d0|)“d1|$“d2|%“d3|&“d4|'“d5|(“d6|*“ŽS )7Nz<linear_cross_entropy: target dtype must be torch.int64, got ú.ç        z5linear_cross_entropy does not support label smoothing>   r}   r|   Únoneú0linear_cross_entropy does not support reduction=r—   z1linear_cross_entropy: expected linear_bias shape z, got ÚcudaÚmpszVlinear_cross_entropy supports float32 acc_dtype with float16/bfloat16 inputs, but got z acc_dtype and z inputs.>   ÚcompactÚbalancedr£   r   rb   rc   rd   rD   re   rf   rg   rh   ri   r7   rj   rk   rl   rm   r:   rn   ro   rp   F©r   r   r	   rq   r"   r`   r   r   r   rr   rR   rN   rs   rt   r4   r9   rE   r>   rV   ru   )r   r
   Úint64Ú	TypeErrorÚNotImplementedErrorr   ÚRuntimeErrorÚtupler   ÚtypeÚfloat16Úbfloat16Úfloat32Úitemsizer   r   )+Úclsr7   r:   rj   rn   rk   rm   rl   r™   rš   r›   rf   r   r   r   ro   r   r   rb   rc   rd   r#   rD   Úis_mpsre   Úis_memory_likeÚoutput_dtyperh   Úlogits_buf_dtyperg   Úneeds_linear_weight_castri   rr   rR   rN   rs   r4   r9   rE   r>   rV   rt   ru   s+                                              r   Úbuildz_ChunkContext.buildf  s;  € ð( �<‰<œ5Ÿ;™;Ò&ÜØNÈvÏ|É|ÈnÐ\]Ð^óð ð ˜SÒ Ü%ØGóð ð Ð3Ñ3Ü%ØC¸¸ÐEóð ð Ð" {×'8Ñ'8¸M×<OÑ<OÐPSÐQSÐ<TÒ'TÜØCÜ˜×,Ñ,¨S¨bÐ1Ó2Ð3°6¼%À×@QÑ@QÓ:RÐ9SÐSTðVóð ð
 —‘ˆØ—‘ˆØ#(§;¡;Ñ ˆ�[Ø&×,Ñ,‰ˆ�Qð —+‘+ Ñ'ˆØ—‘ Ñ%ˆà�IÒØ”e—m‘m¤U§^¡^Ð4Ñ4¸ÄeÇmÁmÒ9Säð5Ø5>°K¸ÈuÈgÐU]ð_óð ð  Ñ*ˆð $Ð'>Ð>ˆÙØ(-´·±Ò(>™9ÀEˆLÙ(6™u¸IÐð ¤%§-¡-Ò/±N‘È	ð ð
 "+Ñð ðˆLð Ð+ð Ð.>ÐASð $1ò $
ØˆKÒXÐ.ÒWÐ3CÐGWÑ3Wð 	!ñ !9Ñ¸eð 	!ð #=ò #
Ø˜)Ñ#ÒN¨Ò)MÐ4DÈÑ4MðB
Ðð (@Ò'QÀMÐ$àò IØ�òIà!Ð%=Ñ=ÒGÀð 	!ð
 %2ò %
Ø&ÒU¨w¨;Ò+T¸5ÐDTÑ;Tð 	"ð ÒG '˜kÒG¨eÐ7GÑ.Gð 	ð '.Ò&?°-Ð#Ø$4¸	Ñ$AÐ!ð ÒSÐ*ÒSÐ/?ÐCSÑ/Sð 	"ð
 '@ò '
Ø&ò *Ø+Ð+ò*à  EÑ)ð 	$ð $ÒU¨G¨ÒUÐ8HÈIÑ8Uð 	ð (Ð'ò XØòXàÐ.×7Ñ7Ñ7¸;ÈÏÉÑ;WÑWð 	)ñ ò .
Ùð.
á#ð.
ñ $ð.
ñ $ð	.
ñ
 ð.
ñ (ð.
ñ  ð.
ñ  2ð.
ñ .ð.
ñ &>ð.
ñ ð.
ñ ð.
ñ ð.
ñ &ð.
ñ  ð.
ñ  (ð!.
ñ" $ð#.
ñ$ .ð%.
ô& —{‘{Ø! ;Ð/Ø&ØØ#õ	ð'.
ô2 —‘Ø!Ð#Ø&ØØ#õ	ð3.
ô> ˜r <°Ô8ð?.
ñ@  2ðA.
ñB (BðC.
ñD &>ðE.
ñF %<ðG.
ñH *FðI.
ñJ &>ðK.
ñL '@ðM.
ñN "6ðO.
ñP $:ðQ.
ñR )DðS.
ñT '@ðU.
ñV '@ðW.
ñX )DðY.
ñZ .Nð[.
ð .	
r   c              #   ó6  K  — | j                   j                  d   }t        d| j                  |«      D ]â  }t	        || j                  |z
  «      }| j                  ||«      }|–— | j                  r6| j                  j                  d||«      j                  |j                  «       | j                  sŒ�| j                  j                  |j                  j                  | j                  j                   «      «       |j                  j#                  «        Œä y­w)a¼  Yield a ``_ChunkViews`` per iter. Post-yield, run the
        scratch-to-final commits that the loop body deferred: the
        buf-and-copy input-grad slice into ``grad_input`` (skipped on
        the fast path where ``grad_input_chunk`` aliases
        ``grad_input``), and the acc_dtype linear_bias scratch into
        ``grad_linear_bias`` (skipped when accumulation went straight
        into ``grad_linear_bias`` in input dtype).
        r   N)rp   r   Úrangerb   ÚminÚ
bind_chunkrN   r$   rJ   rK   rP   rR   r&   Úadd_rT   rW   r   Úzero_)r6   rš   r+   r,   Úchunks        r   Úchunksz_ChunkContext.chunks  sñ   è ø€ ð  Ÿ?™?×0Ñ0°Ñ3ÐÜ! ! T×%5Ñ%5Ð7GÓHò 	,ˆLÜÐ.°×0@Ñ0@À<Ñ0OÓPˆKØ—O‘O L°+Ó>ˆEØŠKØ×,Ò,Ø—‘×&Ñ& q¨,¸ÓD×JÑJØ×*Ñ*ôð ×0Ó0ð ×%Ñ%×*Ñ*Ø×'Ñ'×*Ñ*¨4×+@Ñ+@×+FÑ+FÓGôð ×#Ñ#×)Ñ)Õ+ñ	,ùs   ‚B1DÂ4A%Dr+   r,   c           
      ó„  — | j                   j                  d||«      }| j                  j                  d||«      }| j                  j                  d||«      }| j                  j                  dd|«      }| j
                  r,| j                  j                  dd|«      j                  |«      n|}t        | |||||||¬«      S )Nr   )r    r+   r,   r-   r.   r/   r0   r1   )	r7   rJ   rz   r…   rp   rs   r’   rK   r)   )r6   r+   r,   r-   r.   r/   r0   r1   s           r   rº   z_ChunkContext.bind_chunk1  sÅ   € Ø—j‘j×'Ñ'¨¨<¸ÓEˆØ×,Ñ,×3Ñ3°A°|À[ÓQˆØ×-Ñ-×4Ñ4°Q¸ÀkÓRˆØ—‘×'Ñ'¨¨1¨kÓ:ˆð ×-Ò-ð ×$Ñ$×+Ñ+¨A¨q°+Ó>×DÑDÀ[ÔQàð 	ô
 ØØ%Ø#Ø#Ø%Ø%ØØ+ô	
ð 		
r   Úmat1Úmat2Úoutc                ó®   — |j                   |j                   k(  rt        j                  |||¬«       y t        j                  |||j                   |¬«       y )N©rÂ   )Ú	out_dtyperÂ   )r   r
   Úmm)r6   rÀ   rÁ   rÂ   s       r   rÆ   z_ChunkContext.mmF  s8   € à�:‰:˜Ÿ™Ò"Ü�H‰H�T˜4 SÖ)ä�H‰H�T˜4¨3¯9©9¸#Ö>r   Úxc                 óª   — | j                   j                  dd|j                  d   «      j                  d«      }t	        j
                  |dd|¬«       |S )Nr   é   T)ÚdimÚkeepdimrÂ   )rq   rJ   r   Ú	unsqueezer
   Úamax)r6   rÇ   rÂ   s      r   rÍ   z_ChunkContext.amaxM  sB   € Ø�h‰h�o‰o˜a  A§G¡G¨A¡JÓ/×9Ñ9¸!Ó<ˆÜ�
‰
�1˜! T¨sÕ3Øˆ
r   Úindicesc                 ó²   — |j                  |j                  d|j                  d«      «      j                  d«      j	                  |j
                  «      «      S )NrÉ   )ÚdotÚgatherrÌ   ÚsqueezerW   r   )r6   rk   rÇ   rÎ   s       r   Ú	dotgatherz_ChunkContext.dotgatherR  sC   € ð �z‰z˜!Ÿ(™( 1 g×&7Ñ&7¸Ó&:Ó;×CÑCÀAÓF×IÑIÈ&Ï,É,ÓWÓXÐXr   rÊ   c                 óX   — |j                  «       j                  || j                  ¬«      S ©N©r   )Úexp_r}   rf   )r6   rÇ   rÊ   s      r   Úsumexp_z_ChunkContext.sumexp_W  s!   € ð �v‰v‹x�|‰|˜C t§~¡~ˆ|Ó6Ð6r   c                 óp   — | j                   r| j                  n| j                  }|j                  ||¬«      S rÕ   )re   rf   r   r}   )r6   rÇ   rÊ   Útarget_dtypes       r   r}   z_ChunkContext.sum]  s.   € ð *.×);Ò);�t—~’~ÀÇÁˆØ�u‰u�S ˆuÓ-Ð-r   ÚnumÚdenc                 ó`  — | j                   j                  dd|j                  d   «      }| j                  j                  j
                  dk(  rH|j                  |j                  k7  s|j                  |j                  k7  r|j                  ||z  «       |S t        j                  |||¬«       |S )Nr   r¢   rÄ   )
rq   rJ   r   r7   r   r«   r   rK   r
   Údiv)r6   rÛ   rÜ   Úfactors       r   rÞ   z_ChunkContext.divg  s…   € Ø—‘—‘  A s§y¡y°¡|Ó4ˆà�:‰:×Ñ×!Ñ! UÒ*Ø�I‰I˜Ÿ™Ò%¨¯©°f·l±lÒ)Bà�L‰L˜˜s™Ô#ð ˆô �I‰I�c˜3 FÕ+Øˆr   Úwc           
      óˆ  — | j                   r |j                  |j                  d«      «      S | j                  | j                  k\  rjt        j                  ||j                  d«      | j                  j                  dd|j                  d   «      j                  dd| j                  «      ¬«      S ||j                  d«      z  S )NrÉ   r   rÄ   )
re   rƒ   rÌ   rd   rc   r
   Úmulrp   rJ   r   )r6   rÇ   rà   s      r   râ   z_ChunkContext.mulr  s    € à×ÒØ—6‘6˜!Ÿ+™+ a›.Ó)Ð)Ø×Ñ˜t×/Ñ/Ò/Ü—9‘9ØØ—‘˜A“Ø—O‘O×*Ñ*¨1¨a°·±¸±Ó<×CÑCØ�q˜$×*Ñ*óôð ð �1—;‘;˜q“>Ñ!Ð!r   c                ó.  — |j                   |k(  r|S | j                  rh| j                  j                  |«      j	                  dd|j
                  d   «      j	                  dd|j
                  d   «      j                  |«      }|S |j                  |«      S )Nr   rÉ   )r   ru   rp   ÚviewrJ   r   rK   rW   )r6   rÇ   r   s      r   rW   z_ChunkContext.to€  s}   € à�7‰7�eÒØˆHØ×0Ò0à—‘×$Ñ$ UÓ+ß‘˜˜1˜aŸg™g a™jÓ)ß‘˜˜1˜aŸg™g a™jÓ)ß‘�q“ð	 ð ˆHØ�t‰t�E‹{Ðr   r   )'rX   rY   rZ   r[   r
   r   r\   r]   Úboolr^   Ústrr   rw   rz   r…   r;   r‰   r�   rI   rO   r’   r$   r%   r&   rS   ÚclassmethodÚfloatr¶   r¾   r)   rº   rÆ   rÍ   rÓ   rØ   r}   rÞ   râ   rW   r`   r   r   r*   r*   •   s  … ñð �;‰;ÓØÓØÓØÓØƒMØÓà�{‰{ÓØŸ™Ó#Ø—k‘kÓ!Ø#Ÿk™kÓ)à�<‰<ÓØ�L‰LÓØ�L‰L˜4ÑÓØÓØƒNØ—<‘<ÓØ—‘ Ñ$Ó$ð —l‘l TÑ)Ó)ð
 —‘ÓØ	�‰ÓØ�L‰LÓàÓØ $Ó$Ø"Ó"Ø!Ó!Ø"&Ó&Ø"Ó"Ø#Ó#ØÓØ Ó Ø!%Ó%Ø#Ó#Ø#Ó#Ø!%Ó%Ø&*Ó*àð0�u—|‘|ò 0ó ð0ð ð %§,¡,ò ó ðð ð!! 5§<¡<ò !!ó ð!!ðF ð" E§L¡Lò "ó ð"ð
 ð	  %§,¡,°Ñ"5ò 	 ó ð	 ð ð
 5§<¡<ò 
ó ð
ð ð
 §¡ò 
ó ð
ð ð
 E§L¡Lò 
ó ð
ð ð
 U§\¡\ò 
ó ð
ð ð
˜EŸL™Lò 
ó ð
ð ð
 E§L¡Lò 
ó ð
ð ð	
 %§,¡,ò 	
ó ð	
ð ð
¨¯©ò 
ó ð
ð  ð" 15ñ!n
à�|‰|ðn
ð —|‘|ðn
ð —‘ð	n
ð
 —\‘\ DÑ(ðn
ð —‘˜tÑ#ðn
ð ðn
ð ðn
ð ðn
ð ðn
ð ðn
ð —;‘;ðn
ð !ðn
ð %)ðn
ð #'ðn
ð   Ÿ,™,¨Ñ-ð!n
ð" 
ò#n
ó ðn
ò`,ð4
 sð 
¸ð 
Àó 
ð*?�u—|‘|ð ?¨5¯<©<ð ?ÀÇÁð ?ÐRVó ?ð�e—l‘lð  u§|¡|ó ð
YØ—l‘lðYØ',§|¡|ðYØ>C¿l¹lðYà	�‰óYð
7˜Ÿ™ð 7¨Cð 7°E·L±Ló 7ð.�U—\‘\ð .¨ð .°·±ó .ð	�u—|‘|ð 	¨%¯,©,ð 	¸5¿<¹<ó 	ð"�U—\‘\ð " e§l¡lð "°u·|±|ó "ð�E—L‘Lð ¨E¯K©Kð ¸E¿L¹Lô r   r*   r7   r:   rj   rn   rk   rm   rl   r™   rš   r›   rf   r   r   r   ro   r2   c                 óJ  — |	dk(  s|
€t        d|	›d|
›d�«      ‚t        j                  | |||||||||	|
||||¬«      }|j                  }|dk(  �rï|�€ì|j                  }t        j                  |j                  ||j                  j                  ¬«      }|j                  «       D �]c  }|j                  }|j                  |j                  |j                  j                  |¬«       |�|j                  |«       |j!                  |j#                  |«      «       |j%                  d	|j&                  j)                  d	«      «      j+                  d	«      }|j-                  |d	¬
«      }|j/                  «       j!                  |j1                  |j                  «      «      }|j3                  |j4                  j1                  |j                  «      «       |j7                  d|j8                  |j:                  «      j=                  |«       �Œf ||j>                  j1                  |«      |j@                  |jB                  fS |jD                  }|j>                  }|j@                  }|jB                  }|jF                  }|jH                  }|j                  }|dk(  r.|j                  dk(  r|jK                  t
        jL                  «       |xs |xs |}|j                  «       D �]  }|j                  }|j4                  }|j&                  } |j                  |j                  |j                  j                  |¬«       |�|j                  |«       |j!                  |j#                  |«      «       |j                  |jO                  ||| «      «       |j-                  |d	¬
«      }|r7t        jP                  ||jS                  ||«      j)                  d	«      |¬«       |j!                  |j1                  |j                  «      jU                  |j/                  «       «      «       |s�ŒF|rA|jV                  }!|!j!                  |jY                  |d¬
«      «       |!j[                  d| |«       |r“|j\                  }"|j^                  }#|j`                  }$t        jP                  t        jb                  |d| «      |j1                  |"j                  «      j)                  d	«      |"¬«       t        jd                  |"|#|$d|"¬«       |s�Œ"|jf                  }%|jh                  rp|jj                  }&|jl                  }'|j                  |&j                  |'|¬«       |jQ                  |%|«      }(|j[                  d| |(d¬«       |j!                  |«       �Œª|jo                  |jp                  j                  |jr                  d¬«       |j1                  |jQ                  |%|«      |j                  ¬«      }(|j[                  d| |(d	¬«       �Œ  |j1                  |«      |j1                  |«      ||fS )aE
  Chunked loop shared by all three custom-op entry points; returns
    ``(loss, grad_input, grad_linear_weight, grad_linear_bias)``.

    Caller -> branch:
      scalar-op forward (reduction in {mean,sum})  -> main grad loop
      no_reduction forward (none, loss_grad_output None) -> loss-only branch
      no_reduction backward (none, loss_grad_output set) -> main grad loop

    - ``_linear_cross_entropy_batch_chunked`` (scalar reduction): the
      forward precomputes the scalar loss and all gradients in one pass;
      backward just scales the stashed grads by the upstream gradient.
    - ``_linear_cross_entropy_batch_chunked_no_reduction`` (forward):
      ``reduction='none'`` with ``loss_grad_output is None`` takes the
      loss-only branch, returning the per-sample loss ``(N,)`` and no
      gradients (they are recomputed in its backward instead).
    - ``_linear_cross_entropy_batch_chunked_no_reduction`` (backward):
      ``loss_grad_output`` set folds the per-sample upstream grad into
      ``neg_weight_target``, so this same loop recomputes the chunked
      grads as the grad_output-weighted VJP (the scalar loss it also
      accumulates is then meaningless and ignored).

    Dispatch contract
    -----------------
    The chunked loop body is the mathematical description of the
    algorithm. All policy / device / dtype dispatch lives in
    ``_ChunkContext`` (and its ``_ChunkViews`` peers):

    - **Buffer choices** -- whether a per-chunk acc_dtype scratch is
      used or accumulation runs directly into the final tensor -- live
      in ``alloc_*`` flags computed in ``_ChunkContext.build`` and
      surfaced as ``_ChunkViews`` properties (e.g.
      ``grad_input_chunk``, ``bias_grad_acc``).
    - **Scratch-to-final commits** for those buffers live in
      ``_ChunkContext.chunks()`` post-yield hooks (e.g. the
      ``grad_input`` buf-and-copy commit, the ``grad_linear_bias``
      downcast-and-zero commit).
    - **Dtype dispatch on individual math operations** lives in
      ``_ChunkContext`` methods that mirror PyTorch ops --
      ``mm``, ``amax``, ``dotgather``, ``sumexp_``, ``sum``, ``div``,
      ``mul``, ``to`` -- each one hiding ``out_dtype=`` / acc-dtype /
      buffer-reuse decisions behind a single math call.

    The function body therefore should not introduce inline
    ``if ctx.use_acc_dtype`` / ``if ctx.is_cuda`` / etc. branches; new
    policy-aware behaviour belongs in one of the three locations
    above. The two existing inline branches (``if compute_input_grad``,
    ``if compute_linear_weight_grad``, etc.) gate optional outputs,
    not dispatch.
    Úautozunresolved acc_policy=z or acc_dtype=z; use F.linear_cross_entropy.©ro   rŸ   ©r   r   rÄ   rÉ   )rÊ   r   r|   r—   )ÚalpharÂ   )rí   rÖ   ):r©   r*   r¶   r   r‰   r
   r   rb   r7   r   r¾   r0   rÆ   r:   ÚTr»   Úsub_rÍ   rÑ   r.   rÌ   rÒ   rØ   Úlog_rW   rƒ   r/   rJ   r+   r,   rK   r$   r%   r&   r"   r�   r;   Úfill_r�   rÓ   râ   rÞ   rÐ   rT   r}   Ú
index_add_rP   r@   rB   r   Úaddmmr1   rr   rL   rF   Úaddmm_r?   r-   ))r7   r:   rj   rn   rk   rm   rl   r™   rš   r›   rf   r   r   r   ro   r    r   r‰   rÂ   r½   r0   Ú	ls_targetÚsoftmax_denomÚ
loss_chunkr"   r$   r%   r&   r�   r;   Úcompute_gradsr/   r.   rT   rP   r@   rB   r1   rL   rF   Útemps)                                            r   Ú/_linear_cross_entropy_batch_chunked_accumulatorrú   �  sš  € ðF �VÒ˜yÐ0ÜØ$ Z N°.ÀÀð N+ð +ó
ð 	
ô ×
Ñ
ØØØØØØØØØØØØØ"Ø Ø)ð ó €Cð" �I‰I€Eð �FÓÐ/Ñ7Ø×/Ñ/ÐÜ�k‰k˜#Ÿ/™/°¸s¿y¹y×?OÑ?OÔPˆØ—Z‘Z“\ó 	SˆEØ—\‘\ˆFØ�F‰F�5—;‘; × 3Ñ 3× 5Ñ 5¸6ˆFÔBØÐ+Ø—‘Ð,Ô-Ø�K‰K˜Ÿ™ Ó(Ô)ð Ÿ™ a¨×);Ñ);×)EÑ)EÀaÓ)HÓI×QÑQÐRSÓTˆIØŸK™K¨°A˜KÓ6ˆMØ&×+Ñ+Ó-×2Ñ2°9·<±<À×@SÑ@SÓ3TÓUˆJØ�O‰O˜E×.Ñ.×1Ñ1°-×2EÑ2EÓFÔGØ�J‰J�q˜%×,Ñ,¨e×.?Ñ.?Ó@×FÑFÀzÖRð	Sð Ø�N‰N×Ñ˜eÓ$Ø×"Ñ"Ø× Ñ ð	
ð 	
ð �Z‰Z€FØ—‘€JØ×/Ñ/ÐØ×+Ñ+ÐØ×-Ñ-ÐØ×/Ñ/ÐØ×+Ñ+Ðà�FÒ˜sŸ™°!Ò3Ø�‰”U—Y‘YÔð 	ÒTÐ8ÒTÐ<Tð ð —‘“ó bRˆØ—‘ˆØ×)Ñ)ˆØ×)Ñ)ˆà�‰ˆu�{‰{˜E×/Ñ/×1Ñ1°vˆÔ>ØÐ'Ø�K‰KÐ(Ô)Ø�‰�C—H‘H˜VÓ$Ô%à�‰�C—M‘M ,°¸ÓEÔFØŸ™ F°˜Ó2ˆÙô �I‰IØØ—‘˜ mÓ4×>Ñ>¸qÓAØõð 	�‰�L—O‘O M×$7Ñ$7Ó8×<Ñ<¸]×=OÑ=OÓ=QÓRÔSãÙ'ð* !&× 3Ñ 3�Ø×"Ñ" 3§7¡7¨6°q 7Ó#9Ô:Ø×(Ñ(¨¨L¸,ÔGÙ!Ø#(×#9Ñ#9Ð Ø$)×$;Ñ$;Ð!Ø+0×+IÑ+IÐ(ô —	‘	Ü×&Ñ&Ð'9¸1¸lÓKØ —O‘OÐ$4×$:Ñ$:Ó;×EÑEÀaÓHØ(õô —‘Ø$Ø%Ø,ØØ(õó *Ø"'×"7Ñ"7�ð ×.Ò.ð %*×$7Ñ$7�MØ(-×(?Ñ(?Ð%Ø—F‘FØ%Ÿ™Ø)Ø-ð ô ð
 Ÿ7™7 ?°LÓA�DØ%×0Ñ0°°LÀ$ÈbÐ0ÔQØ&×+Ñ+Ð,=Ö>ð '×-Ñ-Ø×-Ñ-×/Ñ/°×1BÑ1BÈ"ð .ô ð Ÿ6™6ØŸ™ °Ó>Ø0×6Ñ6ð "ó �Dð '×1Ñ1°!°\À4ÈqÐ1ÖQðEbRðJ 	�	‰	�%ÓØ�‰�eÓØØð	ð r   z-torch_nn::_linear_cross_entropy_batch_chunkedr`   )Úmutates_argsr   c                 ó   — t        j                  «       }|s| j                  r|rt        d«      ‚|s|j                  r|rt        d«      ‚|s|�|j                  r|rt        d«      ‚t	        | |||||||||	|
|||«      S )zÜScalar-reduction (mean/sum) chunked op: precomputes the loss and
    gradients in forward, backward scales by the upstream gradient. The
    chunked math lives in ``_linear_cross_entropy_batch_chunked_accumulator``.
    z«linear_cross_entropy chunked op: compute_input_grad was False at trace time but input.requires_grad is True at runtime; recompile the graph with the desired requires_grad.z»linear_cross_entropy chunked op: compute_linear_weight_grad was False at trace time but linear_weight.requires_grad is True at runtime; recompile the graph with the desired requires_grad.z·linear_cross_entropy chunked op: compute_linear_bias_grad was False at trace time but linear_bias.requires_grad is True at runtime; recompile the graph with the desired requires_grad.)r
   Úis_grad_enabledr	   r©   rú   )r7   r:   rj   rn   rk   rm   rl   r™   rš   r›   rf   r   r   r   r   Úgrad_enableds                   r   Ú#_linear_cross_entropy_batch_chunkedrÿ   �  sµ   € ô: ×(Ñ(Ó*€LÙ %×"5Ò"5¹,Üð8ó
ð 	
ñ
 &¨-×*EÒ*EÉ,ÜðKó
ð 	
ñ %ØÐ#Ø×%Ò%Ùäð8ó
ð 	
ô
 ;ØØØØØØØØØØØØØ"Ø óð r   é   c                 ó   — |dv r-t        j                  d| j                  | j                  ¬«      }nt	        d|›�«      ‚|r| j
                  nd}|r|j
                  nd}|r|j
                  d d nd}t        j                  || j                  | j                  d¬	«      }t        j                  || j                  |j                  d¬	«      }t        j                  || j                  | j                  d¬	«      }||||fS )
N>   r}   r|   r`   rì   r    )r   r   r—   r   Fr¥   )r
   r   r   r   r¨   r   )r7   r:   rj   rn   rk   rm   rl   r™   rš   r›   rf   r   r   r   r   ÚresultÚgrad_input_shapeÚgrad_linear_weight_shapeÚgrad_linear_bias_shaper$   r%   r&   s                         r   r#   r#   Ú  s÷   € ð$ �OÑ#Ü—‘˜R u§{¡{¸5¿<¹<ÔH‰ä!Ð$UÈ9È,Ð"WÓXÐXÙ&8�u—{’{¸fÐá9ˆ×Ò¸vð ñ %=ˆ×Ñ˜C˜RÑ À$ð ô —‘ØØ�k‰kØ�|‰|Øô	€Jô Ÿ™Ø Ø�k‰kØ×#Ñ#Øô	Ðô —{‘{ØØ�k‰kØ�|‰|Øô	Ðð �:Ð1Ð3CÐCÐCr   c                 ó   — | j                   }t        ||«      D ��cg c]5  \  }}|�,t        |t        j                  «      r|j                  |d«      n|‘Œ7 }}}t        |«      D ���cg c]H  }t        t        ||«      D ��cg c](  \  }}|�t        |t        j                  «      r||   n|‘Œ* c}}Ž ‘ŒJ }}}}t        j                  |D �	cg c]  }	|	d   ‘Œ	 c}	«      }
t        j                  |D �	cg c]  }	|	d   ‘Œ	 c}	«      }t        j                  |D �	cg c]  }	|	d   ‘Œ	 c}	«      }t        j                  |D �	cg c]  }	|	d   ‘Œ	 c}	«      }|
|||fdfS c c}}w c c}}w c c}}}w c c}	w c c}	w c c}	w c c}	w )zëvmap rule (slow path: per-sample Python loop). A fold-into-num_batches
    fast path is now possible for both ops via the reduction='none' chunked op
    (``_linear_cross_entropy_batch_chunked_no_reduction``); left as a follow-up.
    r   rÉ   é   é   )r   r   r   r   )	Ú
batch_sizeÚzipÚ
isinstancer
   r^   Úmovedimr¸   rÿ   Ústack)ÚinfoÚin_dimsÚargsr	  ÚargÚin_dimÚ
moved_argsÚiÚoutputsÚoÚlossesÚgrad_inputsÚgrad_linear_weightsÚgrad_linear_biasess                 r   Ú_vmapr    s{  € ð —‘€Jô ˜t WÓ-÷	ñ ˆC�ð Ð¤*¨S´%·,±,Ô"?ð 	�‰�F˜AÔàñ	ð€Jñ ô �zÓ"÷ð ð ô 	,ô $' z°7Ó#;÷á�C˜ð !Ð,´¸CÄÇÁÔ1N��A’ÐTWÑWóò	
ð€Gò ô �[‰[¨Ö0 1˜!˜A›$Ò0Ó1€FÜ—+‘+¨WÖ5¨˜q ›tÒ5Ó6€KÜŸ+™+°WÖ&=° q¨£tÒ&=Ó>ÐÜŸ™°GÖ%<¨q a¨£dÒ%<Ó=ÐØ�KÐ!4Ð6HÐIÈ<ÐWÐWùó)ùóùôùò 1ùÚ5ùÚ&=ùÚ%<s5   œ:EÁ(E%Â-EÂ.E%ÃE,Ã2E1ÄE6Ä>E;ÅE%c                 ó€  — d gt         z  }| j                  rT| j                  r| j                  |z  |d<   n5| j                  d c}| _        |€t	        d«      ‚|j                  |«      |d<   | j                  rT| j                  r| j                  |z  |d<   n5| j                  d c}| _        |€t	        d«      ‚|j                  |«      |d<   | j                  r^| j                  r| j                  |z  |d<   t        |«      S | j                  d c}| _	        |€t	        d«      ‚|j                  |«      |d<   t        |«      S )Nr   zjlinear_cross_entropy chunked backward called twice; retain_graph=True / double backward are not supported.rÉ   r  )Ú_NUM_OP_INPUTSr   r   r   r©   rƒ   r   r   r   r   rª   )	r    Úgrad_outputÚ_gi_gradÚ_gw_gradÚ_gb_gradr  ÚgiÚgwÚgbs	            r   Ú,_linear_cross_entropy_batch_chunked_backwardr%  4  sM  € ð ˆV”nÑ$€FØ
×ÒØ×!Ò!ØŸ™ +Ñ-ˆF�1ŠIàŸ'™' 4ˆKˆB�”ØˆzÜ"ðMóð ð Ÿ™ Ó,ˆF�1‰Ià
×%Ò%Ø×!Ò!ØŸ™ +Ñ-ˆF�1ŠIàŸ'™' 4ˆKˆB�”ØˆzÜ"ðMóð ð Ÿ™ Ó,ˆF�1‰Ið ×#Ò#Ø×!Ò!ØŸ™ +Ñ-ˆF�1‰Iô �‹=Ðð Ÿ'™' 4ˆKˆB�”ØˆzÜ"ðMóð ð Ÿ™ Ó,ˆF�1‰IÜ�‹=Ðr   )Úsetup_contextz:torch_nn::_linear_cross_entropy_batch_chunked_no_reductionc	                 ó:   — t        | ||||d|d|||ddd¬«      d   S )aC  reduction='none' chunked forward: returns per-sample loss ``(N,)``.

    Gradients are not precomputed (the per-sample upstream grad is
    unknown at forward); the accumulator's loss-only branch runs here,
    and the backward recomputes the chunked grads. See
    ``_linear_cross_entropy_batch_chunked_accumulator``.
    rŸ   rž   F)r   r   r   r   )rú   ©	r7   r:   rj   rn   rk   rl   rš   r›   rf   s	            r   Ú0_linear_cross_entropy_batch_chunked_no_reductionr)  p  sE   € ô. ;ØØØØØØØØØØØØ Ø#(Ø!&ôð ñ	ð 	r   c           	      óþ   — |\	  }}}}}}}	}
}| j                  |j                  «       |j                  «       ||�|j                  «       nd |�|j                  «       nd «       || _        |	| _        |
| _        || _        y r   )Úsave_for_backwardr   Ú_ignore_indexÚ_batch_chunk_sizeÚ_acc_policyÚ
_acc_dtype)r    r!   r"   r7   r:   rj   rn   rk   rl   rš   r›   rf   s               r   Ú>_linear_cross_entropy_batch_chunked_no_reduction_setup_contextr0  ™  s’   € ð 	ñ
ØØØØØØØØØð ×ÑØ�‰‹Ø×ÑÓØØ +Ð 7ˆ×ÑÔ¸TØ!Ð-ˆ�‰Œ°4ôð %€CÔØ,€CÔØ €C„OØ€C…Nr   c	                 óv   — t        j                  | j                  d d | j                  | j                  d¬«      S )NrÉ   Fr¥   )r
   r   r   r   r   r(  s	            r   r#   r#   ¹  s0   € ô �;‰;Ø�‰�B�Qˆ˜uŸ{™{°5·<±<Èuôð r   c                 óÆ  — | j                   }t        ||«      D ��cg c]5  \  }}|�,t        |t        j                  «      r|j                  |d«      n|‘Œ7 }}}t        |«      D ���cg c]H  }t        t        ||«      D ��cg c](  \  }}|�t        |t        j                  «      r||   n|‘Œ* c}}Ž ‘ŒJ }}}}t        j                  |«      dfS c c}}w c c}}w c c}}}w )zvmap rule (slow path: per-sample Python loop, mirrors the
    scalar-reduction op). Stacks the per-sample ``(N,)`` losses.
    r   )	r	  r
  r  r
   r^   r  r¸   r)  r  )	r  r  r  r	  r  r  r  r  r  s	            r   Ú_vmap_no_reductionr3  Ê  sõ   € ð
 —‘€Jô
 ˜t WÓ-÷	ñ ˆC�ð Ð¤*¨S´%·,±,Ô"?ð 	�‰�F˜AÔàñ	ð€Jñ ô �zÓ"÷ð ð ô 	9ô $' z°7Ó#;÷á�C˜ð !Ð,´¸CÄÇÁÔ1N��A’ÐTWÑWóò	
ð€Gò ô �;‰;�wÓ Ð"Ð"ùóùóùôs   œ:CÁ(CÂ-CÂ.CÃCc                 ód  — | j                   \  }}}}}| j                  }|d   }|d   }	|d uxr |d   }
d gdz  }|s|	s|
st        |«      S t        |||||d| j                  d| j
                  | j                  | j                  ||	|
|¬«      \  }}}}|r||d<   |	r||d<   |
r||d<   t        |«      S )Nr   rÉ   r  é	   rŸ   rž   rë   )Úsaved_tensorsÚneeds_input_gradrª   rú   r,  r-  r.  r/  )r    r  r7   r:   rj   rn   rk   Úneedsr   r   r   r  r#   r$   r%   r&   s                   r   Ú9_linear_cross_entropy_batch_chunked_no_reduction_backwardr9  â  sõ   € ð 9<×8IÑ8IÑ5€Eˆ=˜& +¨vØ× Ñ €EØ˜q™ÐØ!& q¡ÐØ*°$Ð6ÒC¸5À¹8ÐØ)-¨°©
€FáÑ8Ñ<Tä�V‹}Ðô 	8ØØØØØØØ×ÑØØ×!Ñ!Ø�O‰OØ�N‰NØØ&Ø$Ø(ô	
ñ 8€A€zÐ%Ð'7ñ& Øˆˆq‰	Ù!Ø&ˆˆq‰	ÙØ$ˆˆq‰	Ü�‹=Ðr   )Tr   )!ÚdataclassesÚ	functoolsr   r
   Ú__all__r   r   r'   Ú	dataclassr)   r*   r^   ræ   r]   rè   r   rå   rª   rú   ÚlibraryÚ	custom_oprÿ   r  Úregister_faker#   Úregister_vmapr  r%  Úregister_autogradr)  r0  r3  r9  r`   r   r   ú<module>rC     s  ðÛ Ý %ã ð €óóòNð4 ×Ñ÷Zð Zó ðZðz ×Ñ÷vð vó ðvðP -1ñpØ�<‰<ðpà—<‘<ðpð �L‰Lðpð —‘ Ñ$ð	pð
 �L‰L˜4Ñðpð ðpð ðpð ðpð ðpð ðpð �{‰{ðpð ðpð !%ðpð #ðpð —l‘l TÑ)ðpð  ˆ5�<‰<˜Ÿ™ u§|¡|°U·\±\ÐAÑBó!pð| ‡�×ÑØ3À"ð ó ðAØ�<‰<ðAà—<‘<ðAð �L‰LðAð —‘ Ñ$ð	Að
 �L‰L˜4ÑðAð ðAð ðAð ðAð ðAð ðAð �{‰{ðAð ðAð ðAð !%ðAð #ðAð  ˆ5�<‰<˜Ÿ™ u§|¡|°U·\±\ÐAÑBò!AóðAðN €ð %×2Ñ2ð7Dð ò7Dó 3ð7Dðt %×2Ñ2ñXó 3ðXò<(ðV $× 5Ñ 5Ø0ØCð 6ô ð" ‡�×ÑØ@Èrð ó ð#	Ø�<‰<ð#	à—<‘<ð#	ð �L‰Lð#	ð —‘ Ñ$ð	#	ð
 �L‰L˜4Ñð#	ð ð#	ð ð#	ð ð#	ð �{‰{ð#	ð ‡\�\ò#	óð#	òLð@ 2×?Ñ?ðð òó @ðð  2×?Ñ?ñ#ó @ð#ò.+ð\ 1× BÑ BØ=ØPð Cõ r   