
    קg                        d dl Z d dlZd dlZd dlZd dl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mZmZmZmZ d dlmZmZ g dZ G d d          Z G d	 d
e          Z G d de          Z eg           Z G d de          Z G d de          Z G d de          Z G d de          Zd Z G d de          Z  G d de          Z! G d de          Z" G d de          Z# G d de          Z$ G d  d!e          Z% G d" d#e          Z& G d$ d%e          Z' G d& d'e          Z( G d( d)e          Z) G d* d+e          Z* G d, d-e          Z+ G d. d/e          Z,dS )0    N)List)constraints)_sum_rightmostbroadcast_alllazy_propertytril_matrix_to_vecvec_to_tril_matrix)padsoftplus)AbsTransformAffineTransformCatTransformComposeTransformCorrCholeskyTransformCumulativeDistributionTransformExpTransformIndependentTransformLowerCholeskyTransformPositiveDefiniteTransformPowerTransformReshapeTransformSigmoidTransformSoftplusTransformTanhTransformSoftmaxTransformStackTransformStickBreakingTransform	Transformidentity_transformc                        e Zd ZU dZdZej        ed<   ej        ed<   d fd	Zd Z	e
d             Ze
d	             Ze
d
             ZddZd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z xZS )r   a  
    Abstract class for invertable transformations with computable log
    det jacobians. They are primarily used in
    :class:`torch.distributions.TransformedDistribution`.

    Caching is useful for transforms whose inverses are either expensive or
    numerically unstable. Note that care must be taken with memoized values
    since the autograd graph may be reversed. For example while the following
    works with or without caching::

        y = t(x)
        t.log_abs_det_jacobian(x, y).backward()  # x will receive gradients.

    However the following will error when caching due to dependency reversal::

        y = t(x)
        z = t.inv(y)
        grad(z.sum(), [y])  # error because z is x

    Derived classes should implement one or both of :meth:`_call` or
    :meth:`_inverse`. Derived classes that set `bijective=True` should also
    implement :meth:`log_abs_det_jacobian`.

    Args:
        cache_size (int): Size of cache. If zero, no caching is done. If one,
            the latest single value is cached. Only 0 and 1 are supported.

    Attributes:
        domain (:class:`~torch.distributions.constraints.Constraint`):
            The constraint representing valid inputs to this transform.
        codomain (:class:`~torch.distributions.constraints.Constraint`):
            The constraint representing valid outputs to this transform
            which are inputs to the inverse transform.
        bijective (bool): Whether this transform is bijective. A transform
            ``t`` is bijective iff ``t.inv(t(x)) == x`` and
            ``t(t.inv(y)) == y`` for every ``x`` in the domain and ``y`` in
            the codomain. Transforms that are not bijective should at least
            maintain the weaker pseudoinverse properties
            ``t(t.inv(t(x)) == t(x)`` and ``t.inv(t(t.inv(y))) == t.inv(y)``.
        sign (int or Tensor): For bijective univariate transforms, this
            should be +1 or -1 depending on whether transform is monotone
            increasing or decreasing.
    Fdomaincodomainr   c                     || _         d | _        |dk    rn|dk    rd| _        nt          d          t	                                                       d S )Nr      )NNzcache_size must be 0 or 1)_cache_size_inv_cached_x_y
ValueErrorsuper__init__)self
cache_size	__class__s     Z/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/distributions/transforms.pyr*   zTransform.__init___   s]    %	??1__)D8999    c                 B    | j                                         }d |d<   |S )Nr&   )__dict__copy)r+   states     r.   __getstate__zTransform.__getstate__j   s#    ""$$fr/   c                 l    | j         j        | j        j        k    r| j         j        S t          d          )Nz:Please use either .domain.event_dim or .codomain.event_dim)r!   	event_dimr"   r(   r+   s    r.   r6   zTransform.event_dimo   s1    ; DM$;;;;((UVVVr/   c                     d}| j         |                                  }|(t          |           }t          j        |          | _         |S )z{
        Returns the inverse :class:`Transform` of this transform.
        This should satisfy ``t.inv.inv is t``.
        N)r&   _InverseTransformweakrefrefr+   invs     r.   r=   zTransform.invu   sF     9 ))++C;#D))CC((DI
r/   c                     t           )z
        Returns the sign of the determinant of the Jacobian, if applicable.
        In general this only makes sense for bijective transforms.
        NotImplementedErrorr7   s    r.   signzTransform.sign   s
     "!r/   r$   c                     | j         |k    r| S t          |           j        t          j        u r t          |           |          S t	          t          |            d          )Nr,   z.with_cache is not implemented)r%   typer*   r   r@   r+   r,   s     r.   
with_cachezTransform.with_cache   sb    z))K::)"4444::4444!T$ZZ"O"O"OPPPr/   c                 
    | |u S N r+   others     r.   __eq__zTransform.__eq__   s    u}r/   c                 .    |                      |           S rH   )rL   rJ   s     r.   __ne__zTransform.__ne__   s    ;;u%%%%r/   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z2
        Computes the transform `x => y`.
        r   )r%   _callr'   )r+   xx_oldy_oldys        r.   __call__zTransform.__call__   s\     q  ::a== 'u::LJJqMMa4r/   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z1
        Inverts the transform `y => x`.
        r   )r%   _inverser'   )r+   rT   rR   rS   rQ   s        r.   	_inv_callzTransform._inv_call   s`     q  ==###'u::LMM!a4r/   c                     t           )zD
        Abstract method to compute forward transformation.
        r?   r+   rQ   s     r.   rP   zTransform._call   
     "!r/   c                     t           )zD
        Abstract method to compute inverse transformation.
        r?   r+   rT   s     r.   rW   zTransform._inverse   r[   r/   c                     t           )zU
        Computes the log det jacobian `log |dy/dx|` given input and output.
        r?   r+   rQ   rT   s      r.   log_abs_det_jacobianzTransform.log_abs_det_jacobian   r[   r/   c                      | j         j        dz   S )Nz())r-   __name__r7   s    r.   __repr__zTransform.__repr__   s    ~&--r/   c                     |S )z{
        Infers the shape of the forward computation, given the input shape.
        Defaults to preserving shape.
        rI   r+   shapes     r.   forward_shapezTransform.forward_shape   	    
 r/   c                     |S )z}
        Infers the shapes of the inverse computation, given the output shape.
        Defaults to preserving shape.
        rI   re   s     r.   inverse_shapezTransform.inverse_shape   rh   r/   r   r$   )rb   
__module____qualname____doc__	bijectiver   
Constraint__annotations__r*   r4   propertyr6   r=   rA   rF   rL   rN   rU   rX   rP   rW   r`   rc   rg   rj   __classcell__r-   s   @r.   r   r   .   s        * *X I""""$$$$	 	 	 	 	 	  
 W W XW
   X " " X"Q Q Q Q  & & &    " " "" " "" " ". . .        r/   r   c                        e Zd ZdZdef fdZ ej        d          d             Z ej        d          d             Z	e
d             Ze
d	             Ze
d
             ZddZd Zd Zd Zd Zd Zd Z xZS )r9   z|
    Inverts a single :class:`Transform`.
    This class is private; please instead use the ``Transform.inv`` property.
    	transformc                 d    t                                          |j                   || _        d S NrC   )r)   r*   r%   r&   )r+   rw   r-   s     r.   r*   z_InverseTransform.__init__   s,    I$9:::(			r/   Fis_discretec                 ,    | j         J | j         j        S rH   )r&   r"   r7   s    r.   r!   z_InverseTransform.domain   s    y$$$y!!r/   c                 ,    | j         J | j         j        S rH   )r&   r!   r7   s    r.   r"   z_InverseTransform.codomain   s    y$$$yr/   c                 ,    | j         J | j         j        S rH   )r&   rp   r7   s    r.   rp   z_InverseTransform.bijective   s    y$$$y""r/   c                 ,    | j         J | j         j        S rH   )r&   rA   r7   s    r.   rA   z_InverseTransform.sign   s    y$$$y~r/   c                     | j         S rH   )r&   r7   s    r.   r=   z_InverseTransform.inv   s
    yr/   r$   c                 R    | j         J | j                            |          j        S rH   )r&   r=   rF   rE   s     r.   rF   z_InverseTransform.with_cache   s)    y$$$x"":..22r/   c                 b    t          |t                    sdS | j        J | j        |j        k    S NF)
isinstancer9   r&   rJ   s     r.   rL   z_InverseTransform.__eq__   s7    %!233 	5y$$$yEJ&&r/   c                 J    | j         j         dt          | j                   dS )N())r-   rb   reprr&   r7   s    r.   rc   z_InverseTransform.__repr__  s&    .)>>DOO>>>>r/   c                 H    | j         J | j                             |          S rH   )r&   rX   rZ   s     r.   rU   z_InverseTransform.__call__  s&    y$$$y""1%%%r/   c                 L    | j         J | j                             ||           S rH   )r&   r`   r_   s      r.   r`   z&_InverseTransform.log_abs_det_jacobian
  s+    y$$$	..q!4444r/   c                 6    | j                             |          S rH   )r&   rj   re   s     r.   rg   z_InverseTransform.forward_shape      y&&u---r/   c                 6    | j                             |          S rH   )r&   rg   re   s     r.   rj   z_InverseTransform.inverse_shape  r   r/   rl   )rb   rm   rn   ro   r   r*   r   dependent_propertyr!   r"   rs   rp   rA   r=   rF   rL   rc   rU   r`   rg   rj   rt   ru   s   @r.   r9   r9      se        
)) ) ) ) ) ) ) $[#666" " 76" $[#666    76  # # X#   X   X3 3 3 3' ' '? ? ?& & &5 5 5. . .. . . . . . .r/   r9   c                       e Zd ZdZddee         f fdZd Z ej	        d          d             Z
 ej	        d          d	             Zed
             Zed             Zed             ZddZd Zd Zd Zd Zd Z xZS )r   ab  
    Composes multiple transforms in a chain.
    The transforms being composed are responsible for caching.

    Args:
        parts (list of :class:`Transform`): A list of transforms to compose.
        cache_size (int): Size of cache. If zero, no caching is done. If one,
            the latest single value is cached. Only 0 and 1 are supported.
    r   partsc                 |    rfd|D             }t                                                     || _        d S )Nc                 :    g | ]}|                               S rI   rF   ).0partr,   s     r.   
<listcomp>z-ComposeTransform.__init__.<locals>.<listcomp>"  s%    CCCTT__Z00CCCr/   rC   )r)   r*   r   )r+   r   r,   r-   s     `r.   r*   zComposeTransform.__init__   sL     	DCCCCUCCCEJ///


r/   c                 P    t          |t                    sdS | j        |j        k    S r   )r   r   r   rJ   s     r.   rL   zComposeTransform.__eq__&  s)    %!122 	5zU[((r/   Frz   c                    | j         st          j        S | j         d         j        }| j         d         j        j        }t          | j                   D ]8}||j        j        |j        j        z
  z  }t          ||j        j                  }9||j        k    sJ ||j        k    rt          j        |||j        z
            }|S )Nr   )	r   r   realr!   r"   r6   reversedmaxindependent)r+   r!   r6   r   s       r.   r!   zComposeTransform.domain+  s    z 	$##A%JrN+5	TZ(( 	> 	>D.1HHHIIt{'<==IIF,,,,,v''' ,VYAQ5QRRFr/   c                 h   | j         st          j        S | j         d         j        }| j         d         j        j        }| j         D ]8}||j        j        |j        j        z
  z  }t          ||j        j                  }9||j        k    sJ ||j        k    rt          j        |||j        z
            }|S )Nr   r   )r   r   r   r"   r!   r6   r   r   )r+   r"   r6   r   s       r.   r"   zComposeTransform.codomain:  s    z 	$##:b>*JqM(2	J 	@ 	@D04;3HHHIIt}'>??IIH.....x)))".xXEW9WXXHr/   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rH   rp   r   ps     r.   	<genexpr>z-ComposeTransform.bijective.<locals>.<genexpr>K  s$      3311;333333r/   )allr   r7   s    r.   rp   zComposeTransform.bijectiveI  s!    33
333333r/   c                 2    d}| j         D ]}||j        z  }|S Nr$   )r   rA   )r+   rA   r   s      r.   rA   zComposeTransform.signM  s*     	! 	!A!&=DDr/   c                     d }| j         |                                  }|]t          d t          | j                  D                       }t	          j        |          | _         t	          j        |           |_         |S )Nc                     g | ]	}|j         
S rI   )r=   r   s     r.   r   z(ComposeTransform.inv.<locals>.<listcomp>Z  s    #H#H#HaAE#H#H#Hr/   )r&   r   r   r   r:   r;   r<   s     r.   r=   zComposeTransform.invT  sn    9 ))++C;"#H#H8DJ3G3G#H#H#HIICC((DI{4((CH
r/   r$   c                 H    | j         |k    r| S t          | j        |          S ry   )r%   r   r   rE   s     r.   rF   zComposeTransform.with_cache_  s*    z))K
zBBBBr/   c                 0    | j         D ]} ||          }|S rH   )r   )r+   rQ   r   s      r.   rU   zComposeTransform.__call__d  s'    J 	 	DQAAr/   c           	      H   | j         st          j        |          S |g}| j         d d         D ]&}|                     ||d                              '|                    |           g }| j        j        }t          | j         |d d         |dd                    D ]f\  }}}|                    t          |                    ||          ||j        j        z
                       ||j	        j        |j        j        z
  z  }gt          j        t          j        |          S )Nr   r$   )r   torch
zeros_likeappendr!   r6   zipr   r`   r"   	functoolsreduceoperatoradd)r+   rQ   rT   xsr   termsr6   s          r.   r`   z%ComposeTransform.log_abs_det_jacobiani  s'   z 	'#A&&& SJssO 	$ 	$DIIdd2b6ll####
		!K)	dj"SbS'2abb6:: 	I 	IJD!QLL--a33YAV5V   
 04;3HHHIIe444r/   c                 D    | j         D ]}|                    |          }|S rH   )r   rg   r+   rf   r   s      r.   rg   zComposeTransform.forward_shape~  s-    J 	. 	.D&&u--EEr/   c                 ^    t          | j                  D ]}|                    |          }|S rH   )r   r   rj   r   s      r.   rj   zComposeTransform.inverse_shape  s5    TZ(( 	. 	.D&&u--EEr/   c                 |    | j         j        dz   }|d                    d | j        D                       z  }|dz  }|S )Nz(
    z,
    c                 6    g | ]}|                                 S rI   )rc   r   s     r.   r   z-ComposeTransform.__repr__.<locals>.<listcomp>  s     %G%G%Gqajjll%G%G%Gr/   z
))r-   rb   joinr   )r+   
fmt_strings     r.   rc   zComposeTransform.__repr__  sH    ^,y8
inn%G%GDJ%G%G%GHHH
e
r/   rk   rl   )rb   rm   rn   ro   r   r   r*   rL   r   r   r!   r"   r   rp   rA   rs   r=   rF   rU   r`   rg   rj   rc   rt   ru   s   @r.   r   r     sr         d9o      ) ) )
 $[#666  76 $[#666  76 4 4 ]4   ]   XC C C C
  
5 5 5*  
  
      r/   r   c                        e Zd ZdZd fd	ZddZ ej        d          d             Z ej        d          d	             Z	e
d
             Ze
d             Zd Zd Zd Zd Zd Zd Z xZS )r   a  
    Wrapper around another transform to treat
    ``reinterpreted_batch_ndims``-many extra of the right most dimensions as
    dependent. This has no effect on the forward or backward transforms, but
    does sum out ``reinterpreted_batch_ndims``-many of the rightmost dimensions
    in :meth:`log_abs_det_jacobian`.

    Args:
        base_transform (:class:`Transform`): A base transform.
        reinterpreted_batch_ndims (int): The number of extra rightmost
            dimensions to treat as dependent.
    r   c                     t                                          |           |                    |          | _        || _        d S ry   )r)   r*   rF   base_transformreinterpreted_batch_ndims)r+   r   r   r,   r-   s       r.   r*   zIndependentTransform.__init__  sB    J///,77
CC)B&&&r/   r$   c                 T    | j         |k    r| S t          | j        | j        |          S ry   )r%   r   r   r   rE   s     r.   rF   zIndependentTransform.with_cache  s9    z))K#!?J
 
 
 	
r/   Frz   c                 J    t          j        | j        j        | j                  S rH   )r   r   r   r!   r   r7   s    r.   r!   zIndependentTransform.domain  s%    &&(F
 
 	
r/   c                 J    t          j        | j        j        | j                  S rH   )r   r   r   r"   r   r7   s    r.   r"   zIndependentTransform.codomain  s%    &($*H
 
 	
r/   c                     | j         j        S rH   )r   rp   r7   s    r.   rp   zIndependentTransform.bijective  s    ",,r/   c                     | j         j        S rH   )r   rA   r7   s    r.   rA   zIndependentTransform.sign  s    "''r/   c                     |                                 | j        j        k     rt          d          |                     |          S NToo few dimensions on input)dimr!   r6   r(   r   rZ   s     r.   rP   zIndependentTransform._call  s=    5577T[***:;;;""1%%%r/   c                     |                                 | j        j        k     rt          d          | j                            |          S r   )r   r"   r6   r(   r   r=   r]   s     r.   rW   zIndependentTransform._inverse  s@    5577T],,,:;;;"&&q)))r/   c                 f    | j                             ||          }t          || j                  }|S rH   )r   r`   r   r   )r+   rQ   rT   results       r.   r`   z)IndependentTransform.log_abs_det_jacobian  s1    $99!Q??(FGGr/   c                 Z    | j         j         dt          | j                   d| j         dS )Nr   z, r   )r-   rb   r   r   r   r7   s    r.   rc   zIndependentTransform.__repr__  s4    .)jjD1D,E,EjjIgjjjjr/   c                 6    | j                             |          S rH   )r   rg   re   s     r.   rg   z"IndependentTransform.forward_shape      "00777r/   c                 6    | j                             |          S rH   )r   rj   re   s     r.   rj   z"IndependentTransform.inverse_shape  r   r/   rk   rl   )rb   rm   rn   ro   r*   rF   r   r   r!   r"   rs   rp   rA   rP   rW   r`   rc   rg   rj   rt   ru   s   @r.   r   r     sL        C C C C C C

 
 
 
 $[#666
 
 76

 $[#666
 
 76

 - - X- ( ( X(& & &
* * *
  
k k k8 8 88 8 8 8 8 8 8r/   r   c                        e Zd ZdZdZd fd	Zej        d             Zej        d             Z	ddZ
d	 Zd
 Zd Zd Zd Z xZS )r   aM  
    Unit Jacobian transform to reshape the rightmost part of a tensor.

    Note that ``in_shape`` and ``out_shape`` must have the same number of
    elements, just as for :meth:`torch.Tensor.reshape`.

    Arguments:
        in_shape (torch.Size): The input event shape.
        out_shape (torch.Size): The output event shape.
    Tr   c                 6   t          j        |          | _        t          j        |          | _        | j                                        | j                                        k    rt          d          t                                          |           d S )Nz6in_shape, out_shape have different numbers of elementsrC   )r   Sizein_shape	out_shapenumelr(   r)   r*   )r+   r   r   r,   r-   s       r.   r*   zReshapeTransform.__init__  s|    
8,,I..=  DN$8$8$:$:::UVVVJ/////r/   c                 d    t          j        t           j        t          | j                            S rH   )r   r   r   lenr   r7   s    r.   r!   zReshapeTransform.domain  s"    &{'7T]9K9KLLLr/   c                 d    t          j        t           j        t          | j                            S rH   )r   r   r   r   r   r7   s    r.   r"   zReshapeTransform.codomain  s"    &{'7T^9L9LMMMr/   r$   c                 T    | j         |k    r| S t          | j        | j        |          S ry   )r%   r   r   r   rE   s     r.   rF   zReshapeTransform.with_cache  s.    z))Kt~*UUUUr/   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rH   )rf   r   r   r   reshaper   )r+   rQ   batch_shapes      r.   rP   zReshapeTransform._call  sD    g<#dm*<*< <<=yyt~5666r/   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rH   )rf   r   r   r   r   r   )r+   rT   r   s      r.   rW   zReshapeTransform._inverse  sD    g=#dn*=*= ==>yyt}4555r/   c                     |j         d |                                t          | j                  z
           }|                    |          S rH   )rf   r   r   r   	new_zeros)r+   rQ   rT   r   s       r.   r`   z%ReshapeTransform.log_abs_det_jacobian  s=    g<#dm*<*< <<={{;'''r/   c                 @   t          |          t          | j                  k     rt          d          t          |          t          | j                  z
  }||d          | j        k    r"t          d||d           d| j                   |d |         | j        z   S Nr   zShape mismatch: expected z	 but got )r   r   r(   r   r+   rf   cuts      r.   rg   zReshapeTransform.forward_shape  s    u::DM****:;;;%jj3t}---;$-''QE#$$KQQ$-QQ   TcT{T^++r/   c                 @   t          |          t          | j                  k     rt          d          t          |          t          | j                  z
  }||d          | j        k    r"t          d||d           d| j                   |d |         | j        z   S r   )r   r   r(   r   r   s      r.   rj   zReshapeTransform.inverse_shape  s    u::DN++++:;;;%jj3t~...;$.((RE#$$KRR$.RR   TcT{T]**r/   rk   rl   )rb   rm   rn   ro   rp   r*   r   r   r!   r"   rF   rP   rW   r`   rg   rj   rt   ru   s   @r.   r   r     s        	 	 I0 0 0 0 0 0 #M M $#M #N N $#NV V V V
7 7 76 6 6( ( (, , ,+ + + + + + +r/   r   c                   N    e Zd ZdZej        Zej        ZdZ	dZ
d Zd Zd Zd ZdS )	r   z8
    Transform via the mapping :math:`y = \exp(x)`.
    Tr$   c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zExpTransform.__eq__%      %...r/   c                 *    |                                 S rH   )exprZ   s     r.   rP   zExpTransform._call(      uuwwr/   c                 *    |                                 S rH   logr]   s     r.   rW   zExpTransform._inverse+  r   r/   c                     |S rH   rI   r_   s      r.   r`   z!ExpTransform.log_abs_det_jacobian.      r/   Nrb   rm   rn   ro   r   r   r!   positiver"   rp   rA   rL   rP   rW   r`   rI   r/   r.   r   r     sv          F#HID/ / /        r/   r   c                        e Zd ZdZej        Zej        ZdZd fd	Z	ddZ
ed             Zd Zd	 Zd
 Zd Zd Zd Z xZS )r   zD
    Transform via the mapping :math:`y = x^{\text{exponent}}`.
    Tr   c                 x    t                                          |           t          |          \  | _        d S ry   )r)   r*   r   exponent)r+   r   r,   r-   s      r.   r*   zPowerTransform.__init__:  s4    J///(22r/   r$   c                 H    | j         |k    r| S t          | j        |          S ry   )r%   r   r   rE   s     r.   rF   zPowerTransform.with_cache>  s*    z))Kdm
CCCCr/   c                 4    | j                                         S rH   )r   rA   r7   s    r.   rA   zPowerTransform.signC  s    }!!###r/   c                     t          |t                    sdS | j                            |j                                                                                  S r   )r   r   r   eqr   itemrJ   s     r.   rL   zPowerTransform.__eq__G  sI    %00 	5}//3355::<<<r/   c                 6    |                     | j                  S rH   powr   rZ   s     r.   rP   zPowerTransform._callL  s    uuT]###r/   c                 <    |                     d| j        z            S r   r   r]   s     r.   rW   zPowerTransform._inverseO  s    uuQ&'''r/   c                 d    | j         |z  |z                                                                  S rH   )r   absr   r_   s      r.   r`   z#PowerTransform.log_abs_det_jacobianR  s,    !A%**,,00222r/   c                 T    t          j        |t          | j        dd                    S Nrf   rI   r   broadcast_shapesgetattrr   re   s     r.   rg   zPowerTransform.forward_shapeU  #    %eWT]GR-P-PQQQr/   c                 T    t          j        |t          | j        dd                    S r  r  re   s     r.   rj   zPowerTransform.inverse_shapeX  r  r/   rk   rl   )rb   rm   rn   ro   r   r   r!   r"   rp   r*   rF   r   rA   rL   rP   rW   r`   rg   rj   rt   ru   s   @r.   r   r   2  s          !F#HI3 3 3 3 3 3D D D D
 $ $ ]$= = =
$ $ $( ( (3 3 3R R RR R R R R R Rr/   r   c                     t          j        | j                  }t          j        t          j        |           |j        d|j        z
            S N      ?minr   )r   finfodtypeclampsigmoidtinyeps)rQ   r  s     r.   _clipped_sigmoidr  \  s<    K  E;u}Q''UZS59_MMMMr/   c                   N    e Zd ZdZej        Zej        ZdZ	dZ
d Zd Zd Zd ZdS )	r   zg
    Transform via the mapping :math:`y = \frac{1}{1 + \exp(-x)}` and :math:`x = \text{logit}(y)`.
    Tr$   c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zSigmoidTransform.__eq__j      %!1222r/   c                      t          |          S rH   )r  rZ   s     r.   rP   zSigmoidTransform._callm  s    """r/   c                     t          j        |j                  }|                    |j        d|j        z
            }|                                |                                 z
  S r
  )r   r  r  r  r  r  r   log1p)r+   rT   r  s      r.   rW   zSigmoidTransform._inversep  sM    AG$$GG
eiG88uuww1"%%r/   c                 X    t          j        |            t          j        |          z
  S rH   )Fr   r_   s      r.   r`   z%SigmoidTransform.log_abs_det_jacobianu  s!    
A2A..r/   N)rb   rm   rn   ro   r   r   r!   unit_intervalr"   rp   rA   rL   rP   rW   r`   rI   r/   r.   r   r   a  sv          F(HID3 3 3# # #& & &
/ / / / /r/   r   c                   N    e Zd ZdZej        Zej        ZdZ	dZ
d Zd Zd Zd ZdS )	r   z
    Transform via the mapping :math:`\text{Softplus}(x) = \log(1 + \exp(x))`.
    The implementation reverts to the linear function when :math:`x > 20`.
    Tr$   c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zSoftplusTransform.__eq__  s    %!2333r/   c                      t          |          S rH   r   rZ   s     r.   rP   zSoftplusTransform._call  s    {{r/   c                 z    |                                                                                                  |z   S rH   )expm1negr   r]   s     r.   rW   zSoftplusTransform._inverse  s/    zz||!!%%''!++r/   c                 $    t          |            S rH   r!  r_   s      r.   r`   z&SoftplusTransform.log_abs_det_jacobian  s    !}r/   Nr   rI   r/   r.   r   r   y  sv          F#HID4 4 4  , , ,    r/   r   c                   b    e Zd ZdZej        Z ej        dd          ZdZ	dZ
d Zd Zd Zd	 Zd
S )r   a~  
    Transform via the mapping :math:`y = \tanh(x)`.

    It is equivalent to
    ```
    ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)])
    ```
    However this might not be numerically stable, thus it is recommended to use `TanhTransform`
    instead.

    Note that one should use `cache_size=1` when it comes to `NaN/Inf` values.

    g      r  Tr$   c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zTanhTransform.__eq__  s    %///r/   c                 *    |                                 S rH   )tanhrZ   s     r.   rP   zTanhTransform._call  s    vvxxr/   c                 *    t          j        |          S rH   )r   atanhr]   s     r.   rW   zTanhTransform._inverse  s     {1~~r/   c                 \    dt          j        d          |z
  t          d|z            z
  z  S )N       @g       )mathr   r   r_   s      r.   r`   z"TanhTransform.log_abs_det_jacobian  s-     dhsmma'(4!8*<*<<==r/   N)rb   rm   rn   ro   r   r   r!   intervalr"   rp   rA   rL   rP   rW   r`   rI   r/   r.   r   r     s          F#{#D#..HID0 0 0    
> > > > >r/   r   c                   @    e Zd ZdZej        Zej        Zd Z	d Z
d ZdS )r   z4
    Transform via the mapping :math:`y = |x|`.
    c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zAbsTransform.__eq__  r   r/   c                 *    |                                 S rH   )r  rZ   s     r.   rP   zAbsTransform._call  r   r/   c                     |S rH   rI   r]   s     r.   rW   zAbsTransform._inverse  r   r/   N)rb   rm   rn   ro   r   r   r!   r   r"   rL   rP   rW   rI   r/   r.   r   r     s]          F#H/ / /      r/   r   c                        e Zd ZdZdZd fd	Zed             Z ej	        d          d             Z
 ej	        d          d	             ZddZd Zed             Zd Zd Zd Zd Zd Z xZS )r   a  
    Transform via the pointwise affine mapping :math:`y = \text{loc} + \text{scale} \times x`.

    Args:
        loc (Tensor or float): Location parameter.
        scale (Tensor or float): Scale parameter.
        event_dim (int): Optional size of `event_shape`. This should be zero
            for univariate random variables, 1 for distributions over vectors,
            2 for distributions over matrices, etc.
    Tr   c                 v    t                                          |           || _        || _        || _        d S ry   )r)   r*   locscale
_event_dim)r+   r6  r7  r6   r,   r-   s        r.   r*   zAffineTransform.__init__  s7    J///
#r/   c                     | j         S rH   )r8  r7   s    r.   r6   zAffineTransform.event_dim  s
    r/   Frz   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S Nr   r6   r   r   r   r7   s    r.   r!   zAffineTransform.domain  0    >Q##&{'7HHHr/   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S r;  r<  r7   s    r.   r"   zAffineTransform.codomain  r=  r/   r$   c                 `    | j         |k    r| S t          | j        | j        | j        |          S ry   )r%   r   r6  r7  r6   rE   s     r.   rF   zAffineTransform.with_cache  s;    z))KHdj$.Z
 
 
 	
r/   c                 P   t          |t                    sdS t          | j        t          j                  r2t          |j        t          j                  r| j        |j        k    rdS n6| j        |j        k                                                                    sdS t          | j        t          j                  r2t          |j        t          j                  r| j        |j        k    rdS n6| j        |j        k                                                                    sdS dS )NFT)r   r   r6  numbersNumberr   r   r7  rJ   s     r.   rL   zAffineTransform.__eq__  s   %11 	5dh// 	JIw~5
 5
 	 x59$$u % H	)..005577 udj'.11 	jK7
 7
 	 zU[((u ) J%+-224499;; utr/   c                     t          | j        t          j                  r6t	          | j                  dk    rdnt	          | j                  dk     rdndS | j                                        S )Nr   r$   r   )r   r7  rA  RealfloatrA   r7   s    r.   rA   zAffineTransform.sign  sb    dj',// 	Vdj))A--11tz9J9JQ9N9N22TUUz   r/   c                 &    | j         | j        |z  z   S rH   r6  r7  rZ   s     r.   rP   zAffineTransform._call  s    x$*q.((r/   c                 &    || j         z
  | j        z  S rH   rG  r]   s     r.   rW   zAffineTransform._inverse  s    DH
**r/   c                    |j         }| j        }t          |t          j                  r5t          j        |t          j        t          |                              }n&t          j	        |                                          }| j
        r]|                                d | j
                  dz   }|                    |                              d          }|d | j
                  }|                    |          S )N)r   r   )rf   r7  r   rA  rD  r   	full_liker.  r   r  r6   sizeviewsumexpand)r+   rQ   rT   rf   r7  r   result_sizes          r.   r`   z$AffineTransform.log_abs_det_jacobian  s    
eW\** 	,_QU(<(<==FFYu%%))++F> 	- ++--(94>/(9:UBK[[--11"55F+T^O+,E}}U###r/   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  r   r  r  r6  r7  re   s     r.   rg   zAffineTransform.forward_shape   ;    %748Wb1174:wPR3S3S
 
 	
r/   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  rQ  re   s     r.   rj   zAffineTransform.inverse_shape%  rR  r/   r   r   rl   )rb   rm   rn   ro   rp   r*   rs   r6   r   r   r!   r"   rF   rL   rA   rP   rW   r`   rg   rj   rt   ru   s   @r.   r   r     sP       	 	 I$ $ $ $ $ $   X $[#666I I 76I
 $[#666I I 76I

 
 
 
  0 ! ! X!
) ) )+ + +$ $ $
 
 


 
 
 
 
 
 
r/   r   c                   R    e Zd ZdZej        Zej        ZdZ	d Z
d Zd	dZd Zd ZdS )
r   a  
    Transforms an uncontrained real vector :math:`x` with length :math:`D*(D-1)/2` into the
    Cholesky factor of a D-dimension correlation matrix. This Cholesky factor is a lower
    triangular matrix with positive diagonals and unit Euclidean norm for each row.
    The transform is processed as follows:

        1. First we convert x into a lower triangular matrix in row order.
        2. For each row :math:`X_i` of the lower triangular part, we apply a *signed* version of
           class :class:`StickBreakingTransform` to transform :math:`X_i` into a
           unit Euclidean length vector using the following steps:
           - Scales into the interval :math:`(-1, 1)` domain: :math:`r_i = \tanh(X_i)`.
           - Transforms into an unsigned domain: :math:`z_i = r_i^2`.
           - Applies :math:`s_i = StickBreakingTransform(z_i)`.
           - Transforms back into signed domain: :math:`y_i = sign(r_i) * \sqrt{s_i}`.
    Tc                    t          j        |          }t          j        |j                  j        }|                    d|z   d|z
            }t          |d          }|dz  }d|z
                                                      d          }|t          j	        |j
        d         |j        |j                  z   }|t          |dd df         ddgd	          z  }|S )
Nr   r$   r  diag   )r  device.r   value)r   r)  r  r  r  r  r	   sqrtcumprodeyerf   rZ  r
   )r+   rQ   r  rzz1m_cumprod_sqrtrT   s          r.   rP   zCorrCholeskyTransform._call?  s    JqMMk!'""&GGSa#gG..qr*** qDE<<>>11"55	!'"+QWQXFFFF$S#2#X.Aa@@@@r/   c                 h   dt          j        ||z  d          z
  }t          |dd df         ddgd          }t          |d          }t          |d          }||                                z  }|                                |                                                                z
  dz  }|S )	Nr$   r   r   .r   r[  rW  rY  )r   cumsumr
   r   r]  r  r$  )r+   rT   y_cumsumy_cumsum_shiftedy_vecy_cumsum_vectrQ   s           r.   rW   zCorrCholeskyTransform._inverseN  s     u|AEr2222xSbS1Aq6CCC"12...)*:DDD\'')))WWYY(A-r/   Nc                 <   d||z                       d          z
  }t          |d          }d|                                                    d          z  }d|t	          d|z            z   t          j        d          z
                      d          z  }||z   S )Nr$   r   rd  rW        ?r-  )re  r   r   rM  r   r.  )r+   rQ   rT   intermediates
y1m_cumsumy1m_cumsum_trilstick_breaking_logdettanh_logdets           r.   r`   z*CorrCholeskyTransform.log_abs_det_jacobianZ  s     !a%B///
 -ZbAAA #&;&;&=&=&A&A"&E&E EAa 0 0048C==@EE"EMMM${22r/   c                     t          |          dk     rt          d          |d         }t          dd|z  z   dz  dz             }||dz
  z  dz  |k    rt          d          |d d         ||fz   S )Nr$   r   r   g      ?rY  rm  z-Input is not a flattend lower-diagonal number)r   r(   round)r+   rf   NDs       r.   rg   z#CorrCholeskyTransform.forward_shapeh  s    u::>>:;;;"I4!a%<C'#-..A;!q  LMMMSbSzQF""r/   c                     t          |          dk     rt          d          |d         |d         k    rt          d          |d         }||dz
  z  dz  }|d d         |fz   S )NrY  r   rl  r   zInput is not squarer$   r   r(   )r+   rf   rv  ru  s       r.   rj   z#CorrCholeskyTransform.inverse_shaper  sr    u::>>:;;;9b	!!2333"IQK1SbSzQD  r/   rH   )rb   rm   rn   ro   r   real_vectorr!   corr_choleskyr"   rp   rP   rW   r`   rg   rj   rI   r/   r.   r   r   +  s          $F(HI  
 
 
3 3 3 3# # #! ! ! ! !r/   r   c                   L    e Zd ZdZej        Zej        Zd Z	d Z
d Zd Zd ZdS )r   a<  
    Transform from unconstrained space to the simplex via :math:`y = \exp(x)` then
    normalizing.

    This is not bijective and cannot be used for HMC. However this acts mostly
    coordinate-wise (except for the final normalization), and thus is
    appropriate for coordinate-wise optimization algorithms.
    c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zSoftmaxTransform.__eq__  r  r/   c                     |}||                     dd          d         z
                                  }||                    dd          z  S )Nr   Tr   )r   r   rM  )r+   rQ   logprobsprobss       r.   rP   zSoftmaxTransform._call  sI    HLLT22155::<<uyyT****r/   c                 .    |}|                                 S rH   r   )r+   rT   r  s      r.   rW   zSoftmaxTransform._inverse  s    yy{{r/   c                 J    t          |          dk     rt          d          |S Nr$   r   rx  re   s     r.   rg   zSoftmaxTransform.forward_shape  %    u::>>:;;;r/   c                 J    t          |          dk     rt          d          |S r  rx  re   s     r.   rj   zSoftmaxTransform.inverse_shape  r  r/   N)rb   rm   rn   ro   r   ry  r!   simplexr"   rL   rP   rW   rg   rj   rI   r/   r.   r   r   }  s{          $F"H3 3 3+ + +
    
    r/   r   c                   V    e Zd ZdZej        Zej        ZdZ	d Z
d Zd Zd Zd Zd Zd	S )
r   a  
    Transform from unconstrained space to the simplex of one additional
    dimension via a stick-breaking process.

    This transform arises as an iterated sigmoid transform in a stick-breaking
    construction of the `Dirichlet` distribution: the first logit is
    transformed via sigmoid to the first probability and the probability of
    everything else, and then the process recurses.

    This is bijective and appropriate for use in HMC; however it mixes
    coordinates together and is less appropriate for optimization.
    Tc                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zStickBreakingTransform.__eq__      %!7888r/   c                 X   |j         d         dz   |                    |j         d                                       d          z
  }t          ||                                z
            }d|z
                      d          }t          |ddgd          t          |ddgd          z  }|S )Nr   r$   r   r[  )rf   new_onesre  r  r   r^  r
   )r+   rQ   offsetra  	z_cumprodrT   s         r.   rP   zStickBreakingTransform._call  s    q1::agbk#:#:#A#A"#E#EEQ-..UOOB''	Aq6###c)aV1&E&E&EEr/   c                    |dd df         }|j         d         |                    |j         d                                       d          z
  }d|                    d          z
  }t          j        |t          j        |j                  j                  }|                                |                                z
  |                                z   }|S )N.r   r$   )r  )	rf   r  re  r   r  r  r  r  r   )r+   rT   y_cropr  sfrQ   s         r.   rW   zStickBreakingTransform._inverse  s    38qzz&,r*:;;BB2FFFr""" [QW!5!5!:;;;JJLL26688#fjjll2r/   c                 P   |j         d         dz   |                    |j         d                                       d          z
  }||                                z
  }| t	          j        |          z   |dd df                                         z                       d          }|S )Nr   r$   .)rf   r  re  r   r  
logsigmoidrM  )r+   rQ   rT   r  detJs        r.   r`   z+StickBreakingTransform.log_abs_det_jacobian  s    q1::agbk#:#:#A#A"#E#EE

Q\!__$qcrc{'8'88==bAAr/   c                 t    t          |          dk     rt          d          |d d         |d         dz   fz   S Nr$   r   r   rx  re   s     r.   rg   z$StickBreakingTransform.forward_shape  >    u::>>:;;;SbSzU2Y],,,r/   c                 t    t          |          dk     rt          d          |d d         |d         dz
  fz   S r  rx  re   s     r.   rj   z$StickBreakingTransform.inverse_shape  r  r/   N)rb   rm   rn   ro   r   ry  r!   r  r"   rp   rL   rP   rW   r`   rg   rj   rI   r/   r.   r   r     s          $F"HI9 9 9      - - -
- - - - -r/   r   c                   ^    e Zd ZdZ ej        ej        d          Zej        Z	d Z
d Zd ZdS )r   z
    Transform from unconstrained matrices to lower-triangular matrices with
    nonnegative diagonal entries.

    This is useful for parameterizing positive definite matrices in terms of
    their Cholesky factorization.
    rY  c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   zLowerCholeskyTransform.__eq__  r  r/   c                     |                     d          |                    dd                                                                          z   S Nr   rl  )dim1dim2)trildiagonalr   
diag_embedrZ   s     r.   rP   zLowerCholeskyTransform._call  ?    vvbzzAJJBRJ88<<>>IIKKKKr/   c                     |                     d          |                    dd                                                                          z   S r  )r  r  r   r  r]   s     r.   rW   zLowerCholeskyTransform._inverse  r  r/   N)rb   rm   rn   ro   r   r   r   r!   lower_choleskyr"   rL   rP   rW   rI   r/   r.   r   r     st          %[$[%5q99F)H9 9 9L L LL L L L Lr/   r   c                   ^    e Zd ZdZ ej        ej        d          Zej        Z	d Z
d Zd ZdS )r   zN
    Transform from unconstrained matrices to positive-definite matrices.
    rY  c                 ,    t          |t                    S rH   )r   r   rJ   s     r.   rL   z PositiveDefiniteTransform.__eq__  s    %!:;;;r/   c                 D     t                      |          }||j        z  S rH   )r   mTrZ   s     r.   rP   zPositiveDefiniteTransform._call  s#    $"$$Q''14xr/   c                     t           j                            |          }t                                          |          S rH   )r   linalgcholeskyr   r=   r]   s     r.   rW   z"PositiveDefiniteTransform._inverse  s1    L!!!$$%''++A...r/   N)rb   rm   rn   ro   r   r   r   r!   positive_definiter"   rL   rP   rW   rI   r/   r.   r   r     sl          %[$[%5q99F,H< < <  / / / / /r/   r   c                        e Zd ZU dZee         ed<   d fd	Zed             Z	ed             Z
dd	Zd
 Zd Zd Zed             Zej        d             Zej        d             Z xZS )r   a  
    Transform functor that applies a sequence of transforms `tseq`
    component-wise to each submatrix at `dim`, of length `lengths[dim]`,
    in a way compatible with :func:`torch.cat`.

    Example::

       x0 = torch.cat([torch.range(1, 10), torch.range(1, 10)], dim=0)
       x = torch.cat([x0, x0], dim=0)
       t0 = CatTransform([ExpTransform(), identity_transform], dim=0, lengths=[10, 10])
       t = CatTransform([t0, t0], dim=0, lengths=[20, 20])
       y = t(x)
    
transformsr   Nc                    t          d |D                       sJ rfd|D             }t                                                     t          |          | _        |dgt          | j                  z  }t          |          | _        t          | j                  t          | j                  k    sJ || _        d S )Nc              3   @   K   | ]}t          |t                    V  d S rH   r   r   r   rj  s     r.   r   z(CatTransform.__init__.<locals>.<genexpr>  ,      :::a++::::::r/   c                 :    g | ]}|                               S rI   r   r   rj  r,   s     r.   r   z)CatTransform.__init__.<locals>.<listcomp>  %    ;;;ALL,,;;;r/   rC   r$   )r   r)   r*   listr  r   lengthsr   )r+   tseqr   r  r,   r-   s       `r.   r*   zCatTransform.__init__  s    ::T:::::::: 	<;;;;d;;;DJ///t**?cC000GG}}4<  C$8$88888r/   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rH   )r6   r  s     r.   r   z)CatTransform.event_dim.<locals>.<genexpr>!  $      8811;888888r/   )r   r  r7   s    r.   r6   zCatTransform.event_dim  !    88888888r/   c                 *    t          | j                  S rH   )rM  r  r7   s    r.   lengthzCatTransform.length#  s    4<   r/   r$   c                 ^    | j         |k    r| S t          | j        | j        | j        |          S rH   )r%   r   r  r   r  rE   s     r.   rF   zCatTransform.with_cache'  s/    z))KDOTXt|ZPPPr/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   | j        k    sJ g }d}t          | j        | j                  D ]D\  }}|                    | j         ||          }|                     ||                     ||z   }Et          j	        || j                   S Nr   rd  )
r   rK  r  r   r  r  narrowr   r   cat)r+   rQ   yslicesstarttransr  xslices          r.   rP   zCatTransform._call,  s    x48----aeegg------vvdh4;.... $,?? 	# 	#ME6XXdhv66FNN55==)))FNEEydh////r/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   | j        k    sJ g }d}t          | j        | j                  D ]N\  }}|                    | j         ||          }|                    |                    |                     ||z   }Ot          j
        || j                   S r  )r   rK  r  r   r  r  r  r   r=   r   r  )r+   rT   xslicesr  r  r  yslices          r.   rW   zCatTransform._inverse7  s    x48----aeegg------vvdh4;.... $,?? 	# 	#ME6XXdhv66FNN599V,,---FNEEydh////r/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   | j        k    sJ |                                  | j         cxk    r|                                 k     sn J |                    | j                   | j        k    sJ g }d}t          | j        | j                  D ]\  }}|                    | j         ||          }|                    | j         ||          }|                    ||          }	|j        | j        k     rt          |	| j        |j        z
            }	|
                    |	           ||z   }| j         }
|
dk    r|
|                                 z
  }
|
| j        z   }
|
dk     rt          j        ||
          S t          |          S r  )r   rK  r  r   r  r  r  r`   r6   r   r   r   r  rM  )r+   rQ   rT   
logdetjacsr  r  r  r  r  	logdetjacr   s              r.   r`   z!CatTransform.log_abs_det_jacobianB  s   x48----aeegg------vvdh4;....x48----aeegg------vvdh4;....
 $,?? 	# 	#ME6XXdhv66FXXdhv66F2266BBI//*9dnu6VWW	i(((FNEEh!88-CDN"779ZS1111z??"r/   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rH   r   r  s     r.   r   z)CatTransform.bijective.<locals>.<genexpr>]  r  r/   r   r  r7   s    r.   rp   zCatTransform.bijective[  r  r/   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rI   r!   r  s     r.   r   z'CatTransform.domain.<locals>.<listcomp>b  s    ///!QX///r/   r   r  r  r   r  r7   s    r.   r!   zCatTransform.domain_  s1    //t///4<
 
 	
r/   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rI   r"   r  s     r.   r   z)CatTransform.codomain.<locals>.<listcomp>h  s    111AQZ111r/   r  r7   s    r.   r"   zCatTransform.codomaine  s1    1111148T\
 
 	
r/   )r   Nr   rl   )rb   rm   rn   ro   r   r   rr   r*   r   r6   r  rF   rP   rW   r`   rs   rp   r   r   r!   r"   rt   ru   s   @r.   r   r     s/          Y
 
 
 
 
 
 9 9 ]9 ! ! ]!Q Q Q Q
	0 	0 	0	0 	0 	0# # #2 9 9 X9 #
 
 $#

 #
 
 $#
 
 
 
 
r/   r   c                        e Zd ZU dZee         ed<   d fd	ZddZd Z	d Z
d	 Zd
 Zed             Zej        d             Zej        d             Z xZS )r   aW  
    Transform functor that applies a sequence of transforms `tseq`
    component-wise to each submatrix at `dim`
    in a way compatible with :func:`torch.stack`.

    Example::

       x = torch.stack([torch.range(1, 10), torch.range(1, 10)], dim=1)
       t = StackTransform([ExpTransform(), identity_transform], dim=1)
       y = t(x)
    r  r   c                     t          d |D                       sJ rfd|D             }t                                                     t          |          | _        || _        d S )Nc              3   @   K   | ]}t          |t                    V  d S rH   r  r  s     r.   r   z*StackTransform.__init__.<locals>.<genexpr>|  r  r/   c                 :    g | ]}|                               S rI   r   r  s     r.   r   z+StackTransform.__init__.<locals>.<listcomp>~  r  r/   rC   )r   r)   r*   r  r  r   )r+   r  r   r,   r-   s      `r.   r*   zStackTransform.__init__{  s{    ::T:::::::: 	<;;;;d;;;DJ///t**r/   r$   c                 R    | j         |k    r| S t          | j        | j        |          S rH   )r%   r   r  r   rE   s     r.   rF   zStackTransform.with_cache  s+    z))KdotxDDDr/   c                 n      fdt                               j                            D             S )Nc                 F    g | ]}                     j        |          S rI   )selectr   )r   ir+   ra  s     r.   r   z)StackTransform._slice.<locals>.<listcomp>  s)    GGG!1%%GGGr/   )rangerK  r   )r+   ra  s   ``r.   _slicezStackTransform._slice  s7    GGGGGuQVVDH5E5E/F/FGGGGr/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   t          | j                  k    sJ g }t	          |                     |          | j                  D ]#\  }}|                     ||                     $t          j        || j                   S Nrd  )	r   rK  r   r  r   r  r   r   stack)r+   rQ   r  r  r  s        r.   rP   zStackTransform._call  s    x48----aeegg------vvdh3t#7#77777 QAA 	* 	*MFENN55==)))){71111r/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   t          | j                  k    sJ g }t	          |                     |          | j                  D ]-\  }}|                    |                    |                     .t          j	        || j                   S r  )
r   rK  r   r  r   r  r   r=   r   r  )r+   rT   r  r  r  s        r.   rW   zStackTransform._inverse  s    x48----aeegg------vvdh3t#7#77777 QAA 	. 	.MFENN599V,,----{71111r/   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   t          | j                  k    sJ |                                  | j         cxk    r|                                 k     sn J |                    | j                   t          | j                  k    sJ g }|                     |          }|                     |          }t          ||| j                  D ]/\  }}}|                    |                    ||                     0t          j	        || j                   S r  )
r   rK  r   r  r  r   r   r`   r   r  )	r+   rQ   rT   r  r  r  r  r  r  s	            r.   r`   z#StackTransform.log_abs_det_jacobian  sM   x48----aeegg------vvdh3t#7#77777x48----aeegg------vvdh3t#7#77777
++a..++a..%('4?%K%K 	J 	J!FFEe88HHIIII{:484444r/   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rH   r   r  s     r.   r   z+StackTransform.bijective.<locals>.<genexpr>  r  r/   r  r7   s    r.   rp   zStackTransform.bijective  r  r/   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rI   r  r  s     r.   r   z)StackTransform.domain.<locals>.<listcomp>  s    !D!D!Dq!(!D!D!Dr/   r   r  r  r   r7   s    r.   r!   zStackTransform.domain  s(     !D!DDO!D!D!DdhOOOr/   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rI   r  r  s     r.   r   z+StackTransform.codomain.<locals>.<listcomp>  s    !F!F!F!*!F!F!Fr/   r  r7   s    r.   r"   zStackTransform.codomain  s(     !F!Fdo!F!F!FQQQr/   rT  rl   )rb   rm   rn   ro   r   r   rr   r*   rF   r  rP   rW   r`   rs   rp   r   r   r!   r"   rt   ru   s   @r.   r   r   l  s        
 
 Y     E E E E
H H H2 2 22 2 2
5 
5 
5 9 9 X9 #P P $#P #R R $#R R R R Rr/   r   c                   j     e Zd ZdZdZej        ZdZd fd	Z	e
d             Zd Zd Zd	 Zdd
Z xZS )r   aA  
    Transform via the cumulative distribution function of a probability distribution.

    Args:
        distribution (Distribution): Distribution whose cumulative distribution function to use for
            the transformation.

    Example::

        # Construct a Gaussian copula from a multivariate normal.
        base_dist = MultivariateNormal(
            loc=torch.zeros(2),
            scale_tril=LKJCholesky(2).sample(),
        )
        transform = CumulativeDistributionTransform(Normal(0, 1))
        copula = TransformedDistribution(base_dist, [transform])
    Tr$   r   c                 Z    t                                          |           || _        d S ry   )r)   r*   distribution)r+   r  r,   r-   s      r.   r*   z(CumulativeDistributionTransform.__init__  s,    J///(r/   c                     | j         j        S rH   )r  supportr7   s    r.   r!   z&CumulativeDistributionTransform.domain  s     ((r/   c                 6    | j                             |          S rH   )r  cdfrZ   s     r.   rP   z%CumulativeDistributionTransform._call  s     $$Q'''r/   c                 6    | j                             |          S rH   )r  icdfr]   s     r.   rW   z(CumulativeDistributionTransform._inverse  s     %%a(((r/   c                 6    | j                             |          S rH   )r  log_probr_   s      r.   r`   z4CumulativeDistributionTransform.log_abs_det_jacobian  s     ))!,,,r/   c                 H    | j         |k    r| S t          | j        |          S ry   )r%   r   r  rE   s     r.   rF   z*CumulativeDistributionTransform.with_cache  s+    z))K.t/@ZXXXXr/   rk   rl   )rb   rm   rn   ro   rp   r   r  r"   rA   r*   rs   r!   rP   rW   r`   rF   rt   ru   s   @r.   r   r     s         $ I(HD) ) ) ) ) ) ) ) X)( ( () ) )- - -Y Y Y Y Y Y Y Yr/   r   )-r   r.  rA  r   r:   typingr   r   torch.nn.functionalnn
functionalr  torch.distributionsr   torch.distributions.utilsr   r   r   r   r	   r
   r   __all__r   r9   r   r   r   r   r   r   r  r   r   r   r   r   r   r   r   r   r   r   r   r   rI   r/   r.   <module>r     s                           + + + + + +              . - - - - - - -  0f f f f f f f fR;. ;. ;. ;. ;.	 ;. ;. ;.|w w w w wy w w wt &%b)) D8 D8 D8 D8 D89 D8 D8 D8N@+ @+ @+ @+ @+y @+ @+ @+F    9   ,'R 'R 'R 'R 'RY 'R 'R 'RTN N N
/ / / / /y / / /0    	   .!> !> !> !> !>I !> !> !>H    9   "c
 c
 c
 c
 c
i c
 c
 c
LO! O! O! O! O!I O! O! O!d         y      F5- 5- 5- 5- 5-Y 5- 5- 5-pL L L L LY L L L,/ / / / /	 / / /(g
 g
 g
 g
 g
9 g
 g
 g
TER ER ER ER ERY ER ER ERP+Y +Y +Y +Y +Yi +Y +Y +Y +Y +Yr/   