
    9j2                        U d dl mZmZ d dlmZ d dlmZmZmZm	Z	m
Z
 d dlZd dlmc mZ d dlmZmZ d dlmZ d dlmZmZmZmZ dZee   ed	<   g d
Zdeez  deedf   fdZdeeez     dedz  dedz  defdZ dededefdZ!d*dede"defdZ#dedefdZ$d*dede"def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),    )CallableSequence)update_wrapper)AnyFinalGenericoverloadTypeVarN)SymIntTensoris_tensor_like)_dtype_NumberDeviceNumbergox?euler_constant)broadcast_alllogits_to_probsclamp_probsprobs_to_logitslazy_propertytril_matrix_to_vecvec_to_tril_matrixvaluesreturn.c                     t        d | D              st        d      t        d | D              st        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     Y/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/distributions/utils.py	<genexpr>z broadcast_all.<locals>.<genexpr>+   s$     Kq~a :Jq'$::Ks   ')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>0   s     1Q~a 1s   )dtyper'   device)all
ValueErrordicttorchget_default_dtyper    r   r'   r)   r   tensorbroadcast_tensors)r   optionsvaluer#   
new_valuess        r$   r   r      s      KF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&shaper'   r)   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_)r4   r'   r)   s      r$   _standard_normalr=   =   sc    
 xx""$||KKU6:JJuE&9
 	
 ;;uE&9AACC    r2   dimc                 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)rA   )r4   reshapesum)r2   r?   required_shapes      r$   _sum_rightmostrE   K   sA     ax[[3$'%/N==(,,R00r>   logits	is_binaryc                 ^    |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.
    rA   )r?   )r-   sigmoidFsoftmax)rF   rG   s     r$   r   r   Y   s'     }}V$$99V$$r>   probsc                     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)rL   rR   s     r$   r   r   e   s3    , ++ekk
"
&
&C;;3AG;,,r>   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   rG   
ps_clampeds      r$   r   r      s?     U#Jyy$u{{J;'???99Z  r>   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dz  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.
    wrappedr   Nc                 *    || _         t        | |       y r   )r]   r   selfr]   s     r$   __init__zlazy_property.__init__   s    )0tW%r>   instanceobj_typez!_lazy_property_and_property[T, R]c                      y r    r`   rb   rc   s      r$   __get__zlazy_property.__get__   s     /2r>   c                      y r   re   rf   s      r$   rg   zlazy_property.__get__   s    ?Br>   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_propertyr]   r-   enable_gradsetattr__name__)r`   rb   rc   r2   s       r$   rg   zlazy_property.__get__   sc     .t||<<  	+LL*E	+$,,//7	+ 	+s   A))A2r   )rm   
__module____qualname____doc__r   rX   rZ   ra   r	   r   rg   re   r>   r$   r   r      s    &!a 0 &T & .222(+2	,2 2 BBSBAB B 37D,/	0r>   r   c                   ,    e Zd ZdZdeegef   ddfdZy)rj   zWe want lazy properties to look like multiple things.

    * property when Sphinx autodoc looks
    * lazy_property when Distribution validate_args looks
    r]   r   Nc                 0    t         j                  | |       y r   )propertyra   r_   s     r$   ra   z$_lazy_property_and_property.__init__   s    $(r>   )rm   rn   ro   rp   r   rX   rZ   ra   re   r>   r$   rj   rj      s%    )!a 0 )T )r>   rj   matdiagc           	      .   | 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.
    rA   zdiag (z) provided is outside [z, rN   z].r)   .)r4   r-   r6   r7   r+   aranger)   view)rt   ru   nrx   	tril_maskvecs         r$   r   r      s    
 			"A88&&(daRi4196$'>rd"QUG2NOO\\!CJJ/FR+tax88I
c9n
CJr>   r|   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.
    rN         rA      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.Nrw   .)r4   absr-   rQ   r'   rR   r6   r7   roundr+   r    r   item	new_zerosSizerx   r)   ry   )r|   ru   rz   rR   rt   rx   r{   s          r$   r   r      sV    a$h,DLQSYYr]!22QT]dQh5OOTW
W	X		
A ++cii
 
$
$C88&&(eAhlS.@,SYYr]O;YZCD
 	
 &a6affhE!HA
--		#2QF);;
<C\\!CJJ/FR+tax88ICYJr>   )F)r   )-collections.abcr   r   	functoolsr   typingr   r   r   r	   r
   r-   torch.nn.functionalnn
functionalrJ   r   r   torch.overridesr   torch.typesr   r   r   r   r   float__annotations____all__tupler   intr=   rE   boolr   r   r   rX   rZ   r   rs   rj   r   r   re   r>   r$   <module>r      sz   . . $ 9 9      * 7 7  6e 5,6F? ,uVS[/A ,DDC&L!DD=D TMD 	D1& 1s 1v 1	%F 	%t 	% 	%-v -& -4
!6 
!d 
!v 
! Ct$C4 GAqDM >)-1"5x )F # f F # f r>   