a
    h[                     @   s  U d dl mZ d dlmZ d dlmZmZmZmZm	Z	m
Z
mZmZ d dlZd dlm  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eeef eedf dddZ eee!ef  e	e e	e edddZ"ee!edddZ#d.ee$edddZ%eedddZ&d/ee$edddZ'edd d!Z(ed"d d#Z)G d$d% d%ee(e)f Z*G d&d' d'e*e(e)f e+Z,d0ee!ed(d)d*Z-d1ee!ed+d,d-Z.dS )2    )Sequence)update_wrapper)AnyCallableFinalGenericOptionaloverloadTypeVarUnionN)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returnc                     s   t dd | D stdt dd | D stt d | D ]$}t|tjr>t|j|jd  qdq> fdd| D }tj	| S tj	|  S )	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                 s   s    | ]}t |pt|tV  qd S N)r   
isinstancer   .0v r#   G/var/www/auris/lib/python3.9/site-packages/torch/distributions/utils.py	<genexpr>+       z broadcast_all.<locals>.<genexpr>ziInput arguments must all be instances of Number, torch.Tensor or objects implementing __torch_function__.c                 s   s   | ]}t |V  qd S r   r   r    r#   r#   r$   r%   0   r&   )dtyper'   devicec                    s*   g | ]"}t |r|ntj|fi  qS r#   )r   torchZtensorr    optionsr#   r$   
<listcomp>6   s   z!broadcast_all.<locals>.<listcomp>)
all
ValueErrordictr*   Zget_default_dtyper   r   r'   r)   Zbroadcast_tensors)r   value
new_valuesr#   r+   r$   r      s    

r   )shaper'   r)   r   c                 C   sB   t j r.t t j| ||dt j| ||dS t j| ||d S )Nr(   )r*   _C_get_tracing_statenormalzerosZonesemptyZnormal_)r3   r'   r)   r#   r#   r$   _standard_normal=   s    
r9   )r1   dimr   c                 C   s0   |dkr| S | j d|  d }| |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)r;   )r3   Zreshapesum)r1   r:   Zrequired_shaper#   r#   r$   _sum_rightmostK   s    r=   F)logits	is_binaryr   c                 C   s   |rt | S tj| d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.
    r;   )r:   )r*   ZsigmoidFZsoftmax)r>   r?   r#   r#   r$   r   Y   s    
r   )probsr   c                 C   s    t | jj}| j|d| d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)rA   rF   r#   r#   r$   r   e   s    r   )rA   r?   r   c                 C   s,   t | }|r"t|t|  S t|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)rA   r?   Z
ps_clampedr#   r#   r$   r      s    r   TT)contravariantR)	covariantc                   @   sv   e Zd ZdZeegef ddddZedde	dddd	Z
edee	edd
d	Z
deedf e	dddd	Z
dS )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.
    Nwrappedr   c                 C   s   || _ t| | d S r   )rO   r   selfrO   r#   r#   r$   __init__   s    zlazy_property.__init__z!_lazy_property_and_property[T, R])instanceobj_typer   c                 C   s   d S r   r#   rQ   rS   rT   r#   r#   r$   __get__   s    zlazy_property.__get__c                 C   s   d S r   r#   rU   r#   r#   r$   rV      s    z%R | _lazy_property_and_property[T, R]c                 C   sX   |d u rt | jS t  | |}W d    n1 s:0    Y  t|| jj| |S r   )_lazy_property_and_propertyrO   r*   Zenable_gradsetattr__name__)rQ   rS   rT   r1   r#   r#   r$   rV      s    

()N)N)N)rY   
__module____qualname____doc__r   rJ   rL   rR   r	   r   rV   r   r#   r#   r#   r$   r      s     r   c                   @   s*   e Zd ZdZeegef ddddZdS )rW   zWe want lazy properties to look like multiple things.

    * property when Sphinx autodoc looks
    * lazy_property when Distribution validate_args looks
    NrN   c                 C   s   t | | d S r   )propertyrR   rP   r#   r#   r$   rR      s    z$_lazy_property_and_property.__init__)rY   rZ   r[   r\   r   rJ   rL   rR   r#   r#   r#   r$   rW      s   rW   )matdiagr   c                 C   s   | j d }tj sH|| k s&||krHtd| d|  d|d  dtj|| jd}||dd|d  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.
    r;   zdiag (z) provided is outside [z, rB   z].r)   .)r3   r*   r4   r5   r/   aranger)   view)r^   r_   nra   	tril_maskvecr#   r#   r$   r      s    
"r   )re   r_   r   c                 C   s  dd|   dd|  d d| j d   dt| |d   d  d }t| jj}tj st|| |krt	d| j d  dd	 t
|tjrt| nt|}| | j d
d t||f }tj|| jd}||dd|d  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.
    rB         r;      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.Nr`   .)r3   absr*   rE   r'   rF   r4   r5   roundr/   r   r   itemZ	new_zerosSizera   r)   rb   )re   r_   rc   rF   r^   ra   rd   r#   r#   r$   r      s$    4 "r   )F)F)r   )r   )/collections.abcr   	functoolsr   typingr   r   r   r   r   r	   r
   r   r*   Ztorch.nn.functionalnnZ
functionalr@   r   r   Ztorch.overridesr   Ztorch.typesr   r   r   r   r   float__annotations____all__tupler   intr9   r=   boolr   r   r   rJ   rL   r   r]   rW   r   r   r#   r#   r#   r$   <module>   s2   ( #