
    }Yh                     
   d dl Z d dlZd dlZd dlZd dlmZ d dlmZ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 dlmZmZmZmZmZ d dl
mZmZ d d	l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          Z0 G d. d/e          Z1 G d0 d1e          Z2 G d2 d3e          Z3dS )4    N)Sequence)OptionalUnion)Tensor)constraints)Distribution)_sum_rightmostbroadcast_alllazy_propertytril_matrix_to_vecvec_to_tril_matrix)padsoftplus)_Number)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deddf fd	Z	d
 Z
edefd            Zedd            Zedef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   
cache_sizereturnNc                     || _         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__)selfr(   	__class__s     p/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/torch/distributions/transforms.pyr1   zTransform.__init__b   s]    %@D	??1__)D8999    c                 B    | j                                         }d |d<   |S )Nr-   )__dict__copy)r2   states     r4   __getstate__zTransform.__getstate__m   s#    ""$$fr5   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/   r2   s    r4   r<   zTransform.event_dimr   s1    ; DM$;;;;((UVVVr5   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r2   invs     r4   rC   zTransform.invx   sF     9 ))++C;#D))CC((DI
r5   c                     t           )z
        Returns the sign of the determinant of the Jacobian, if applicable.
        In general this only makes sense for bijective transforms.
        NotImplementedErrorr=   s    r4   signzTransform.sign   s
     "!r5   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,   typer1   r#   rF   r2   r(   s     r4   
with_cachezTransform.with_cache   sb    z))K::)"4444::4444!T$ZZ"O"O"OPPPr5   c                 
    | |u S N r2   others     r4   __eq__zTransform.__eq__   s    u}r5   c                 .    |                      |           S rN   )rR   rP   s     r4   __ne__zTransform.__ne__   s    ;;u%%%%r5   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z2
        Computes the transform `x => y`.
        r   )r,   _callr.   )r2   xx_oldy_oldys        r4   __call__zTransform.__call__   s\     q  ::a== 'u::LJJqMMa4r5   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z1
        Inverts the transform `y => x`.
        r   )r,   _inverser.   )r2   rZ   rX   rY   rW   s        r4   	_inv_callzTransform._inv_call   s`     q  ==###'u::LMM!a4r5   c                     t           )zD
        Abstract method to compute forward transformation.
        rE   r2   rW   s     r4   rV   zTransform._call   
     "!r5   c                     t           )zD
        Abstract method to compute inverse transformation.
        rE   r2   rZ   s     r4   r]   zTransform._inverse   ra   r5   c                     t           )zU
        Computes the log det jacobian `log |dy/dx|` given input and output.
        rE   r2   rW   rZ   s      r4   log_abs_det_jacobianzTransform.log_abs_det_jacobian   ra   r5   c                      | j         j        dz   S )Nz())r3   __name__r=   s    r4   __repr__zTransform.__repr__   s    ~&--r5   c                     |S )z{
        Infers the shape of the forward computation, given the input shape.
        Defaults to preserving shape.
        rO   r2   shapes     r4   forward_shapezTransform.forward_shape   	    
 r5   c                     |S )z}
        Infers the shapes of the inverse computation, given the output shape.
        Defaults to preserving shape.
        rO   rk   s     r4   inverse_shapezTransform.inverse_shape   rn   r5   r   )r)   r#   r+   )rh   
__module____qualname____doc__	bijectiver   
Constraint__annotations__intr1   r:   propertyr<   rC   rG   rL   rR   rT   r[   r^   rV   r]   rf   ri   rm   rp   __classcell__r3   s   @r4   r#   r#   1   s        * *X I""""$$$$	 	3 	t 	 	 	 	 	 	  
 W3 W W W XW
    X "c " " " X"Q Q Q Q  & & &    " " "" " "" " ". . .        r5   r#   c                       e Zd ZdZdeddf fdZ ej        d          d             Z ej        d          d	             Z	e
defd
            Ze
defd            Ze
defd            ZddZd Zd Zd Zd Zd Zd Z xZS )r?   z|
    Inverts a single :class:`Transform`.
    This class is private; please instead use the ``Transform.inv`` property.
    	transformr)   Nc                 d    t                                          |j                   || _        d S NrI   )r0   r1   r,   r-   )r2   r~   r3   s     r4   r1   z_InverseTransform.__init__   s,    I$9:::(			r5   Fis_discretec                 ,    | j         J | j         j        S rN   )r-   r'   r=   s    r4   r&   z_InverseTransform.domain   s    y$$$y!!r5   c                 ,    | j         J | j         j        S rN   )r-   r&   r=   s    r4   r'   z_InverseTransform.codomain   s    y$$$yr5   c                 ,    | j         J | j         j        S rN   )r-   rv   r=   s    r4   rv   z_InverseTransform.bijective   s    y$$$y""r5   c                 ,    | j         J | j         j        S rN   )r-   rG   r=   s    r4   rG   z_InverseTransform.sign   s    y$$$y~r5   c                     | j         S rN   )r-   r=   s    r4   rC   z_InverseTransform.inv   s
    yr5   r+   c                 R    | j         J | j                            |          j        S rN   )r-   rC   rL   rK   s     r4   rL   z_InverseTransform.with_cache   s)    y$$$x"":..22r5   c                 b    t          |t                    sdS | j        J | j        |j        k    S NF)
isinstancer?   r-   rP   s     r4   rR   z_InverseTransform.__eq__   s7    %!233 	5y$$$yEJ&&r5   c                 J    | j         j         dt          | j                   dS )N())r3   rh   reprr-   r=   s    r4   ri   z_InverseTransform.__repr__  s&    .)>>DOO>>>>r5   c                 H    | j         J | j                             |          S rN   )r-   r^   r`   s     r4   r[   z_InverseTransform.__call__	  s&    y$$$y""1%%%r5   c                 L    | j         J | j                             ||           S rN   )r-   rf   re   s      r4   rf   z&_InverseTransform.log_abs_det_jacobian  s+    y$$$	..q!4444r5   c                 6    | j                             |          S rN   )r-   rp   rk   s     r4   rm   z_InverseTransform.forward_shape      y&&u---r5   c                 6    | j                             |          S rN   )r-   rm   rk   s     r4   rp   z_InverseTransform.inverse_shape  r   r5   rr   )rh   rs   rt   ru   r#   r1   r   dependent_propertyr&   r'   rz   boolrv   ry   rG   rC   rL   rR   ri   r[   rf   rm   rp   r{   r|   s   @r4   r?   r?      s        
)) ) ) ) ) ) ) ) $[#666" " 76" $[#666    76  #4 # # # X# c    X Y    X3 3 3 3' ' '? ? ?& & &5 5 5. . .. . . . . . .r5   r?   c                   &    e Zd ZdZddee         deddf fdZd Z e	j
        d	
          d             Z e	j
        d	
          d             Zedefd            Zedefd            Zedef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   partsr(   r)   Nc                 |    rfd|D             }t                                                     || _        d S )Nc                 :    g | ]}|                               S rO   rL   ).0partr(   s     r4   
<listcomp>z-ComposeTransform.__init__.<locals>.<listcomp>%  s%    CCCTT__Z00CCCr5   rI   )r0   r1   r   )r2   r   r(   r3   s     `r4   r1   zComposeTransform.__init__#  sL     	DCCCCUCCCEJ///


r5   c                 P    t          |t                    sdS | j        |j        k    S r   )r   r   r   rP   s     r4   rR   zComposeTransform.__eq__)  s)    %!122 	5zU[((r5   Fr   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'   r<   reversedmaxindependent)r2   r&   r<   r   s       r4   r&   zComposeTransform.domain.  s    z 	$##A%JrN+5	TZ(( 	> 	>D.1HHHIIt{'<==IIF,,,,,v''' ,VYAQ5QRRFr5   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&   r<   r   r   )r2   r'   r<   r   s       r4   r'   zComposeTransform.codomain=  s    z 	$##:b>*JqM(2	J 	@ 	@D04;3HHHIIt}'>??IIH.....x)))".xXEW9WXXHr5   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rN   rv   r   ps     r4   	<genexpr>z-ComposeTransform.bijective.<locals>.<genexpr>N  s$      3311;333333r5   )allr   r=   s    r4   rv   zComposeTransform.bijectiveL  s!    33
333333r5   c                 2    d}| j         D ]}||j        z  }|S Nr+   )r   rG   )r2   rG   r   s      r4   rG   zComposeTransform.signP  s*     	! 	!A!&=DDr5   c                     d }| j         |                                  }|]t          d t          | j                  D                       }t	          j        |          | _         t	          j        |           |_         |S )Nc                     g | ]	}|j         
S rO   )rC   r   s     r4   r   z(ComposeTransform.inv.<locals>.<listcomp>]  s    #H#H#HaAE#H#H#Hr5   )r-   r   r   r   r@   rA   rB   s     r4   rC   zComposeTransform.invW  sn    9 ))++C;"#H#H8DJ3G3G#H#H#HIICC((DI{4((CH
r5   r+   c                 H    | j         |k    r| S t          | j        |          S r   )r,   r   r   rK   s     r4   rL   zComposeTransform.with_cacheb  s*    z))K
zBBBBr5   c                 0    | j         D ]} ||          }|S rN   )r   )r2   rW   r   s      r4   r[   zComposeTransform.__call__g  s'    J 	 	DQAAr5   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&   r<   zipr	   rf   r'   	functoolsreduceoperatoradd)r2   rW   rZ   xsr   termsr<   s          r4   rf   z%ComposeTransform.log_abs_det_jacobianl  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4r5   c                 D    | j         D ]}|                    |          }|S rN   )r   rm   r2   rl   r   s      r4   rm   zComposeTransform.forward_shape  s-    J 	. 	.D&&u--EEr5   c                 ^    t          | j                  D ]}|                    |          }|S rN   )r   r   rp   r   s      r4   rp   zComposeTransform.inverse_shape  s5    TZ(( 	. 	.D&&u--EEr5   c                 |    | j         j        dz   }|d                    d | j        D                       z  }|dz  }|S )Nz(
    z,
    c                 6    g | ]}|                                 S rO   )ri   r   s     r4   r   z-ComposeTransform.__repr__.<locals>.<listcomp>  s     %G%G%Gqajjll%G%G%Gr5   z
))r3   rh   joinr   )r2   
fmt_strings     r4   ri   zComposeTransform.__repr__  sH    ^,y8
inn%G%GDJ%G%G%GHHH
e
r5   rq   rr   )rh   rs   rt   ru   listr#   ry   r1   rR   r   r   r&   r'   r   r   rv   rG   rz   rC   rL   r[   rf   rm   rp   ri   r{   r|   s   @r4   r   r     s         d9o 3 t      ) ) )
 $[#666  76 $[#666  76 44 4 4 4 ]4 c    ] Y    XC C C C
  
5 5 5*  
  
      r5   r   c            	           e Zd ZdZ	 ddedededdf fdZdd
Z ej	        d          d             Z
 ej	        d          d             Zedefd            Zedef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   base_transformreinterpreted_batch_ndimsr(   r)   Nc                     t                                          |           |                    |          | _        || _        d S r   )r0   r1   rL   r   r   )r2   r   r   r(   r3   s       r4   r1   zIndependentTransform.__init__  sD     	J///,77
CC)B&&&r5   r+   c                 T    | j         |k    r| S t          | j        | j        |          S r   )r,   r   r   r   rK   s     r4   rL   zIndependentTransform.with_cache  s9    z))K#!?J
 
 
 	
r5   Fr   c                 J    t          j        | j        j        | j                  S rN   )r   r   r   r&   r   r=   s    r4   r&   zIndependentTransform.domain  s%    &&(F
 
 	
r5   c                 J    t          j        | j        j        | j                  S rN   )r   r   r   r'   r   r=   s    r4   r'   zIndependentTransform.codomain  s%    &($*H
 
 	
r5   c                     | j         j        S rN   )r   rv   r=   s    r4   rv   zIndependentTransform.bijective  s    ",,r5   c                     | j         j        S rN   )r   rG   r=   s    r4   rG   zIndependentTransform.sign  s    "''r5   c                     |                                 | j        j        k     rt          d          |                     |          S NToo few dimensions on input)dimr&   r<   r/   r   r`   s     r4   rV   zIndependentTransform._call  s=    5577T[***:;;;""1%%%r5   c                     |                                 | j        j        k     rt          d          | j                            |          S r   )r   r'   r<   r/   r   rC   rc   s     r4   r]   zIndependentTransform._inverse  s@    5577T],,,:;;;"&&q)))r5   c                 f    | j                             ||          }t          || j                  }|S rN   )r   rf   r	   r   )r2   rW   rZ   results       r4   rf   z)IndependentTransform.log_abs_det_jacobian  s1    $99!Q??(FGGr5   c                 Z    | j         j         dt          | j                   d| j         dS )Nr   z, r   )r3   rh   r   r   r   r=   s    r4   ri   zIndependentTransform.__repr__  s4    .)jjD1D,E,EjjIgjjjjr5   c                 6    | j                             |          S rN   )r   rm   rk   s     r4   rm   z"IndependentTransform.forward_shape      "00777r5   c                 6    | j                             |          S rN   )r   rp   rk   s     r4   rp   z"IndependentTransform.inverse_shape  r   r5   rq   rr   )rh   rs   rt   ru   r#   ry   r1   rL   r   r   r&   r'   rz   r   rv   rG   rV   r]   rf   ri   rm   rp   r{   r|   s   @r4   r   r     s        " 	C C!C $'C 	C
 
C C C C C C
 
 
 
 $[#666
 
 76

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

 -4 - - - X- (c ( ( ( X(& & &
* * *
  
k k k8 8 88 8 8 8 8 8 8r5   r   c            	            e Zd ZdZdZ	 ddej        dej        deddf 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   a  
    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.
        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. (Default 0.)
    Tr   in_shape	out_shaper(   r)   Nc                 6   t          j        |          | _        t          j        |          | _        | j                                        | j                                        k    rt          d          t                                          |           d S )Nz6in_shape, out_shape have different numbers of elementsrI   )r   Sizer   r   numelr/   r0   r1   )r2   r   r   r(   r3   s       r4   r1   zReshapeTransform.__init__  s~     
8,,I..=  DN$8$8$:$:::UVVVJ/////r5   c                 d    t          j        t           j        t          | j                            S rN   )r   r   r   lenr   r=   s    r4   r&   zReshapeTransform.domain  s"    &{'7T]9K9KLLLr5   c                 d    t          j        t           j        t          | j                            S rN   )r   r   r   r   r   r=   s    r4   r'   zReshapeTransform.codomain  s"    &{'7T^9L9LMMMr5   r+   c                 T    | j         |k    r| S t          | j        | j        |          S r   )r,   r   r   r   rK   s     r4   rL   zReshapeTransform.with_cache  s.    z))Kt~*UUUUr5   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rN   )rl   r   r   r   reshaper   )r2   rW   batch_shapes      r4   rV   zReshapeTransform._call
  sD    g<#dm*<*< <<=yyt~5666r5   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rN   )rl   r   r   r   r   r   )r2   rZ   r   s      r4   r]   zReshapeTransform._inverse  sD    g=#dn*=*= ==>yyt}4555r5   c                     |j         d |                                t          | j                  z
           }|                    |          S rN   )rl   r   r   r   	new_zeros)r2   rW   rZ   r   s       r4   rf   z%ReshapeTransform.log_abs_det_jacobian  s=    g<#dm*<*< <<={{;'''r5   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   r2   rl   cuts      r4   rm   zReshapeTransform.forward_shape  s    u::DM****:;;;%jj3t}---;$-''QE#$$KQQ$-QQ   TcT{T^++r5   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      r4   rp   zReshapeTransform.inverse_shape   s    u::DN++++:;;;%jj3t~...;$.((RE#$$KRR$.RR   TcT{T]**r5   rq   rr   )rh   rs   rt   ru   rv   r   r   ry   r1   r   r   r&   r'   rL   rV   r]   rf   rm   rp   r{   r|   s   @r4   r   r     s)         I 	
0 
0*
0 :
0 	
0
 

0 
0 
0 
0 
0 
0 #M M $#M #N N $#NV V V V
7 7 76 6 6( ( (, , ,+ + + + + + +r5   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 rN   )r   r   rP   s     r4   rR   zExpTransform.__eq__5      %...r5   c                 *    |                                 S rN   )expr`   s     r4   rV   zExpTransform._call8      uuwwr5   c                 *    |                                 S rN   logrc   s     r4   r]   zExpTransform._inverse;  r   r5   c                     |S rN   rO   re   s      r4   rf   z!ExpTransform.log_abs_det_jacobian>      r5   Nrh   rs   rt   ru   r   r   r&   positiver'   rv   rG   rR   rV   r]   rf   rO   r5   r4   r   r   +  sv          F#HID/ / /        r5   r   c                        e Zd ZdZej        Zej        ZdZdde	de
ddf fdZdd
Zede
f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   exponentr(   r)   Nc                 x    t                                          |           t          |          \  | _        d S r   )r0   r1   r
   r   )r2   r   r(   r3   s      r4   r1   zPowerTransform.__init__K  s4    J///(22r5   r+   c                 H    | j         |k    r| S t          | j        |          S r   )r,   r   r   rK   s     r4   rL   zPowerTransform.with_cacheO  s*    z))Kdm
CCCCr5   c                 4    | j                                         S rN   )r   rG   r=   s    r4   rG   zPowerTransform.signT  s    }!!###r5   c                     t          |t                    sdS | j                            |j                                                                                  S r   )r   r   r   eqr   itemrP   s     r4   rR   zPowerTransform.__eq__X  sI    %00 	5}//3355::<<<r5   c                 6    |                     | j                  S rN   powr   r`   s     r4   rV   zPowerTransform._call]  s    uuT]###r5   c                 <    |                     d| j        z            S r   r  rc   s     r4   r]   zPowerTransform._inverse`  s    uuQ&'''r5   c                 d    | j         |z  |z                                                                  S rN   )r   absr   re   s      r4   rf   z#PowerTransform.log_abs_det_jacobianc  s,    !A%**,,00222r5   c                 T    t          j        |t          | j        dd                    S Nrl   rO   r   broadcast_shapesgetattrr   rk   s     r4   rm   zPowerTransform.forward_shapef  #    %eWT]GR-P-PQQQr5   c                 T    t          j        |t          | j        dd                    S r  r  rk   s     r4   rp   zPowerTransform.inverse_shapei  r  r5   rq   rr   )rh   rs   rt   ru   r   r   r&   r'   rv   r   ry   r1   rL   r   rG   rR   rV   r]   rf   rm   rp   r{   r|   s   @r4   r   r   B  s         !F#HI3 3 3S 3 3 3 3 3 3 3D D D D
 $c $ $ $ ]$= = =
$ $ $( ( (3 3 3R R RR R R R R R Rr5   r   c                     t          j        | j                  }t          j        t          j        |           |j        d|j        z
            S N      ?minr   )r   finfodtypeclampsigmoidtinyeps)rW   r  s     r4   _clipped_sigmoidr  m  s<    K  E;u}Q''UZS59_MMMMr5   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 rN   )r   r   rP   s     r4   rR   zSigmoidTransform.__eq__|      %!1222r5   c                      t          |          S rN   )r  r`   s     r4   rV   zSigmoidTransform._call  s    """r5   c                     t          j        |j                  }|                    |j        d|j        z
            }|                                |                                 z
  S r  )r   r  r  r  r  r  r   log1p)r2   rZ   r  s      r4   r]   zSigmoidTransform._inverse  sM    AG$$GG
eiG88uuww1"%%r5   c                 X    t          j        |            t          j        |          z
  S rN   )Fr   re   s      r4   rf   z%SigmoidTransform.log_abs_det_jacobian  s!    
A2A..r5   N)rh   rs   rt   ru   r   r   r&   unit_intervalr'   rv   rG   rR   rV   r]   rf   rO   r5   r4   r   r   r  sv          F(HID3 3 3# # #& & &
/ / / / /r5   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 rN   )r   r   rP   s     r4   rR   zSoftplusTransform.__eq__  s    %!2333r5   c                      t          |          S rN   r   r`   s     r4   rV   zSoftplusTransform._call  s    {{r5   c                 z    |                                                                                                  |z   S rN   )expm1negr   rc   s     r4   r]   zSoftplusTransform._inverse  s/    zz||!!%%''!++r5   c                 $    t          |            S rN   r*  re   s      r4   rf   z&SoftplusTransform.log_abs_det_jacobian  s    !}r5   Nr   rO   r5   r4   r   r     sv         
 F#HID4 4 4  , , ,    r5   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

    .. code-block:: python

        ComposeTransform(
            [
                AffineTransform(0.0, 2.0),
                SigmoidTransform(),
                AffineTransform(-1.0, 2.0),
            ]
        )

    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 rN   )r   r   rP   s     r4   rR   zTanhTransform.__eq__  s    %///r5   c                 *    |                                 S rN   )tanhr`   s     r4   rV   zTanhTransform._call  s    vvxxr5   c                 *    t          j        |          S rN   )r   atanhrc   s     r4   r]   zTanhTransform._inverse  s     {1~~r5   c                 \    dt          j        d          |z
  t          d|z            z
  z  S )N       @g       )mathr   r   re   s      r4   rf   z"TanhTransform.log_abs_det_jacobian  s-     dhsmma'(4!8*<*<<==r5   N)rh   rs   rt   ru   r   r   r&   intervalr'   rv   rG   rR   rV   r]   rf   rO   r5   r4   r   r     s         , F#{#D#..HID0 0 0    
> > > > >r5   r   c                   @    e Zd ZdZej        Zej        Zd Z	d Z
d ZdS )r   z*Transform via the mapping :math:`y = |x|`.c                 ,    t          |t                    S rN   )r   r   rP   s     r4   rR   zAbsTransform.__eq__  r   r5   c                 *    |                                 S rN   )r
  r`   s     r4   rV   zAbsTransform._call  r   r5   c                     |S rN   rO   rc   s     r4   r]   zAbsTransform._inverse  r   r5   N)rh   rs   rt   ru   r   r   r&   r   r'   rR   rV   r]   rO   r5   r4   r   r     sW        55F#H/ / /      r5   r   c                   >    e Zd ZdZdZ	 	 ddeeef         deeef         dededd	f
 fd
Z	e
defd            Z ej        d          d             Z ej        d          d             ZddZd Ze
deeef         f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   locscaler<   r(   r)   Nc                 v    t                                          |           || _        || _        || _        d S r   )r0   r1   r>  r?  
_event_dim)r2   r>  r?  r<   r(   r3   s        r4   r1   zAffineTransform.__init__  s9     	J///
#r5   c                     | j         S rN   )rA  r=   s    r4   r<   zAffineTransform.event_dim  s
    r5   Fr   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S Nr   r<   r   r   r   r=   s    r4   r&   zAffineTransform.domain  0    >Q##&{'7HHHr5   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S rD  rE  r=   s    r4   r'   zAffineTransform.codomain  rF  r5   r+   c                 `    | j         |k    r| S t          | j        | j        | j        |          S r   )r,   r   r>  r?  r<   rK   s     r4   rL   zAffineTransform.with_cache
  s;    z))KHdj$.Z
 
 
 	
r5   c                 (   t          |t                    sdS t          | j        t                    r-t          |j        t                    r| j        |j        k    rdS n6| j        |j        k                                                                    sdS t          | j        t                    r-t          |j        t                    r| j        |j        k    rdS n6| j        |j        k                                                                    sdS dS )NFT)r   r   r>  r   r   r  r?  rP   s     r4   rR   zAffineTransform.__eq__  s    %11 	5dh(( 	Z	7-K-K 	x59$$u % H	)..005577 udj'** 	z%+w/O/O 	zU[((u ) J%+-224499;; utr5   c                     t          | j        t                    r6t          | j                  dk    rdnt          | j                  dk     rdndS | j                                        S )Nr   r+   r   )r   r?  r   floatrG   r=   s    r4   rG   zAffineTransform.sign%  s`    dj'** 	Vdj))A--11tz9J9JQ9N9N22TUUz   r5   c                 &    | j         | j        |z  z   S rN   r>  r?  r`   s     r4   rV   zAffineTransform._call+  s    x$*q.((r5   c                 &    || j         z
  | j        z  S rN   rM  rc   s     r4   r]   zAffineTransform._inverse.  s    DH
**r5   c                    |j         }| j        }t          |t                    r5t	          j        |t          j        t          |                              }n&t	          j        |                                          }| j	        r]|
                                d | j	                  dz   }|                    |                              d          }|d | j	                  }|                    |          S )N)r   r   )rl   r?  r   r   r   	full_liker7  r   r
  r<   sizeviewsumexpand)r2   rW   rZ   rl   r?  r   result_sizes          r4   rf   z$AffineTransform.log_abs_det_jacobian1  s    
eW%% 	,_QU(<(<==FFYu%%))++F> 	- ++--(94>/(9:UBK[[--11"55F+T^O+,E}}U###r5   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  r   r  r  r>  r?  rk   s     r4   rm   zAffineTransform.forward_shape>  ;    %748Wb1174:wPR3S3S
 
 	
r5   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  rW  rk   s     r4   rp   zAffineTransform.inverse_shapeC  rX  r5   r   r   rr   )rh   rs   rt   ru   rv   r   r   rK  ry   r1   rz   r<   r   r   r&   r'   rL   rR   rG   rV   r]   rf   rm   rp   r{   r|   s   @r4   r   r     s       	 	 I 
$ 
$65=!
$ VU]#
$ 	
$
 
$ 

$ 
$ 
$ 
$ 
$ 
$ 3    X $[#666I I 76I
 $[#666I I 76I

 
 
 
  ( !eFCK( ! ! ! X!
) ) )+ + +$ $ $
 
 


 
 
 
 
 
 
r5   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   r2  r  r  r  r  r   sqrtcumprodeyerl   r`  r   )r2   rW   r  rzz1m_cumprod_sqrtrZ   s          r4   rV   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@@@@r5   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   ra  r]  r_  )r   cumsumr   r   rc  r#  r-  )r2   rZ   y_cumsumy_cumsum_shiftedy_vecy_cumsum_vectrW   s           r4   r]   zCorrCholeskyTransform._inversem  s     u|AEr2222xSbS1Aq6CCC"12...)*:DDD\'')))WWYY(A-r5   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   rj  r]        ?r6  )rk  r   r   rS  r   r7  )r2   rW   rZ   intermediates
y1m_cumsumy1m_cumsum_trilstick_breaking_logdettanh_logdets           r4   rf   z*CorrCholeskyTransform.log_abs_det_jacobiany  s     !a%B///
 -ZbAAA #&;&;&=&=&A&A"&E&E EAa 0 0048C==@EE"EMMM${22r5   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      ?r_  rs  z-Input is not a flattend lower-diagonal number)r   r/   round)r2   rl   NDs       r4   rm   z#CorrCholeskyTransform.forward_shape  s    u::>>:;;;"I4!a%<C'#-..A;!q  LMMMSbSzQF""r5   c                     t          |          dk     rt          d          |d         |d         k    rt          d          |d         }||dz
  z  dz  }|d d         |fz   S )Nr_  r   rr  r   zInput is not squarer+   r   r/   )r2   rl   r|  r{  s       r4   rp   z#CorrCholeskyTransform.inverse_shape  sr    u::>>:;;;9b	!!2333"IQK1SbSzQD  r5   rN   )rh   rs   rt   ru   r   real_vectorr&   corr_choleskyr'   rv   rV   r]   rf   rm   rp   rO   r5   r4   r   r   I  s           $F(HI  
 
 
3 3 3 3# # #! ! ! ! !r5   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 rN   )r   r    rP   s     r4   rR   zSoftmaxTransform.__eq__  r   r5   c                     |}||                     dd          d         z
                                  }||                    dd          z  S )Nr   Tr   )r   r   rS  )r2   rW   logprobsprobss       r4   rV   zSoftmaxTransform._call  sI    HLLT22155::<<uyyT****r5   c                 .    |}|                                 S rN   r   )r2   rZ   r  s      r4   r]   zSoftmaxTransform._inverse  s    yy{{r5   c                 J    t          |          dk     rt          d          |S Nr+   r   r~  rk   s     r4   rm   zSoftmaxTransform.forward_shape  %    u::>>:;;;r5   c                 J    t          |          dk     rt          d          |S r  r~  rk   s     r4   rp   zSoftmaxTransform.inverse_shape  r  r5   N)rh   rs   rt   ru   r   r  r&   simplexr'   rR   rV   r]   rm   rp   rO   r5   r4   r    r      s{          $F"H3 3 3+ + +
    
    r5   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 rN   )r   r"   rP   s     r4   rR   zStickBreakingTransform.__eq__      %!7888r5   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   ra  )rl   new_onesrk  r  r   rd  r   )r2   rW   offsetrg  	z_cumprodrZ   s         r4   rV   zStickBreakingTransform._call  s    q1::agbk#:#:#A#A"#E#EEQ-..UOOB''	Aq6###c)aV1&E&E&EEr5   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  )	rl   r  rk  r   r  r  r  r  r   )r2   rZ   y_cropr  sfrW   s         r4   r]   zStickBreakingTransform._inverse  s    38qzz&,r*:;;BB2FFFr""" [QW!5!5!:;;;JJLL26688#fjjll2r5   c                 P   |j         d         dz   |                    |j         d                                       d          z
  }||                                z
  }| t	          j        |          z   |dd df                                         z                       d          }|S )Nr   r+   .)rl   r  rk  r   r%  
logsigmoidrS  )r2   rW   rZ   r  detJs        r4   rf   z+StickBreakingTransform.log_abs_det_jacobian  s    q1::agbk#:#:#A#A"#E#EE

Q\!__$qcrc{'8'88==bAAr5   c                 t    t          |          dk     rt          d          |d d         |d         dz   fz   S Nr+   r   r   r~  rk   s     r4   rm   z$StickBreakingTransform.forward_shape  >    u::>>:;;;SbSzU2Y],,,r5   c                 t    t          |          dk     rt          d          |d d         |d         dz
  fz   S r  r~  rk   s     r4   rp   z$StickBreakingTransform.inverse_shape  r  r5   N)rh   rs   rt   ru   r   r  r&   r  r'   rv   rR   rV   r]   rf   rm   rp   rO   r5   r4   r"   r"     s          $F"HI9 9 9      - - -
- - - - -r5   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.
    r_  c                 ,    t          |t                    S rN   )r   r   rP   s     r4   rR   zLowerCholeskyTransform.__eq__  r  r5   c                     |                     d          |                    dd                                                                          z   S Nr   rr  )dim1dim2)trildiagonalr   
diag_embedr`   s     r4   rV   zLowerCholeskyTransform._call  ?    vvbzzAJJBRJ88<<>>IIKKKKr5   c                     |                     d          |                    dd                                                                          z   S r  )r  r  r   r  rc   s     r4   r]   zLowerCholeskyTransform._inverse
  r  r5   N)rh   rs   rt   ru   r   r   r   r&   lower_choleskyr'   rR   rV   r]   rO   r5   r4   r   r     st          %[$[%5q99F)H9 9 9L L LL L L L Lr5   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.
    r_  c                 ,    t          |t                    S rN   )r   r   rP   s     r4   rR   z PositiveDefiniteTransform.__eq__  s    %!:;;;r5   c                 D     t                      |          }||j        z  S rN   )r   mTr`   s     r4   rV   zPositiveDefiniteTransform._call  s#    $"$$Q''14xr5   c                     t           j                            |          }t                                          |          S rN   )r   linalgcholeskyr   rC   rc   s     r4   r]   z"PositiveDefiniteTransform._inverse  s1    L!!!$$%''++A...r5   N)rh   rs   rt   ru   r   r   r   r&   positive_definiter'   rR   rV   r]   rO   r5   r4   r   r     sl          %[$[%5q99F,H< < <  / / / / /r5   r   c                   *    e Zd ZU dZee         ed<   	 	 	 ddee         dede	ee                  ded	df
 fd
Z
ed	efd            Zed	efd            ZddZd Zd Zd Zed	ef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   Ntseqr   lengthsr(   r)   c                    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 rN   r   r#   r   rp  s     r4   r   z(CatTransform.__init__.<locals>.<genexpr>:  ,      :::a++::::::r5   c                 :    g | ]}|                               S rO   r   r   rp  r(   s     r4   r   z)CatTransform.__init__.<locals>.<listcomp><  %    ;;;ALL,,;;;r5   rI   r+   )r   r0   r1   r   r  r   r  r   )r2   r  r   r  r(   r3   s       `r4   r1   zCatTransform.__init__3  s     ::T:::::::: 	<;;;;d;;;DJ///t**?cC000GG}}4<  C$8$88888r5   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rN   )r<   r  s     r4   r   z)CatTransform.event_dim.<locals>.<genexpr>G  $      8811;888888r5   )r   r  r=   s    r4   r<   zCatTransform.event_dimE  !    88888888r5   c                 *    t          | j                  S rN   )rS  r  r=   s    r4   lengthzCatTransform.lengthI  s    4<   r5   r+   c                 ^    | j         |k    r| S t          | j        | j        | j        |          S rN   )r,   r   r  r   r  rK   s     r4   rL   zCatTransform.with_cacheM  s/    z))KDOTXt|ZPPPr5   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   rj  )
r   rQ  r  r   r  r  narrowr   r   cat)r2   rW   yslicesstarttransr  xslices          r4   rV   zCatTransform._callR  s    x48----aeegg------vvdh4;.... $,?? 	# 	#ME6XXdhv66FNN55==)))FNEEydh////r5   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   rQ  r  r   r  r  r  r   rC   r   r  )r2   rZ   xslicesr  r  r  yslices          r4   r]   zCatTransform._inverse]  s    x48----aeegg------vvdh4;.... $,?? 	# 	#ME6XXdhv66FNN599V,,---FNEEydh////r5   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   rQ  r  r   r  r  r  rf   r<   r	   r   r   r  rS  )r2   rW   rZ   
logdetjacsr  r  r  r  r  	logdetjacr   s              r4   rf   z!CatTransform.log_abs_det_jacobianh  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??"r5   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rN   r   r  s     r4   r   z)CatTransform.bijective.<locals>.<genexpr>  r  r5   r   r  r=   s    r4   rv   zCatTransform.bijective  r  r5   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rO   r&   r  s     r4   r   z'CatTransform.domain.<locals>.<listcomp>  s    ///!QX///r5   r   r  r  r   r  r=   s    r4   r&   zCatTransform.domain  s1    //t///4<
 
 	
r5   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rO   r'   r  s     r4   r   z)CatTransform.codomain.<locals>.<listcomp>  s    111AQZ111r5   r  r=   s    r4   r'   zCatTransform.codomain  s1    1111148T\
 
 	
r5   )r   Nr   rr   )rh   rs   rt   ru   r   r#   rx   r   ry   r   r1   r   r<   r  rL   rV   r]   rf   rz   r   rv   r   r   r&   r'   r{   r|   s   @r4   r   r   "  s          Y
 +/ y!  (3-(	
  
     $ 93 9 9 9 ]9 ! ! ! ! ]!Q Q Q Q
	0 	0 	0	0 	0 	0# # #2 94 9 9 9 X9 #
 
 $#

 #
 
 $#
 
 
 
 
r5   r   c            	            e Zd ZU dZee         ed<   	 ddee         dededdf fd	Z	ddZ
d Zd Zd Zd Zedef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   r  r   r(   r)   Nc                     t          d |D                       sJ rfd|D             }t                                                     t          |          | _        || _        d S )Nc              3   @   K   | ]}t          |t                    V  d S rN   r  r  s     r4   r   z*StackTransform.__init__.<locals>.<genexpr>  r  r5   c                 :    g | ]}|                               S rO   r   r  s     r4   r   z+StackTransform.__init__.<locals>.<listcomp>  r  r5   rI   )r   r0   r1   r   r  r   )r2   r  r   r(   r3   s      `r4   r1   zStackTransform.__init__  s}     ::T:::::::: 	<;;;;d;;;DJ///t**r5   r+   c                 R    | j         |k    r| S t          | j        | j        |          S rN   )r,   r!   r  r   rK   s     r4   rL   zStackTransform.with_cache  s+    z))KdotxDDDr5   c                 n      fdt                               j                            D             S )Nc                 F    g | ]}                     j        |          S rO   )selectr   )r   ir2   rg  s     r4   r   z)StackTransform._slice.<locals>.<listcomp>  s)    GGG!1%%GGGr5   )rangerQ  r   )r2   rg  s   ``r4   _slicezStackTransform._slice  s7    GGGGGuQVVDH5E5E/F/FGGGGr5   c                    |                                  | j         cxk    r|                                 k     sn J |                    | j                   t          | j                  k    sJ g }t	          |                     |          | j                  D ]#\  }}|                     ||                     $t          j        || j                   S Nrj  )	r   rQ  r   r  r   r  r   r   stack)r2   rW   r  r  r  s        r4   rV   zStackTransform._call  s    x48----aeegg------vvdh3t#7#77777 QAA 	* 	*MFENN55==)))){71111r5   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   rQ  r   r  r   r  r   rC   r   r  )r2   rZ   r  r  r  s        r4   r]   zStackTransform._inverse  s    x48----aeegg------vvdh3t#7#77777 QAA 	. 	.MFENN599V,,----{71111r5   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   rQ  r   r  r  r   r   rf   r   r  )	r2   rW   rZ   r  r  r  r  r  r  s	            r4   rf   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4r5   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rN   r   r  s     r4   r   z+StackTransform.bijective.<locals>.<genexpr>  r  r5   r  r=   s    r4   rv   zStackTransform.bijective  r  r5   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rO   r  r  s     r4   r   z)StackTransform.domain.<locals>.<listcomp>  s    !D!D!Dq!(!D!D!Dr5   r   r  r  r   r=   s    r4   r&   zStackTransform.domain  s(     !D!DDO!D!D!DdhOOOr5   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rO   r  r  s     r4   r   z+StackTransform.codomain.<locals>.<listcomp>  s    !F!F!F!*!F!F!Fr5   r  r=   s    r4   r'   zStackTransform.codomain  s(     !F!Fdo!F!F!FQQQr5   rZ  rr   )rh   rs   rt   ru   r   r#   rx   r   ry   r1   rL   r  rV   r]   rf   rz   r   rv   r   r   r&   r'   r{   r|   s   @r4   r!   r!     sR        
 
 Y JK Y'.1CF	     E E E E
H H H2 2 22 2 2
5 
5 
5 94 9 9 9 X9 #P P $#P #R R $#R R R R Rr5   r!   c                        e Zd ZdZdZej        ZdZdde	de
ddf fd	Zedeej                 f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   distributionr(   r)   Nc                 Z    t                                          |           || _        d S r   )r0   r1   r  )r2   r  r(   r3   s      r4   r1   z(CumulativeDistributionTransform.__init__  s,    J///(r5   c                     | j         j        S rN   )r  supportr=   s    r4   r&   z&CumulativeDistributionTransform.domain  s     ((r5   c                 6    | j                             |          S rN   )r  cdfr`   s     r4   rV   z%CumulativeDistributionTransform._call  s     $$Q'''r5   c                 6    | j                             |          S rN   )r  icdfrc   s     r4   r]   z(CumulativeDistributionTransform._inverse  s     %%a(((r5   c                 6    | j                             |          S rN   )r  log_probre   s      r4   rf   z4CumulativeDistributionTransform.log_abs_det_jacobian  s     ))!,,,r5   c                 H    | j         |k    r| S t          | j        |          S r   )r,   r   r  rK   s     r4   rL   z*CumulativeDistributionTransform.with_cache  s+    z))K.t/@ZXXXXr5   rq   rr   )rh   rs   rt   ru   rv   r   r&  r'   rG   r   ry   r1   rz   r   rw   r&   rV   r]   rf   rL   r{   r|   s   @r4   r   r     s         $ I(HD) )\ )s )4 ) ) ) ) ) ) )!78 ) ) ) X)( ( () ) )- - -Y Y Y Y Y Y Y Yr5   r   )4r   r7  r   r@   collections.abcr   typingr   r   r   torch.nn.functionalnn
functionalr%  r   torch.distributionsr    torch.distributions.distributionr   torch.distributions.utilsr	   r
   r   r   r   r   r   torch.typesr   __all__r#   r?   r   r$   r   r   r   r   r  r   r   r   r   r   r   r    r"   r   r   r   r!   r   rO   r5   r4   <module>r	     s          $ $ $ $ $ $ " " " " " " " "                 + + + + + + 9 9 9 9 9 9              . - - - - - - -        0f f f f f f f fR;. ;. ;. ;. ;.	 ;. ;. ;.|w w w w wy w w wt &%b)) I8 I8 I8 I8 I89 I8 I8 I8XG+ G+ G+ G+ G+y G+ G+ G+T    9   .(R (R (R (R (RY (R (R (RVN N N
/ / / / /y / / /2    	   0*> *> *> *> *>I *> *> *>Z    9    f
 f
 f
 f
 f
i f
 f
 f
RP! P! P! P! P!I P! P! P!f! ! ! ! !y ! ! !H5- 5- 5- 5- 5-Y 5- 5- 5-pL L L L LY L L L,/ / / / /	 / / /(m
 m
 m
 m
 m
9 m
 m
 m
`GR GR GR GR GRY GR GR GRT+Y +Y +Y +Y +Yi +Y +Y +Y +Y +Yr5   