Ë
    f^(h¥  ã                   ó@  — d dl mZ d dlmZmZmZmZmZ d dlm	Z	 d dl
Z
d dlmc mZ d dl
mZ d dlmZ d dlmZ dZg d	¢Zd
„ Zd„ Zd„ Zdd„Zd„ Zdd„Z e	dd¬«      Z e	dd¬«      Z G d„ deeef   «      Z G d„ deeef   e«      Z d dede!defd„Z"d dede!defd„Z#y)!é    )Úupdate_wrapper)ÚAnyÚCallableÚGenericÚoverloadÚUnion)ÚTypeVarN)ÚTensor©Úis_tensor_like)Ú_Numberg¶oüŒxâ?)Úbroadcast_allÚlogits_to_probsÚclamp_probsÚprobs_to_logitsÚlazy_propertyÚtril_matrix_to_vecÚvec_to_tril_matrixc                  óÖ  — t        d„ | D «       «      st        d«      ‚t        d„ | D «       «      s¤t        t        j                  «       ¬«      }| D ]?  }t        |t        j                  «      sŒt        |j                  |j                  ¬«      } n | D �cg c]%  }t        |«      r|nt        j                  |fi |¤Ž‘Œ' }}t        j                  |Ž S t        j                  | Ž S c c}w )aÔ  
    Given a list of values (possibly containing numbers), returns a list where each
    value is broadcasted based on the following rules:
      - `torch.*Tensor` instances are broadcasted as per :ref:`_broadcasting-semantics`.
      - Number instances (scalars) are upcast to tensors having
        the same size and type as the first tensor passed to `values`.  If all the
        values are scalars, then they are upcasted to scalar Tensors.

    Args:
        values (list of `Number`, `torch.*Tensor` or objects implementing __torch_function__)

    Raises:
        ValueError: if any of the values is not a `Number` instance,
            a `torch.*Tensor` instance, or an instance implementing __torch_function__
    c              3   óV   K  — | ]!  }t        |«      xs t        |t        «      –— Œ# y ­w©N)r   Ú
isinstancer   ©Ú.0Úvs     úW/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/distributions/utils.pyú	<genexpr>z broadcast_all.<locals>.<genexpr>*   s$   è ø€ ÒK¸qŒ~˜aÓ Ò:¤J¨q´'Ó$:Ó:ÑKùs   ‚')ziInput arguments must all be instances of Number, torch.Tensor or objects implementing __torch_function__.c              3   ó2   K  — | ]  }t        |«      –— Œ y ­wr   r   r   s     r   r   z broadcast_all.<locals>.<genexpr>/   s   è ø€ Ò1 QŒ~˜a× Ñ1ùs   ‚)Údtype©r   Údevice)ÚallÚ
ValueErrorÚdictÚtorchÚget_default_dtyper   r
   r   r!   r   ÚtensorÚbroadcast_tensors)ÚvaluesÚoptionsÚvaluer   Ú
new_valuess        r   r   r      sÝ   € ô  ÑKÀFÔKÔKÜðGó
ð 	
ô Ñ1¨&Ô1Ô1Ü"&¬U×-DÑ-DÓ-FÔ"GˆØò 	ˆEÜ˜%¤§¡Õ.Ü U§[¡[¸¿¹ÔF�Ùð	ð
 MSö
ØGH” Ô"‰A¬¯©°QÑ(B¸'Ñ(BÑBð
ˆ
ð 
ô ×&Ñ&¨
Ð3Ð3Ü×"Ñ" FÐ+Ð+ùò	
s   Â*C&c                 ó  — t         j                  j                  «       rBt        j                  t        j                  | ||¬«      t        j
                  | ||¬«      «      S t        j                  | ||¬«      j                  «       S )Nr    )r%   Ú_CÚ_get_tracing_stateÚnormalÚzerosÚonesÚemptyÚnormal_)Úshaper   r!   s      r   Ú_standard_normalr6   <   sa   € Ü‡x�x×"Ñ"Ô$ä�|‰|Ü�K‰K˜ U°6Ô:Ü�J‰J�u E°&Ô9ó
ð 	
ô �;‰;�u E°&Ô9×AÑAÓCÐCó    c                 óv   — |dk(  r| S | j                   d|  dz   }| j                  |«      j                  d«      S )zÎ
    Sum out ``dim`` many rightmost dimensions of a given tensor.

    Args:
        value (Tensor): A tensor of ``.dim()`` at least ``dim``.
        dim (int): The number of rightmost dims to sum out.
    r   N)éÿÿÿÿr9   )r5   ÚreshapeÚsum)r+   ÚdimÚrequired_shapes      r   Ú_sum_rightmostr>   F   sA   € ð ˆa‚xØˆØ—[‘[  3 $Ð'¨%Ñ/€NØ�=‰=˜Ó(×,Ñ,¨RÓ0Ð0r7   c                 ó^   — |rt        j                  | «      S t        j                  | d¬«      S )a  
    Converts a tensor of logits into probabilities. Note that for the
    binary case, each value denotes log odds, whereas for the
    multi-dimensional case, the values along the last dimension denote
    the log probabilities (possibly unnormalized) of the events.
    r9   )r<   )r%   ÚsigmoidÚFÚsoftmax)ÚlogitsÚ	is_binarys     r   r   r   T   s'   € ñ Ü�}‰}˜VÓ$Ð$Ü�9‰9�V Ô$Ð$r7   c                 ó€   — t        j                  | j                  «      j                  }| j	                  |d|z
  ¬«      S )a   Clamps the probabilities to be in the open interval `(0, 1)`.

    The probabilities would be clamped between `eps` and `1 - eps`,
    and `eps` would be the smallest representable positive number for the input data type.

    Args:
        probs (Tensor): A tensor of probabilities.

    Returns:
        Tensor: The clamped probabilities.

    Examples:
        >>> probs = torch.tensor([0.0, 0.5, 1.0])
        >>> clamp_probs(probs)
        tensor([1.1921e-07, 5.0000e-01, 1.0000e+00])

        >>> probs = torch.tensor([0.0, 0.5, 1.0], dtype=torch.float64)
        >>> clamp_probs(probs)
        tensor([2.2204e-16, 5.0000e-01, 1.0000e+00], dtype=torch.float64)

    é   )ÚminÚmax)r%   Úfinfor   ÚepsÚclamp)ÚprobsrJ   s     r   r   r   `   s3   € ô, �+‰+�e—k‘kÓ
"×
&Ñ
&€CØ�;‰;˜3 A¨¡Gˆ;Ó,Ð,r7   c                 óž   — t        | «      }|r,t        j                  |«      t        j                  | «      z
  S t        j                  |«      S )a$  
    Converts a tensor of probabilities into logits. For the binary case,
    this denotes the probability of occurrence of the event indexed by `1`.
    For the multi-dimensional case, the values along the last dimension
    denote the probabilities of occurrence of each of the events.
    )r   r%   ÚlogÚlog1p)rL   rD   Ú
ps_clampeds      r   r   r   z   s?   € ô ˜UÓ#€JÙÜ�y‰y˜Ó$¤u§{¡{°J°;Ó'?Ñ?Ð?Ü�9‰9�ZÓ Ð r7   ÚTT)ÚcontravariantÚR)Ú	covariantc                   ó�   — e Zd ZdZdeegef   ddfd„Ze	 dddde	ddfd	„«       Z
eddede	defd
„«       Z
	 ddeedf   de	ddfd„Z
y)r   zø
    Used as a decorator for lazy loading of class attributes. This uses a
    non-data descriptor that calls the wrapped method to compute the property on
    first call; thereafter replacing the wrapped method into an instance
    attribute.
    ÚwrappedÚreturnNc                 ó*   — || _         t        | |«       y r   )rV   r   ©ÚselfrV   s     r   Ú__init__zlazy_property.__init__“   s   € Ø)0ˆŒÜ�t˜WÕ%r7   ÚinstanceÚobj_typez!_lazy_property_and_property[T, R]c                  ó   — y r   © ©rZ   r\   r]   s      r   Ú__get__zlazy_property.__get__—   s   € ð /2r7   c                  ó   — y r   r_   r`   s      r   ra   zlazy_property.__get__œ   s   € Ø?Br7   z%R | _lazy_property_and_property[T, R]c                 óê   — |€t        | j                  «      S t        j                  «       5  | j                  |«      }d d d «       t	        || j                  j
                  «       |S # 1 sw Y   Œ,xY wr   )Ú_lazy_property_and_propertyrV   r%   Úenable_gradÚsetattrÚ__name__)rZ   r\   r]   r+   s       r   ra   zlazy_property.__get__Ÿ   sc   € ð ÐÜ.¨t¯|©|Ó<Ð<Ü×ÑÓ ñ 	+Ø—L‘L Ó*ˆE÷	+ä�˜$Ÿ,™,×/Ñ/°Ô7Øˆ÷	+ð 	+ús   ¬A)Á)A2r   )rg   Ú
__module__Ú__qualname__Ú__doc__r   rQ   rS   r[   r   r   ra   r   r_   r7   r   r   r   ‹   s�   „ ñð& ¨!¨¨a¨Ñ 0ð &°Tó &ð à.2ñ2Øð2Ø(+ð2à	,ò2ó ð2ð ÙB ÐB¨SÐB¸AÒBó ØBð 9=ñØ˜a ˜g™ðØ25ðà	0ôr7   r   c                   ó,   — e Zd ZdZdeegef   ddfd„Zy)rd   zžWe want lazy properties to look like multiple things.

    * property when Sphinx autodoc looks
    * lazy_property when Distribution validate_args looks
    rV   rW   Nc                 ó0   — t         j                  | |«       y r   )Úpropertyr[   rY   s     r   r[   z$_lazy_property_and_property.__init__±   s   € Ü×Ñ˜$ Õ(r7   )rg   rh   ri   rj   r   rQ   rS   r[   r_   r7   r   rd   rd   ª   s%   „ ñð) ¨!¨¨a¨Ñ 0ð )°Tô )r7   rd   ÚmatÚdiagrW   c           	      ó.  — | j                   d   }t        j                  j                  «       s$|| k  s||k\  rt	        d|› d| › d|dz
  › d�«      ‚t        j
                  || j                  ¬«      }||j                  dd«      |dz   z   k  }| d|f   }|S )	z 
    Convert a `D x D` matrix or a batch of matrices into a (batched) vector
    which comprises of lower triangular elements from the matrix in row order.
    r9   zdiag (z) provided is outside [z, rF   z].©r!   .)r5   r%   r.   r/   r#   Úaranger!   Úview)rn   ro   Únrr   Ú	tril_maskÚvecs         r   r   r   µ   s›   € ð
 	�	‰	�"‰€AÜ�8‰8×&Ñ&Ô(¨d°a°Rªi¸4À1º9Ü˜6 $ Ð'>À¸r¸dÀ"ÀQÈÁUÀGÈ2ÐNÓOÐOÜ�\‰\˜! C§J¡JÔ/€FØ˜Ÿ™ R¨Ó+¨t°a©xÑ8Ñ8€IØ
ˆc�9ˆnÑ
€CØ€Jr7   rv   c                 óè  — dd|z  z    dd|z  z   dz  d| j                   d   z  z   dt        |«      z  |dz   z  z   dz  z   dz  }t        j                  | j                  «      j
                  }t        j                  j                  «       s0t        |«      |z
  |kD  rt        d| j                   d   › d�d	z   «      ‚t        |t        j                  «      rt        |j                  «       «      n
t        |«      }| j                  | j                   d
d t        j                  ||f«      z   «      }t        j                  || j                   ¬«      }||j#                  dd«      |dz   z   k  }| |d|f<   |S )z•
    Convert a vector or a batch of vectors into a batched `D x D`
    lower triangular matrix containing elements from the vector in row order.
    rF   é   é   r9   é   g      à?zThe size of last dimension is z which cannot be expressed as z3the lower triangular part of a square D x D matrix.Nrq   .)r5   Úabsr%   rI   r   rJ   r.   r/   Úroundr#   r   r
   ÚitemÚ	new_zerosÚSizerr   r!   rs   )rv   ro   rt   rJ   rn   rr   ru   s          r   r   r   Ã   sV  € ð ˆa�$‰h‰,ˆØ��D‘‰L˜QÑ  S§Y¡Y¨r¡]Ñ!2Ñ2°Q¼¸T»±]ÀdÈQÁhÑ5OÑOÐTWÑ
Wñ	Xà	ñ	
€Aô �+‰+�c—i‘iÓ
 ×
$Ñ
$€CÜ�8‰8×&Ñ&Ô(¬e°A«h¸©l¸SÒ.@ÜØ,¨S¯Y©Y°r©]¨OÐ;YÐZØCñDó
ð 	
ô & a¬¯©Ô6Œˆa�f‰f‹hŒ¼EÀ!»H€AØ
�-‰-˜Ÿ	™	 # 2˜¬¯©°Q¸°FÓ);Ñ;Ó
<€CÜ�\‰\˜! C§J¡JÔ/€FØ˜Ÿ™ R¨Ó+¨t°a©xÑ8Ñ8€IØ€CˆˆYˆÑØ€Jr7   )F)r   )$Ú	functoolsr   Útypingr   r   r   r   r   Útyping_extensionsr	   r%   Útorch.nn.functionalÚnnÚ
functionalrA   r
   Útorch.overridesr   Útorch.typesr   Úeuler_constantÚ__all__r   r6   r>   r   r   r   rQ   rS   r   rm   rd   Úintr   r   r_   r7   r   ú<module>r‹      sÊ   ðå $ß :Õ :Ý %ã ß Ð Ý Ý *Ý ð (€ò€ò,òDDò1ó	%ò-ó4
!ñ ˆC˜tÔ$€ÙˆC˜4Ô €ô�G˜A˜q˜D‘Mô ô>) -°°1°Ñ"5°xô )ñ˜Fð ¨#ð °fó ñ˜Fð ¨#ð °fô r7   