Ë
    ÄÓ^j�a  ã                   óÌ  — d dl Z d dlmZ d dlZd dlmZ d dlmc m	Z
 d dlmc mZ d dlmZ d dlmZ d dlmZmZmZmZ d dlmZmZ d dlmZ d dlmZmZmZ d d	lm Z  d d
l!m"Z" ejF                  jH                  Z$dgZ%e jL                  d„ «       Z'de(e"df   de)de)fd„Z*de(e"df   dedefd„Z+dejX                  jZ                  de(e.df   de/e0e.f   defd„Z1d„ Z2dejX                  jZ                  de(e.df   de/e0e.f   de.fd„Z3dejX                  jZ                  de(e.df   de/e0e.f   de.fd„Z4dedededz  dedz  de)d e)d!ejj                  d"e)ded#e)de(eef   fd$„Z6dejX                  jZ                  de(e.df   de/e0e.f   de.fd%„Z7d&ededededz  de)d e)d'ed!ejj                  d"e)ded#e)defd(„Z8dejX                  jZ                  de(e.df   de/e0e.f   de.fd)„Z9e$jd                  jt                  e3e$jv                  jt                  e4e$jx                  jt                  e7e$jz                  jt                  e7e$j|                  jt                  e9e$j~                  jt                  e9iZ@d*„ ZAd+„ ZBy),é    N)Úcast)ÚTensor)Ú
DeviceMesh)ÚDTensorÚPartialÚ	ReplicateÚShard)ÚDTensorSpecÚ
TensorMeta)Ú_MaskPartial)Ú	_skip_dimÚ	ReductionÚreplicate_reduction_dims)Únormalize_dim)Ú	PlacementÚloss_parallelc               #   ó<   K  — t        «        d–— t        «        y­w)uz  
    A context manager that enables loss parallelism, where efficient parallelized loss computation
    can be performed when the input is sharded on the class dimension. Currently only the cross-entropy
    loss is supported.

    Within this context manager, one can use :func:`~torch.nn.functional.cross_entropy` or
    :class:`~torch.nn.CrossEntropyLoss` as usual, with the following assumptions on the input parameters.
    The corresponding ``backward()`` call, if any, also needs to happen under this context manager.

    Both one-dimensional and multi-dimensional ``DeviceMesh`` are supported. On a
    multi-dimensional mesh, exactly one mesh dim must shard the class dimension â€”
    that dim is treated as the "TP" dim and can be in any position (not necessarily
    last). The remaining mesh dims may be ``Shard`` (e.g. batch-sharded for DP/CP)
    or ``Replicate``.

    Args:
        input (:class:`DTensor`):
            Input logits. Assumed to be sharded on the class dimension on exactly
            one mesh dim.
        target (Union[:class:`torch.Tensor`, :class:`DTensor`]):
            Must be ground truth class indices (class probabilities currently not
            supported). Its placements are derived from ``input``'s placements by
            (1) replacing the TP dim's ``Shard(class_dim)`` with ``Replicate`` and
            (2) shifting any other ``Shard(d)`` with ``d > class_dim`` down by one
            (since the class tensor dim is removed from the output)::

                input tensor shape       input placements             target shape      target placements
                ----------------------   --------------------------   ---------------   ------------------------
                (batch, class)           (Shard(0), Shard(1))         (batch,)          (Shard(0), Replicate())
                (batch, class)           (Replicate(), Shard(1))      (batch,)          (Replicate(), Replicate())
                (batch, class, seq)      (Shard(2), Shard(1))         (batch, seq)      (Shard(1), Replicate())
                (batch, class, seq)      (Shard(0), Shard(1))         (batch, seq)      (Shard(0), Replicate())

            A plain :class:`torch.Tensor` is only accepted when the derived target
            placements are all ``Replicate`` (e.g. on a one-dimensional mesh);
            otherwise a :class:`DTensor` must be passed explicitly so that the
            intended sharding is unambiguous.
        weight (Union[:class:`torch.Tensor`, :class:`DTensor`], optional):
            If given, assumed to be replicated across the ``DeviceMesh``.
        label_smoothing:
            Currently not supported.

    Returns:
        A :class:`DTensor` whose placements depend on ``reduction``:

        - ``reduction="none"`` â€” per-sample loss; inherits the ``target``
          placements (``Shard`` on batch-parallel dims, ``Replicate`` on TP).
        - ``reduction="sum"`` â€” scalar; ``Replicate`` on the TP dim (the custom
          all-reduce makes each rank's local value globally correct over TP),
          ``Partial("sum")`` on every other ``Shard`` mesh dim so that the
          cross-rank reduction happens lazily on materialization/redistribution,
          and ``Replicate`` on ``Replicate`` mesh dims.
        - ``reduction="mean"`` â€” only supported on a one-dimensional mesh; returns
          a fully replicated :class:`DTensor`.

        On a one-dimensional mesh all three cases simplify to a fully replicated
        :class:`DTensor` (the original behavior).

    .. note::
        ``reduction="mean"`` is only supported on a one-dimensional ``DeviceMesh``.
        On a multi-dimensional mesh the per-rank division by ``total_weight`` uses a
        local count, so aggregating across non-TP dims does not yield the correct
        global mean; use ``reduction="sum"`` or ``"none"`` instead and divide by the
        global count yourself if needed.

    Example:
        A sharded DTensor is manually created here to showcase the usage.
        In practice, it is usually the output of a TP module.

        >>> # xdoctest: +SKIP("distributed")
        >>> from torch.distributed.tensor.parallel import loss_parallel
        >>> from torch.distributed.device_mesh import init_device_mesh
        >>> ...
        >>> device_mesh = init_device_mesh("cuda", (8,))
        >>> input = torch.randn(4, 16, device="cuda", requires_grad=True)
        >>> dist_input = distribute_tensor(input, device_mesh, placements=[Shard(1)])
        >>> target = torch.randint(16, (4,), device="cuda")
        >>> with loss_parallel():
        >>>     loss = F.cross_entropy(dist_input, target, reduction="mean")
        >>>     loss.backward()
        >>> ...
    N)Ú_enable_custom_loss_opsÚ_disable_custom_loss_ops© ó    úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/distributed/tensor/parallel/loss.pyr   r      s   è ø€ ôh Ôã	äÕùó   ‚Ú
placements.ÚdimÚreturnc           
      ój  — t        | «      D ��cg c]  \  }}|j                  |«      sŒ|‘Œ }}}t        |«      dk7  rt        d|› d| › dt        |«      › d�«      ‚|d   }t        | «      D ]>  \  }}||k(  rŒ|j                  «       rŒ|j	                  «       rŒ.t        d|› d|› d	�«      ‚ |S c c}}w )
Né   zHloss_parallel() requires exactly one mesh dim to shard tensor dimension z, but got placements z with z such mesh dim(s).r   zGloss_parallel() expects non-TP mesh dims to be Shard or Replicate, got z at dim ú.)Ú	enumerateÚis_shardÚlenÚ
ValueErrorÚis_replicate)r   r   ÚiÚpÚshard_mesh_dimsÚmesh_dims         r   Ú_find_all_reduce_mesh_dimr)   ~   sÙ   € Ü%.¨zÓ%:×N™T˜Q ¸a¿j¹jÈ½o’qÐN€OÑNÜ
ˆ?Ó˜qÒ ÜðØ˜Ð2°:°,¸fÜ�?Ó#Ð$Ð$6ð8ó
ð 	
ð
 ˜qÑ!€HÜ˜*Ó%ò ‰ˆˆ1Ø�Š=ØØ—
‘
• §¡Õ 0Üð+Ø+,¨#¨X°a°S¸ð;óð ð	ð €Oùó! Os
   �B/©B/Úmeshc                 óR  — t        | t        «      r-| j                  |k(  r| S t        d|› d| j                  › d�«      ‚t        | t        j
                  «      r:t        d„ |D «       «      rt        d|› d�«      ‚t        j                  | ||d¬«      S t        d	t        | «      › �«      ‚)
Nz	Expected z	 but got r   c              3   ó<   K  — | ]  }|j                  «       –— Œ y ­w©N)r!   )Ú.0r&   s     r   ú	<genexpr>z#_cast_to_dtensor.<locals>.<genexpr>›   s   è ø€ Ò0 ˆq�z‰z�|Ñ0ùr   zZloss_parallel() requires a DTensor (not a plain torch.Tensor) when the derived placements u¸    contain Shard â€” this happens on a multi-dimensional mesh with a batch-sharded non-TP dim. Wrap the tensor with DTensor.from_local or distribute_tensor to make the sharding explicit.F)Údevice_meshr   Ú	run_checkzUnsupported type )Ú
isinstancer   r   ÚRuntimeErrorÚtorchr   Úanyr#   Ú
from_localÚ	TypeErrorÚtype)Útensorr   r*   s      r   Ú_cast_to_dtensorr:   ’   s¹   € ô �&œ'Ô"Ø×Ñ 
Ò*ØˆMä ¨:¨,°iÀ×@QÑ@QÐ?RÐRSÐTÓUÐUÜ	�FœEŸL™LÔ	)ÜÑ0 ZÔ0Ô0ô ð/Ø/9¨lð ;1ð2óð ô ×!Ñ!Ø °Àuô
ð 	
ô Ð+¬D°«L¨>Ð:Ó;Ð;r   Úop_callÚargsÚkwargsc                 óV  — t         j                  j                  | ||«      }|j                  €t	        d«      ‚t         j                  j
                  j                  |j                  «      }t        |t        «      r|S t        |t        «      r|d   S t        dt        |«      › d�«      ‚)Nz9op_info.schema should not be None after unwrap_to_op_infor   zUnexpected tensor meta type: r   )r   Ú_op_dispatcherÚunwrap_to_op_infoÚschemaÚAssertionErrorÚsharding_propagatorÚ_propagate_tensor_metar2   r   Útupler3   r8   )r;   r<   r=   Úop_infoÚtensor_metas        r   rD   rD   ­   sž   € ô
 ×$Ñ$×6Ñ6°wÀÀfÓM€GØ‡~�~ÐÜØGó
ð 	
ô ×(Ñ(×<Ñ<×SÑSØ�‰ó€Kô �+œzÔ*ØÐÜ	�K¤Ô	'à˜1‰~ÐäÐ:¼4ÀÓ;LÐ:MÈQÐOÓPÐPr   c                 óü  — |r#| j                   t        j                  k7  rt        ‚t	        j
                  | t        j                  j                  ¬«      \  }}| j                  |t        j                  ¬«      } | j                  «       dk(  r| }nYt        j                  | |d¬«      }t        j                  |t        j                  j                   j"                  ||f¬«      }| |z
  }t        j$                  t        j&                  |«      |d¬«      }	t        j                  |	t        j                  j(                  j"                  ||f¬«      }	t        j*                  |	«      }
||
z
  }|s|j                  |«      }|S )N)Útype_promotion_kind)ÚdtypeÚmemory_formatr   T)Úkeepdim)ÚreduceOpÚgroup)rJ   r4   ÚhalfrB   ÚutilsÚelementwise_dtypesÚELEMENTWISE_TYPE_PROMOTION_KINDÚDEFAULTÚtoÚcontiguous_formatÚnumelÚamaxÚfuncolÚ
all_reduceÚc10dÚReduceOpÚMAXÚnameÚsumÚexpÚSUMÚlog)Úxr   Úhalf_to_floatr*   r(   Úcomputation_dtypeÚresult_dtypeÚshiftedÚx_maxÚshifted_sumexpÚshifted_logsumexpÚresults               r   Ú_log_softmaxrk   Å   s1  € ÙØ�7‰7”e—j‘jÒ Ü Ð Ü&+×&>Ñ&>Ø	œu×DÑD×LÑLô'Ñ#Ð�|ð 	
�‰Ð$´E×4KÑ4KˆÓL€AØ‡w�wƒy�A‚~Ø‰ä—
‘
˜1˜c¨4Ô0ˆÜ×!Ñ!ØœDŸM™M×-Ñ-×2Ñ2¸4ÀÐ:Jô
ˆð �e‘)ˆÜ—Y‘YœuŸy™y¨Ó1°3ÀÔE€NÜ×&Ñ&Ø¤§¡×!2Ñ!2×!7Ñ!7ÀÀhÐ?Oô€Nô Ÿ	™	 .Ó1ÐØÐ(Ñ(€FÙØ—‘˜<Ó(ˆØ€Mr   c                 óÀ  — t        t        |d   «      }t        t        |d   «      }t        t        |d   «      }|j                  }t        ||j                  «       «      }t        |j                  |«      }t        | ||«      }t        |j                  |||j                  |«      }	t        |j                  |j                  |¬«      }
t        |	|
|	j                  ¬«      S )Nr   r   é   ©rG   ©Úrequires_grad)r   r   ÚintÚboolÚ_specr   r   r)   r   rD   rk   Ú_local_tensorr*   r
   rp   )r;   r<   r=   rb   r   rc   Úspecr(   Úoutput_tensor_metaÚresÚres_specs              r   Ú_log_softmax_handlerry   à   sÁ   € ô
 	ŒW�d˜1‘gÓ€AÜ
Œs�D˜‘GÓ
€CÜœ˜t A™wÓ'€Mà�7‰7€DÜ
˜˜QŸU™U›WÓ
%€CÜ(¨¯©¸#Ó>€Hä/°¸¸vÓFÐä
�q—‘¨¨]¸D¿I¹IÀxÓ
P€CäØ�	‰	Ø�‰Ø&ô€Hô àØà×'Ñ'ôð r   c                 ó„   — t        t        |d   «      }t        t        j                  |d   «      }|j	                  |«      S )Nr   é   )r   r   r4   rJ   rT   )r;   r<   r=   Úgrad_outputÚinput_dtypes        r   Ú_log_softmax_backward_handlerr~     s7   € ô
 ”w  Q¡Ó(€KÜ”u—{‘{ D¨¡GÓ,€KØ�>‰>˜+Ó&Ð&r   rb   ÚtargetÚweightÚlocal_weightÚ	reductionÚignore_indexÚinput_shapeÚchannel_dimr(   c
                 óX  ‡‡— | j                  «       ŠdŠ‰dk  rdŠdt        dt        fˆˆfd„}
|� |
|«      }|€t        ‚ |
|«      }| |z  } t        j                  ||k7  |d«      }|j                  ‰«      }t        |‰¬«      }|j                  |||	«      }t        j                  | ‰|«      }|j                  |||	«      }|j                  ‰«       }t        j                  ||k7  |d«      }|t        j                  j                  k(  r‰dkD  r| j                  dd	«      }||fS |�|t        | j                   «      }d
|‰<   j#                  |«      }t        j                  |‰|«      j                  ‰«      }t        j                  ||k7  |d«      }|j%                  «       }n"||k7  j%                  «       j'                  | «      }|t        j(                  j                  k(  r|j%                  «       }||fS |t        j*                  j                  k(  r|j%                  «       |z  }||fS )Nr   rm   r   r€   r   c                 ól   •— ‰dkD  r+dg‰z  }| j                   d   |‰<   | j                  |«      }|S | }|S )Nr   r   )ÚshapeÚview)r€   rˆ   Úwr…   Ún_dimss      €€r   Ú_weight_viewz'_nll_loss_forward.<locals>._weight_view   sQ   ø€ Ø�AŠ:àðàñˆEð "(§¡¨a¡ˆE�+ÑØ—‘˜EÓ"ˆAð ˆð ˆAØˆr   ©Úoffset_shapeÚ
offset_dimr   g        éÿÿÿÿ)r   r   rB   r4   ÚwhereÚ	unsqueezer   Ú_partition_valueÚgatherÚ_reduce_valueÚsqueezer   ÚNONEÚvalueÚnew_fullÚlistrˆ   Úexpandr^   rT   r`   ÚMEAN)rb   r   r€   r�   r‚   rƒ   r„   r…   r*   r(   rŒ   rŠ   Úlocal_wÚsafe_targetÚsafe_target_Úpartial_placementÚsafe_target_partial_Úresult_partialÚresult_reducedrj   Útotal_weightÚ	new_shapeÚwsumr‹   s          `               @r   Ú_nll_loss_forwardr§     s  ù€ ð �U‰U‹W€FØ€KØ�‚zØˆð	œVð 	¬ö 	ð ÐÙ˜Ó ˆØÐÜ Ð Ù˜|Ó,ˆØ�‰KˆÜ—+‘+˜f¨Ñ4°f¸aÓ@€KØ×(Ñ(¨Ó5€Lô %°+È+ÔVÐØ,×=Ñ=Ø�d˜HóÐô —\‘\ ! [Ð2FÓG€Nà&×4Ñ4°^ÀTÈ8ÓT€NØ×$Ñ$ [Ó1Ð1€Fä�[‰[˜ <Ñ/°¸Ó;€Fà”I—N‘N×(Ñ(Ò(¨V°aªZØ—z‘z " cÓ*ˆØ�|Ð#Ð#àÐÜ˜Ÿ™“Mˆ	Ø!#ˆ	�+Ñà�H‰H�YÓˆÜ�|‰|˜A˜{¨LÓ9×AÑAÀ+ÓNˆÜ�{‰{˜6 \Ñ1°4¸Ó;ˆØ—x‘x“z‰à ,Ñ.×3Ñ3Ó5×8Ñ8¸Ó;ˆð ”I—M‘M×'Ñ'Ò'Ø—‘“ˆð �<ÐÐð 
”i—n‘n×*Ñ*Ò	*Ø—‘“ Ñ,ˆà�<ÐÐr   c                 óp  — t        t        |d   «      }|d   }|d   }t        t        |d   «      }t        t        |d   «      }|j                  «       dk\  rdnd}|j                  }	t        |	j                  |«      }
t        t        |	j                  |g«      |«      }t        «       f|	j                  j                  z  }t        |||	j                  «      }d }|�°t        |||	j                  «      }t        |	j                  j                  «      D �cg c]  }||
k(  rt        d«      n	t        «       ‘Œ }}|j                  |	j                  |«      j                   }|j"                  d   |j                   j"                  |   k7  rt$        ‚|t&        j(                  j*                  k(  r|}nÝ|t&        j,                  j*                  k(  r<|	j                  j                  dkD  r#t/        d|	j                  j                  › d�«      ‚g }t1        |	j                  «      D ]_  \  }}||
k(  r|j3                  t        «       «       Œ%|j5                  «       r|j3                  t7        «       «       ŒO|j3                  |«       Œa t9        |«      }t;        |«      }||c|d<   |d<   t=        | t9        |«      |«      }t?        |j                   |j                   |�|j                   nd ||||j"                  ||	j                  |
«
      \  }}tA        |	j                  ||¬«      }t        |||jB                  ¬	«      |fS c c}w )
Nr   r   rm   r{   é   zjloss_parallel() with reduction='mean' is only supported on one-dimensional DeviceMesh; got mesh with ndim=z(. Use reduction='sum' or 'none' instead.rn   ro   )"r   r   rq   r   rs   r)   r   r   r   r   r*   Úndimr:   Úranger	   Úredistributert   rˆ   rB   r   r—   r˜   rœ   ÚNotImplementedErrorr    Úappendr!   r   rE   rš   rD   r§   r
   rp   )r;   r<   r=   rb   r   r€   r‚   rƒ   r…   ru   r(   Útarget_placementsÚall_replicate_placementsr�   r%   Úsharded_placementsÚoutput_placementsÚout_placements_listr&   rv   rj   r¤   Úout_specs                          r   Ú_nll_loss_forward_handlerrµ   ]  sö  € ô
 	ŒW�d˜1‘gÓ€AØ�!‰W€FØ�!‰W€FÜ”S˜$˜q™'Ó"€IÜœ˜T !™WÓ%€Là—u‘u“w !’|‘!¨€KØ�7‰7€DÜ(¨¯©¸+ÓF€Hô "Ü  §¡°;°-Ó@À+óÐô !*£˜~°·	±	·±Ñ>ÐÜ˜fÐ&7¸¿¹ÓC€FØ€LØÐÜ! &Ð*BÀDÇIÁIÓNˆô
 AFÀdÇiÁiÇnÁnÓ@Uö
Ø;<˜˜XšŒE�!ŒH¬9«;Ñ6ð
Ðð 
ð ×*Ñ*¨4¯9©9Ð6HÓI×WÑWˆØ×Ñ˜aÑ  A§O¡O×$9Ñ$9¸+Ñ$FÒFÜ Ð à”I—N‘N×(Ñ(Ò(Ø-Ñð œ	Ÿ™×,Ñ,Ò,°·±·±À!Ò1CÜ%ðBà—9‘9—>‘>Ð"Ð"JðLóð ð 02ÐÜ˜dŸo™oÓ.ò 	.‰DˆAˆqØ�HŠ}Ø#×*Ñ*¬9«;Õ7Ø—‘”Ø#×*Ñ*¬7«9Õ5à#×*Ñ*¨1Õ-ð	.ô "Ð"5Ó6Ðô �‹:€Dà˜vÐ€Dˆ�GˆT�!‰WÜ/°¼¸t»ÀfÓMÐä,Ø	�‰Ø×ÑØ &Ð 2ˆ×Ò¸ØØØØ	�‰ØØ�	‰	ØóÑ€FˆLô ˜4Ÿ9™9Ð&7ÐEWÔX€Hô 	àØà ×.Ñ.ô	
ð 	ð
ð 
ùòm
s   Ä!L3r|   r¤   c                 óª  — |j                  «       dk  rdnd}|t        j                  j                  k(  r| |z  } |j	                  |«      }t        j                  ||k7  |d«      }t        j                  |«      }t        ||¬«      }|j                  |«      j                  «       }|j                  ||	|
«      }|j                  j                  €t        ‚|j                  j                  j                  |j                   «      dz
  }t        j"                  |j$                  d   |j&                  ¬«      }|j                  «       dk(  r|||<   n€|j                  «       dk(  r||||f<   ne|j)                  |d«      }|j$                  }|j+                  d|j$                  |   «      }||||f<   |j-                  |«      j)                  |d«      }|j                  «       | j                  «       cxkD  rdkD  rn n| j	                  |«      } |��t/        |j                  «       «      D �cg c]  }d‘Œ }}|j$                  d   ||<   |j+                  |«      }t1        |j$                  «      }d||<   |j3                  |«      }t        j4                  |||«      }| |z  } t        j                  ||k7  | d«      } |t        j6                  |«      z   | z  S c c}w )Nrm   r   r   r�   g      ð?)Údevicer�   )r   r   rœ   r˜   r’   r4   r‘   Ú
zeros_liker   r–   Úflattenr“   Úmask_bufferÚdatarB   rT   rJ   Úarangerˆ   r·   Ú	transposeÚreshaper‰   r«   rš   r›   r”   r_   )r|   rb   r   r€   r‚   rƒ   r¤   r„   r…   r*   r(   rž   Ú
grad_inputr    Úmasked_safe_targetÚgrad_updateÚ	arange_1dÚgrad_input_tÚintermidate_shapeÚgrad_input_2dÚ_r¥   rŠ   Úw_targets                           r   Ú"_nll_loss_and_log_softmax_backwardrÈ   Ã  s‘  € ð —u‘u“w ’{‘!¨€KØ”I—N‘N×(Ñ(Ò(Ø! LÑ0ˆà×Ñ˜kÓ*€FÜ—+‘+˜f¨Ñ4°f¸aÓ@€KÜ×!Ñ! !Ó$€Jô %°+È+ÔVÐØ×%Ñ% kÓ2×:Ñ:Ó<€KØ*×;Ñ;¸KÈÈxÓXÐà×$Ñ$×)Ñ)Ð1ÜÐØ#×/Ñ/×4Ñ4×7Ñ7¸
×8HÑ8HÓIÈCÑO€KÜ—‘Ø× Ñ  Ñ#Ð,>×,EÑ,Eô€Ið
 	‡u�uƒw�!‚|Ø)4ˆ
Ð%Ò&Ø	
�‰‹�AŠØ4?ˆ
�9Ð0Ð0Ò1à!×+Ñ+¨K¸Ó<ˆØ(×.Ñ.ÐØ$×,Ñ,¨R°·±¸Ñ1EÓFˆØ7Bˆ�iÐ!3Ð3Ñ4Ø"×'Ñ'Ð(9Ó:×DÑDÀ[ÐRTÓUˆ
à‡~�~Ó˜+Ÿ/™/Ó+Ô/¨aÕ/Ø!×+Ñ+¨KÓ8ˆàÐÜ % a§e¡e£g£Ö/˜1’QÐ/ˆ	Ð/Ø!'§¡¨a¡ˆ	�+ÑØ—‘ 	Ó*ˆô ˜Ÿ™“Mˆ	Ø!#ˆ	�+ÑØ�M‰M˜)Ó$ˆÜ—<‘<  ;°Ó7ˆØ! HÑ,ˆä—+‘+˜f¨Ñ4°kÀ1ÓE€Kð œŸ™ 1›Ñ%¨Ñ4Ð4ùò# 0s   È&	Kc                 óR  — t        t        |d   «      }t        t        |d   «      }|d   }|d   }t        t        |d   «      }t        t        |d   «      }t        t        |d   «      }	|j	                  «       dk\  rdnd}
|j
                  }t        |j                  |
«      }t        t        |j                  |
g«      |
«      }t        «       f|j                  j                  z  }t        |||j                  «      }|�t        |||j                  «      }|t        j                  j                   k(  r|j#                  |j                  |«      }t%        |«      }||d<   ||c|d<   |d<   t        |	||j                  «      |d<   t'        | t)        |«      |«      }t+        |j,                  |j,                  |j,                  |�|j,                  nd |||	|j.                  |
|j                  |«      }t1        |j                  |j                  |¬«      }t        |||j2                  ¬	«      S )
Nr   r   rm   r{   r©   é   é   rn   ro   )r   r   rq   r   r   rs   r)   r   r   r   r   r*   rª   r:   r   r—   r˜   r¬   rš   rD   rE   rÈ   rt   rˆ   r
   rp   )r;   r<   r=   r|   rb   r   r€   r‚   rƒ   r¤   r…   ru   r(   r¯   r°   rv   rj   r´   s                     r   Ú_nll_loss_backward_handlerrÌ   	  sþ  € ô
 ”w  Q¡Ó(€KÜŒW�d˜1‘gÓ€AØ�!‰W€FØ�!‰W€FÜ”S˜$˜q™'Ó"€IÜœ˜T !™WÓ%€LÜœ  Q¡Ó(€Là—u‘u“w !’|‘!¨€KØ�7‰7€DÜ(¨¯©¸+ÓF€Hô "Ü  §¡°;°-Ó@À+óÐô !*£˜~°·	±	·±Ñ>ÐÜ˜fÐ&7¸¿¹ÓC€FØÐÜ! &Ð*BÀDÇIÁIÓNˆð ”I—N‘N×(Ñ(Ò(Ø!×.Ñ.¨t¯y©yÐ:KÓLˆô �‹:€Dà€Dˆ�Gà˜vÐ€Dˆ�GˆT�!‰Wä˜|Ð-EÀtÇyÁyÓQ€Dˆ�GÜ/°¼¸t»ÀfÓMÐä/Ø×!Ñ!Ø	�‰Ø×ÑØ &Ð 2ˆ×Ò¸ØØØØ	�‰ØØ�	‰	Øó€Fô Ø�	‰	Ø�‰Ø&ô€Hô àØà×*Ñ*ôð r   c                  ó^   — t         j                  j                  j                  t        «       y r-   )r   r?   Ú_custom_op_handlersÚupdateÚcustomized_loss_opsr   r   r   r   r   `  s   € Ü×Ñ×.Ñ.×5Ñ5Ô6IÕJr   c                  ól   — t         D ]+  } t        j                  j                  j	                  | «       Œ- y r-   )rÐ   r   r?   rÎ   Úpop)Ú	custom_ops    r   r   r   d  s-   € Ü(ò Bˆ	Ü×Ñ×2Ñ2×6Ñ6°yÕAñBr   )CÚ
contextlibÚtypingr   r4   Útorch._prims_commonÚ_prims_commonrP   Ú)torch.distributed._functional_collectivesÚdistributedÚ_functional_collectivesrX   Ú"torch.distributed.distributed_c10dÚdistributed_c10drZ   r   Útorch.distributed.device_meshr   Útorch.distributed.tensorr   r   r   r	   Ú&torch.distributed.tensor._dtensor_specr
   r   Ú,torch.distributed.tensor._ops._embedding_opsr   Ú'torch.distributed.tensor._ops._math_opsr   r   r   Ú#torch.distributed.tensor._ops.utilsr   Ú(torch.distributed.tensor.placement_typesr   ÚopsÚatenÚ__all__Úcontextmanagerr   rE   rq   r)   r:   Ú_opsÚ
OpOverloadÚobjectÚdictÚstrrD   rk   ry   r~   ÚSizer§   rµ   rÈ   rÌ   ÚdefaultÚ_log_softmax_backward_dataÚnll_loss_forwardÚnll_loss2d_forwardÚnll_loss_backwardÚnll_loss2d_backwardrÐ   r   r   r   r   r   ú<module>rô      sÔ  ðó Ý ã Ý #ß :Ð :ß 1Ð 1Ý Ý 4ß GÓ Gß JÝ E÷ñ õ
 >Ý >ð ‡y�y‡~�~€ð Ð
€ð ×ÑñWó ðWð~¨%°	¸3°Ñ*?ð Àcð Ècó ð(<Ø˜i¨˜nÑ-ð<Ø5?ð<àó<ð6QØ�Z‰Z×"Ñ"ðQà
�˜�Ñ
ðQð ��f�ÑðQð ó	Qò0ð6Ø�Z‰Z×"Ñ"ðà
�˜�Ñ
ðð ��f�Ñðð ó	ðF'Ø�Z‰Z×"Ñ"ð'à
�˜�Ñ
ð'ð ��f�Ñð'ð ó	'ðK ØðK àðK ð �T‰MðK ð ˜4‘-ð	K ð
 ðK ð ðK ð —‘ðK ð ðK ð ðK ð ðK ð ˆ6�6ˆ>ÑóK ð\\Ø�Z‰Z×"Ñ"ð\à
�˜�Ñ
ð\ð ��f�Ñð\ð ó	\ðLC5ØðC5àðC5ð ðC5ð �T‰Mð	C5ð
 ðC5ð ðC5ð ðC5ð —‘ðC5ð ðC5ð ðC5ð ðC5ð óC5ðLJØ�Z‰Z×"Ñ"ðJà
�˜�Ñ
ðJð ��f�ÑðJð ó	Jð\ 	×Ñ×ÑÐ3Ø×#Ñ#×+Ñ+Ð-JØ×Ñ×!Ñ!Ð#<Ø×Ñ×#Ñ#Ð%>Ø×Ñ×"Ñ"Ð$>Ø×Ñ×$Ñ$Ð&@ðÐ òKóBr   