
    /j6                        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 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          Z- G d- d.e          Z. G d/ d0e          Z/ G d1 d2e          Z0dS )3    N)Sequence)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     c/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/torch/distributions/transforms.pyr/   zTransform.__init__a   s]    %=A	??1__)D8999    c                 B    | j                                         }d |d<   |S )Nr+   )__dict__copy)r0   states     r2   __getstate__zTransform.__getstate__l   s#    ""$$fr3   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-   r0   s    r2   r:   zTransform.event_dimq   s1    ; DM$;;;;((UVVVr3   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r0   invs     r2   rA   zTransform.invw   sF     9 ))++C;#D))CC((DI
r3   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    r2   signzTransform.sign   s
     "!r3   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!   rD   r0   r&   s     r2   
with_cachezTransform.with_cache   sb    z))K::)"4444::4444!T$ZZ"O"O"OPPPr3   c                 
    | |u S N r0   others     r2   __eq__zTransform.__eq__   s    u}r3   c                 .    |                      |           S rL   )rP   rN   s     r2   __ne__zTransform.__ne__   s    ;;u%%%%r3   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z2
        Computes the transform `x => y`.
        r   )r*   _callr,   )r0   xx_oldy_oldys        r2   __call__zTransform.__call__   s\     q  ::a== 'u::LJJqMMa4r3   c                     | j         dk    r|                     |          S | j        \  }}||u r|S |                     |          }||f| _        |S )z1
        Inverts the transform `y => x`.
        r   )r*   _inverser,   )r0   rX   rV   rW   rU   s        r2   	_inv_callzTransform._inv_call   s`     q  ==###'u::LMM!a4r3   c                     t           )zD
        Abstract method to compute forward transformation.
        rC   r0   rU   s     r2   rT   zTransform._call   
     "!r3   c                     t           )zD
        Abstract method to compute inverse transformation.
        rC   r0   rX   s     r2   r[   zTransform._inverse   r_   r3   c                     t           )zU
        Computes the log det jacobian `log |dy/dx|` given input and output.
        rC   r0   rU   rX   s      r2   log_abs_det_jacobianzTransform.log_abs_det_jacobian   r_   r3   c                      | j         j        dz   S )Nz())r1   __name__r;   s    r2   __repr__zTransform.__repr__   s    ~&--r3   c                     |S )z{
        Infers the shape of the forward computation, given the input shape.
        Defaults to preserving shape.
        rM   r0   shapes     r2   forward_shapezTransform.forward_shape   	    
 r3   c                     |S )z}
        Infers the shapes of the inverse computation, given the output shape.
        Defaults to preserving shape.
        rM   ri   s     r2   inverse_shapezTransform.inverse_shape   rl   r3   r   )r'   r!   r)   )rf   
__module____qualname____doc__	bijectiver   
Constraint__annotations__intr/   r8   propertyr:   rA   rE   rJ   rP   rR   rY   r\   rT   r[   rd   rg   rk   rn   __classcell__r1   s   @r2   r!   r!   0   s        * *X I""""$$$$	 	3 	t 	 	 	 	 	 	  
 W3 W W W XW
    X "c " " " X"Q Q Q Q  & & &    " " "" " "" " ". . .        r3   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 NrG   )r.   r/   r*   r+   )r0   r|   r1   s     r2   r/   z_InverseTransform.__init__   s,    I$9:::(			r3   Fis_discretec                 F    | j         t          d          | j         j        S N_inv must not be None)r+   AssertionErrorr%   r;   s    r2   r$   z_InverseTransform.domain   s&     9 !8999y!!r3   c                 F    | j         t          d          | j         j        S r   )r+   r   r$   r;   s    r2   r%   z_InverseTransform.codomain   s&     9 !8999yr3   c                 F    | j         t          d          | j         j        S r   )r+   r   rt   r;   s    r2   rt   z_InverseTransform.bijective   s$    9 !8999y""r3   c                 F    | j         t          d          | j         j        S r   )r+   r   rE   r;   s    r2   rE   z_InverseTransform.sign   s#    9 !8999y~r3   c                     | j         S rL   )r+   r;   s    r2   rA   z_InverseTransform.inv   s
    yr3   r)   c                 l    | j         t          d          | j                            |          j        S r   )r+   r   rA   rJ   rI   s     r2   rJ   z_InverseTransform.with_cache  s2    9 !8999x"":..22r3   c                 |    t          |t                    sdS | j        t          d          | j        |j        k    S )NFr   )
isinstancer=   r+   r   rN   s     r2   rP   z_InverseTransform.__eq__  s@    %!233 	59 !8999yEJ&&r3   c                 J    | j         j         dt          | j                   dS )N())r1   rf   reprr+   r;   s    r2   rg   z_InverseTransform.__repr__  s&    .)>>DOO>>>>r3   c                 b    | j         t          d          | j                             |          S r   )r+   r   r\   r^   s     r2   rY   z_InverseTransform.__call__  s/    9 !8999y""1%%%r3   c                 f    | j         t          d          | j                             ||           S r   )r+   r   rd   rc   s      r2   rd   z&_InverseTransform.log_abs_det_jacobian  s4    9 !8999	..q!4444r3   c                 6    | j                             |          S rL   )r+   rn   ri   s     r2   rk   z_InverseTransform.forward_shape      y&&u---r3   c                 6    | j                             |          S rL   )r+   rk   ri   s     r2   rn   z_InverseTransform.inverse_shape  r   r3   rp   )rf   rq   rr   rs   r!   r/   r   dependent_propertyr$   r%   rx   boolrt   rw   rE   rA   rJ   rP   rg   rY   rd   rk   rn   ry   rz   s   @r2   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
. . .. . . . . . .r3   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 rM   rJ   ).0partr&   s     r2   
<listcomp>z-ComposeTransform.__init__.<locals>.<listcomp>.  s%    CCCTT__Z00CCCr3   rG   )r.   r/   r   )r0   r   r&   r1   s     `r2   r/   zComposeTransform.__init__,  sL     	DCCCCUCCCEJ///


r3   c                 P    t          |t                    sdS | j        |j        k    S NF)r   r   r   rN   s     r2   rP   zComposeTransform.__eq__2  s)    %!122 	5zU[((r3   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     rt          d| d|j                   ||j        k    rt          j	        |||j        z
            }|S )Nr   
event_dim z must be >= domain.event_dim )
r   r   realr$   r%   r:   reversedmaxr   independent)r0   r$   r:   r   s       r2   r$   zComposeTransform.domain7  s     z 	$##A%JrN+5	TZ(( 	> 	>D.1HHHIIt{'<==IIv''' WYWWVEUWW   v''' ,VYAQ5QRRFr3   c                    | 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     rt          d| d|j                   ||j        k    rt          j        |||j        z
            }|S )Nr   r   r   z must be >= codomain.event_dim )	r   r   r   r%   r$   r:   r   r   r   )r0   r%   r:   r   s       r2   r%   zComposeTransform.codomainJ  s     z 	$##:b>*JqM(2	J 	@ 	@D04;3HHHIIt}'>??IIx))) [Y[[xGY[[   x)))".xXEW9WXXHr3   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rL   rt   r   ps     r2   	<genexpr>z-ComposeTransform.bijective.<locals>.<genexpr>_  s$      3311;333333r3   )allr   r;   s    r2   rt   zComposeTransform.bijective]  s!    33
333333r3   c                 2    d}| j         D ]}||j        z  }|S Nr)   )r   rE   )r0   rE   r   s      r2   rE   zComposeTransform.signa  s*     	! 	!A!&=DDr3   c                     d }| j         |                                  }|]t          d t          | j                  D                       }t	          j        |          | _         t	          j        |           |_         |S )Nc                     g | ]	}|j         
S rM   )rA   r   s     r2   r   z(ComposeTransform.inv.<locals>.<listcomp>n  s    #H#H#HaAE#H#H#Hr3   )r+   r   r   r   r>   r?   r@   s     r2   rA   zComposeTransform.invh  sn    9 ))++C;"#H#H8DJ3G3G#H#H#HIICC((DI{4((CH
r3   r)   c                 H    | j         |k    r| S t          | j        |          S r~   )r*   r   r   rI   s     r2   rJ   zComposeTransform.with_caches  s*    z))K
zBBBBr3   c                 0    | j         D ]} ||          }|S rL   )r   )r0   rU   r   s      r2   rY   zComposeTransform.__call__x  s'    J 	 	DQAAr3   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   rd   r%   	functoolsreduceoperatoradd)r0   rU   rX   xsr   termsr:   s          r2   rd   z%ComposeTransform.log_abs_det_jacobian}  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4r3   c                 D    | j         D ]}|                    |          }|S rL   )r   rk   r0   rj   r   s      r2   rk   zComposeTransform.forward_shape  s-    J 	. 	.D&&u--EEr3   c                 ^    t          | j                  D ]}|                    |          }|S rL   )r   r   rn   r   s      r2   rn   zComposeTransform.inverse_shape  s5    TZ(( 	. 	.D&&u--EEr3   c                 |    | j         j        dz   }|d                    d | j        D                       z  }|dz  }|S )Nz(
    z,
    c                 6    g | ]}|                                 S rM   )rg   r   s     r2   r   z-ComposeTransform.__repr__.<locals>.<listcomp>  s     %G%G%Gqajjll%G%G%Gr3   z
))r1   rf   joinr   )r0   
fmt_strings     r2   rg   zComposeTransform.__repr__  sH    ^,y8
inn%G%GDJ%G%G%GHHH
e
r3   ro   rp   )rf   rq   rr   rs   listr!   rw   r/   rP   r   r   r$   r%   r	   r   rt   rE   rx   rA   rJ   rY   rd   rk   rn   rg   ry   rz   s   @r2   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*  
  
      r3   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~   )r.   r/   rJ   r   r   )r0   r   r   r&   r1   s       r2   r/   zIndependentTransform.__init__  sD     	J///,77
CC)B&&&r3   r)   c                 T    | j         |k    r| S t          | j        | j        |          S r~   )r*   r   r   r   rI   s     r2   rJ   zIndependentTransform.with_cache  s9    z))K#!?J
 
 
 	
r3   Fr   c                 J    t          j        | j        j        | j                  S rL   )r   r   r   r$   r   r;   s    r2   r$   zIndependentTransform.domain  s'     &&(F
 
 	
r3   c                 J    t          j        | j        j        | j                  S rL   )r   r   r   r%   r   r;   s    r2   r%   zIndependentTransform.codomain  s'     &($*H
 
 	
r3   c                     | j         j        S rL   )r   rt   r;   s    r2   rt   zIndependentTransform.bijective  s    ",,r3   c                     | j         j        S rL   )r   rE   r;   s    r2   rE   zIndependentTransform.sign  s    "''r3   c                     |                                 | j        j        k     rt          d          |                     |          S NToo few dimensions on input)dimr$   r:   r-   r   r^   s     r2   rT   zIndependentTransform._call  s=    5577T[***:;;;""1%%%r3   c                     |                                 | j        j        k     rt          d          | j                            |          S r   )r   r%   r:   r-   r   rA   ra   s     r2   r[   zIndependentTransform._inverse  s@    5577T],,,:;;;"&&q)))r3   c                 f    | j                             ||          }t          || j                  }|S rL   )r   rd   r   r   )r0   rU   rX   results       r2   rd   z)IndependentTransform.log_abs_det_jacobian  s1    $99!Q??(FGGr3   c                 Z    | j         j         dt          | j                   d| j         dS )Nr   z, r   )r1   rf   r   r   r   r;   s    r2   rg   zIndependentTransform.__repr__  s4    .)jjD1D,E,EjjIgjjjjr3   c                 6    | j                             |          S rL   )r   rk   ri   s     r2   rk   z"IndependentTransform.forward_shape      "00777r3   c                 6    | j                             |          S rL   )r   rn   ri   s     r2   rn   z"IndependentTransform.inverse_shape  r   r3   ro   rp   )rf   rq   rr   rs   r!   rw   r/   rJ   r   r   r$   r%   rx   r   rt   rE   rT   r[   rd   rg   rk   rn   ry   rz   s   @r2   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 8r3   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 elementsrG   )r   Sizer   r   numelr-   r.   r/   )r0   r   r   r&   r1   s       r2   r/   zReshapeTransform.__init__  s~     
8,,I..=  DN$8$8$:$:::UVVVJ/////r3   c                 d    t          j        t           j        t          | j                            S rL   )r   r   r   lenr   r;   s    r2   r$   zReshapeTransform.domain  s$     &{'7T]9K9KLLLr3   c                 d    t          j        t           j        t          | j                            S rL   )r   r   r   r   r   r;   s    r2   r%   zReshapeTransform.codomain  s$     &{'7T^9L9LMMMr3   r)   c                 T    | j         |k    r| S t          | j        | j        |          S r~   )r*   r   r   r   rI   s     r2   rJ   zReshapeTransform.with_cache  s.    z))Kt~*UUUUr3   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rL   )rj   r   r   r   reshaper   )r0   rU   batch_shapes      r2   rT   zReshapeTransform._call  sD    g<#dm*<*< <<=yyt~5666r3   c                     |j         d |                                t          | j                  z
           }|                    || j        z             S rL   )rj   r   r   r   r   r   )r0   rX   r   s      r2   r[   zReshapeTransform._inverse#  sD    g=#dn*=*= ==>yyt}4555r3   c                     |j         d |                                t          | j                  z
           }|                    |          S rL   )rj   r   r   r   	new_zeros)r0   rU   rX   r   s       r2   rd   z%ReshapeTransform.log_abs_det_jacobian'  s=    g<#dm*<*< <<={{;'''r3   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   r0   rj   cuts      r2   rk   zReshapeTransform.forward_shape+  s    u::DM****:;;;%jj3t}---;$-''QE#$$KQQ$-QQ   TcT{T^++r3   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      r2   rn   zReshapeTransform.inverse_shape5  s    u::DN++++:;;;%jj3t~...;$.((RE#$$KRR$.RR   TcT{T]**r3   ro   rp   )rf   rq   rr   rs   rt   r   r   rw   r/   r   r   r$   r%   rJ   rT   r[   rd   rk   rn   ry   rz   s   @r2   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( ( (, , ,+ + + + + + +r3   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 rL   )r   r   rN   s     r2   rP   zExpTransform.__eq__J      %...r3   c                 *    |                                 S rL   )expr^   s     r2   rT   zExpTransform._callM      uuwwr3   c                 *    |                                 S rL   logra   s     r2   r[   zExpTransform._inverseP  r   r3   c                     |S rL   rM   rc   s      r2   rd   z!ExpTransform.log_abs_det_jacobianS      r3   Nrf   rq   rr   rs   r   r   r$   positiver%   rt   rE   rP   rT   r[   rd   rM   r3   r2   r   r   @  sv          F#HID/ / /        r3   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~   )r.   r/   r   r   )r0   r   r&   r1   s      r2   r/   zPowerTransform.__init__`  s4    J///(22r3   r)   c                 H    | j         |k    r| S t          | j        |          S r~   )r*   r   r   rI   s     r2   rJ   zPowerTransform.with_cached  s*    z))Kdm
CCCCr3   c                 4    | j                                         S rL   )r   rE   r;   s    r2   rE   zPowerTransform.signi  s    }!!###r3   c                     t          |t                    sdS | j                            |j                                                                                  S r   )r   r   r   eqr   itemrN   s     r2   rP   zPowerTransform.__eq__m  sI    %00 	5}//3355::<<<r3   c                 6    |                     | j                  S rL   powr   r^   s     r2   rT   zPowerTransform._callr  s    uuT]###r3   c                 <    |                     d| j        z            S r   r  ra   s     r2   r[   zPowerTransform._inverseu  s    uuQ&'''r3   c                 d    | j         |z  |z                                                                  S rL   )r   absr   rc   s      r2   rd   z#PowerTransform.log_abs_det_jacobianx  s,    !A%**,,00222r3   c                 T    t          j        |t          | j        dd                    S Nrj   rM   r   broadcast_shapesgetattrr   ri   s     r2   rk   zPowerTransform.forward_shape{  #    %eWT]GR-P-PQQQr3   c                 T    t          j        |t          | j        dd                    S r  r  ri   s     r2   rn   zPowerTransform.inverse_shape~  r  r3   ro   rp   )rf   rq   rr   rs   r   r   r$   r%   rt   r   rw   r/   rJ   r	   rE   rP   rT   r[   rd   rk   rn   ry   rz   s   @r2   r   r   W  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r3   r   c                     t          j        | j                  }t          j        t          j        |           |j        d|j        z
            S N      ?minr   )r   finfodtypeclampsigmoidtinyeps)rU   r  s     r2   _clipped_sigmoidr    s<    K  E;u}Q''UZS59_MMMMr3   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 rL   )r   r   rN   s     r2   rP   zSigmoidTransform.__eq__      %!1222r3   c                      t          |          S rL   )r  r^   s     r2   rT   zSigmoidTransform._call  s    """r3   c                     t          j        |j                  }|                    |j        d|j        z
            }|                                |                                 z
  S r  )r   r  r  r  r  r  r   log1p)r0   rX   r  s      r2   r[   zSigmoidTransform._inverse  sM    AG$$GG
eiG88uuww1"%%r3   c                 X    t          j        |            t          j        |          z
  S rL   )Fr   rc   s      r2   rd   z%SigmoidTransform.log_abs_det_jacobian  s!    
A2A..r3   N)rf   rq   rr   rs   r   r   r$   unit_intervalr%   rt   rE   rP   rT   r[   rd   rM   r3   r2   r   r     sv          F(HID3 3 3# # #& & &
/ / / / /r3   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 rL   )r   r   rN   s     r2   rP   zSoftplusTransform.__eq__  s    %!2333r3   c                      t          |          S rL   r   r^   s     r2   rT   zSoftplusTransform._call  s    {{r3   c                 z    |                                                                                                  |z   S rL   )expm1negr   ra   s     r2   r[   zSoftplusTransform._inverse  s/    zz||!!%%''!++r3   c                 $    t          |            S rL   r,  rc   s      r2   rd   z&SoftplusTransform.log_abs_det_jacobian  s    !}r3   Nr   rM   r3   r2   r   r     sv         
 F#HID4 4 4  , , ,    r3   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 rL   )r   r   rN   s     r2   rP   zTanhTransform.__eq__  s    %///r3   c                 *    |                                 S rL   )tanhr^   s     r2   rT   zTanhTransform._call  s    vvxxr3   c                 *    t          j        |          S rL   )r   atanhra   s     r2   r[   zTanhTransform._inverse  s     {1~~r3   c                 \    dt          j        d          |z
  t          d|z            z
  z  S )N       @g       )mathr   r   rc   s      r2   rd   z"TanhTransform.log_abs_det_jacobian  s-     dhsmma'(4!8*<*<<==r3   N)rf   rq   rr   rs   r   r   r$   intervalr%   rt   rE   rP   rT   r[   rd   rM   r3   r2   r   r     s         , F#{#D#..HID0 0 0    
> > > > >r3   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 rL   )r   r   rN   s     r2   rP   zAbsTransform.__eq__  r   r3   c                 *    |                                 S rL   )r  r^   s     r2   rT   zAbsTransform._call  r   r3   c                     |S rL   rM   ra   s     r2   r[   zAbsTransform._inverse  r   r3   N)rf   rq   rr   rs   r   r   r$   r   r%   rP   rT   r[   rM   r3   r2   r   r     sW        55F#H/ / /      r3   r   c                        e Zd ZdZdZ	 	 ddeez  deez  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z  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~   )r.   r/   r@  rA  
_event_dim)r0   r@  rA  r:   r&   r1   s        r2   r/   zAffineTransform.__init__  s9     	J///
#r3   c                     | j         S rL   )rC  r;   s    r2   r:   zAffineTransform.event_dim  s
    r3   Fr   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S Nr   r:   r   r   r   r;   s    r2   r$   zAffineTransform.domain  2     >Q##&{'7HHHr3   c                 x    | j         dk    rt          j        S t          j        t          j        | j                   S rF  rG  r;   s    r2   r%   zAffineTransform.codomain  rH  r3   r)   c                 `    | j         |k    r| S t          | j        | j        | j        |          S r~   )r*   r   r@  rA  r:   rI   s     r2   rJ   zAffineTransform.with_cache!  s;    z))KHdj$.Z
 
 
 	
r3   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  rA  rN   s     r2   rP   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tr3   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   rA  r   floatrE   r;   s    r2   rE   zAffineTransform.sign<  s`    dj'** 	Vdj))A--11tz9J9JQ9N9N22TUUz   r3   c                 &    | j         | j        |z  z   S rL   r@  rA  r^   s     r2   rT   zAffineTransform._callB  s    x$*q.((r3   c                 &    || j         z
  | j        z  S rL   rO  ra   s     r2   r[   zAffineTransform._inverseE  s    DH
**r3   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   )rj   rA  r   r   r   	full_liker9  r   r  r:   sizeviewsumexpand)r0   rU   rX   rj   rA  r   result_sizes          r2   rd   z$AffineTransform.log_abs_det_jacobianH  s    
eW%% 	,_QU(<(<==FFYu%%))++F> 	- ++--(94>/(9:UBK[[--11"55F+T^O+,E}}U###r3   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  r   r  r  r@  rA  ri   s     r2   rk   zAffineTransform.forward_shapeU  ;    %748Wb1174:wPR3S3S
 
 	
r3   c           	      ~    t          j        |t          | j        dd          t          | j        dd                    S r  rY  ri   s     r2   rn   zAffineTransform.inverse_shapeZ  rZ  r3   r   r   rp   )rf   rq   rr   rs   rt   r   rM  rw   r/   rx   r:   r   r   r$   r%   rJ   rP   rE   rT   r[   rd   rk   rn   ry   rz   s   @r2   r   r     s       	 	 I 
$ 
$e^
$ ~
$ 	
$
 
$ 

$ 
$ 
$ 
$ 
$ 
$ 3    X $[#666I I 76I
 $[#666I I 76I

 
 
 
  ( !fsl ! ! ! X!
) ) )+ + +$ $ $
 
 


 
 
 
 
 
 
r3   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 unconstrained 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   r4  r  r  r  r  r   sqrtcumprodeyerj   rb  r   )r0   rU   r  rzz1m_cumprod_sqrtrX   s          r2   rT   zCorrCholeskyTransform._callu  s    JqMMk!'""&GGSa#gG..qr***
 qDE<<>>11"55	!'"+QWQXFFFF$S#2#X.Aa@@@@r3   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   rc  r_  ra  )r   cumsumr   r
   re  r%  r/  )r0   rX   y_cumsumy_cumsum_shiftedy_vecy_cumsum_vectrU   s           r2   r[   zCorrCholeskyTransform._inverse  s     u|AEr2222xSbS1Aq6CCC"12...)*:DDD\'')))WWYY(A-r3   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   rl  r_        ?r8  )rm  r
   r   rU  r   r9  )r0   rU   rX   intermediates
y1m_cumsumy1m_cumsum_trilstick_breaking_logdettanh_logdets           r2   rd   z*CorrCholeskyTransform.log_abs_det_jacobian  s     !a%B///
 -ZbAAA #&;&;&=&=&A&A"&E&E EAa 0 0048C==@EE"EMMM${22r3   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      ?ra  ru  z.Input is not a flattened lower-diagonal number)r   r-   round)r0   rj   NDs       r2   rk   z#CorrCholeskyTransform.forward_shape  s    u::>>:;;;"I4!a%<C'#-..A;!q  MNNNSbSzQF""r3   c                     t          |          dk     rt          d          |d         |d         k    rt          d          |d         }||dz
  z  dz  }|d d         |fz   S )Nra  r   rt  r   zInput is not squarer)   r   r-   )r0   rj   r~  r}  s       r2   rn   z#CorrCholeskyTransform.inverse_shape  sr    u::>>:;;;9b	!!2333"IQK1SbSzQD  r3   rL   )rf   rq   rr   rs   r   real_vectorr$   corr_choleskyr%   rt   rT   r[   rd   rk   rn   rM   r3   r2   r   r   `  s           $F(HI   
 
 
3 3 3 3# # #! ! ! ! !r3   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 rL   )r   r   rN   s     r2   rP   zSoftmaxTransform.__eq__  r"  r3   c                     |}||                     dd          d         z
                                  }||                    dd          z  S )Nr   Tr   )r   r   rU  )r0   rU   logprobsprobss       r2   rT   zSoftmaxTransform._call  sI    HLLT22155::<<uyyT****r3   c                 .    |}|                                 S rL   r   )r0   rX   r  s      r2   r[   zSoftmaxTransform._inverse  s    yy{{r3   c                 J    t          |          dk     rt          d          |S Nr)   r   r  ri   s     r2   rk   zSoftmaxTransform.forward_shape  %    u::>>:;;;r3   c                 J    t          |          dk     rt          d          |S r  r  ri   s     r2   rn   zSoftmaxTransform.inverse_shape  r  r3   N)rf   rq   rr   rs   r   r  r$   simplexr%   rP   rT   r[   rk   rn   rM   r3   r2   r   r     s{          $F"H3 3 3+ + +
    
    r3   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 rL   )r   r    rN   s     r2   rP   zStickBreakingTransform.__eq__      %!7888r3   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   rc  )rj   new_onesrm  r  r   rf  r   )r0   rU   offsetri  	z_cumprodrX   s         r2   rT   zStickBreakingTransform._call  s    q1::agbk#:#:#A#A"#E#EEQ-..UOOB''	Aq6###c)aV1&E&E&EEr3   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  )	rj   r  rm  r   r  r  r  r  r   )r0   rX   y_cropr  sfrU   s         r2   r[   zStickBreakingTransform._inverse  s    38qzz&,r*:;;BB2FFFr""" [QW!5!5!:;;;JJLL26688#fjjll2r3   c                 P   |j         d         dz   |                    |j         d                                       d          z
  }||                                z
  }| t	          j        |          z   |dd df                                         z                       d          }|S )Nr   r)   .)rj   r  rm  r   r'  
logsigmoidrU  )r0   rU   rX   r  detJs        r2   rd   z+StickBreakingTransform.log_abs_det_jacobian  s    q1::agbk#:#:#A#A"#E#EE

Q\!__$qcrc{'8'88==bAAr3   c                 t    t          |          dk     rt          d          |d d         |d         dz   fz   S Nr)   r   r   r  ri   s     r2   rk   z$StickBreakingTransform.forward_shape  >    u::>>:;;;SbSzU2Y],,,r3   c                 t    t          |          dk     rt          d          |d d         |d         dz
  fz   S r  r  ri   s     r2   rn   z$StickBreakingTransform.inverse_shape
  r  r3   N)rf   rq   rr   rs   r   r  r$   r  r%   rt   rP   rT   r[   rd   rk   rn   rM   r3   r2   r    r      s          $F"HI9 9 9      - - -
- - - - -r3   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.
    ra  c                 ,    t          |t                    S rL   )r   r   rN   s     r2   rP   zLowerCholeskyTransform.__eq__  r  r3   c                     |                     d          |                    dd                                                                          z   S Nr   rt  )dim1dim2)trildiagonalr   
diag_embedr^   s     r2   rT   zLowerCholeskyTransform._call  ?    vvbzzAJJBRJ88<<>>IIKKKKr3   c                     |                     d          |                    dd                                                                          z   S r  )r  r  r   r  ra   s     r2   r[   zLowerCholeskyTransform._inverse"  r  r3   N)rf   rq   rr   rs   r   r   r   r$   lower_choleskyr%   rP   rT   r[   rM   r3   r2   r   r     st          %[$[%5q99F)H9 9 9L L LL L L L Lr3   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.
    ra  c                 ,    t          |t                    S rL   )r   r   rN   s     r2   rP   z PositiveDefiniteTransform.__eq__.  s    %!:;;;r3   c                 D     t                      |          }||j        z  S rL   )r   mTr^   s     r2   rT   zPositiveDefiniteTransform._call1  s#    $"$$Q''14xr3   c                     t           j                            |          }t                                          |          S rL   )r   linalgcholeskyr   rA   ra   s     r2   r[   z"PositiveDefiniteTransform._inverse5  s1    L!!!$$%''++A...r3   N)rf   rq   rr   rs   r   r   r   r$   positive_definiter%   rP   rT   r[   rM   r3   r2   r   r   &  sl          %[$[%5q99F,H< < <  / / / / /r3   r   c                   $    e Zd ZU dZee         ed<   	 	 	 ddee         dedee         dz  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t          d          rfd|D             }t                                                     t	          |          | _        |dgt          | j                  z  }t	          |          | _        t          | j                  t          | j                  k    r:t          dt          | j                   dt          | j                   d          || _        d S )	Nc              3   @   K   | ]}t          |t                    V  d S rL   r   r!   r   rr  s     r2   r   z(CatTransform.__init__.<locals>.<genexpr>R  ,      :::a++::::::r3   0All elements of tseq must be Transform instancesc                 :    g | ]}|                               S rM   r   r   rr  r&   s     r2   r   z)CatTransform.__init__.<locals>.<listcomp>U  %    ;;;ALL,,;;;r3   rG   r)   z	lengths (z) must match transforms (r   )	r   r   r.   r/   r   r  r   r  r   )r0   r  r   r  r&   r1   s       `r2   r/   zCatTransform.__init__K  s    ::T::::: 	U !STTT 	<;;;;d;;;DJ///t**?cC000GG}}t|DO 4 444 _C--__DOH\H\___   r3   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rL   )r:   r  s     r2   r   z)CatTransform.event_dim.<locals>.<genexpr>c  $      8811;888888r3   )r   r  r;   s    r2   r:   zCatTransform.event_dima  !    88888888r3   c                 *    t          | j                  S rL   )rU  r  r;   s    r2   lengthzCatTransform.lengthe  s    4<   r3   r)   c                 ^    | j         |k    r| S t          | j        | j        | j        |          S rL   )r*   r   r  r   r  rI   s     r2   rJ   zCatTransform.with_cachei  s/    z))KDOTXt|ZPPPr3   c                    |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   | j        k    r:t          d| j          d|                    | j                    d| j                   g }d}t	          | j        | j                  D ]D\  }}|                    | j         ||          }|                     ||                     ||z   }Et          j
        || j                   S )	Ndim  out of range for tensor with  dimensionsx.size() =  must equal length r   rl  )r   r   rS  r  r   r  r  narrowr   r   cat)r0   rU   yslicesstarttransr  xslices          r2   rT   zCatTransform._calln  sC   DH....quuww.... StxSSquuwwSSS   66$(t{** Z$(ZZtx(8(8ZZT[ZZ    $,?? 	# 	#ME6XXdhv66FNN55==)))FNEEydh////r3   c                    |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   | j        k    r:t          d| j          d|                    | j                    d| j                   g }d}t	          | j        | j                  D ]N\  }}|                    | j         ||          }|                    |	                    |                     ||z   }Ot          j        || j                   S )	Nr  r  r  y.size(r  r  r   rl  )r   r   rS  r  r   r  r  r  r   rA   r   r  )r0   rX   xslicesr  r  r  yslices          r2   r[   zCatTransform._inverse  sG   DH....quuww.... StxSSquuwwSSS   66$(t{** Z$(ZZtx(8(8ZZT[ZZ    $,?? 	# 	#ME6XXdhv66FNN599V,,---FNEEydh////r3   c                 2   |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   | j        k    r:t          d| j          d|                    | j                    d| j                   |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   | j        k    r:t          d| j          d|                    | j                    d| 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 )Nr   out of range for x with r  r  r  r   out of range for y with r  r   rl  )r   r   rS  r  r   r  r  r  rd   r:   r   r   r   r  rU  )r0   rU   rX   
logdetjacsr  r  r  r  r  	logdetjacr   s              r2   rd   z!CatTransform.log_abs_det_jacobian  s   DH....quuww.... NtxNN!%%''NNN   66$(t{** Z$(ZZtx(8(8ZZT[ZZ   DH....quuww.... NtxNN!%%''NNN   66$(t{** Z$(ZZtx(8(8ZZT[ZZ   
 $,?? 	# 	#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??"r3   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rL   r   r  s     r2   r   z)CatTransform.bijective.<locals>.<genexpr>  r  r3   r   r  r;   s    r2   rt   zCatTransform.bijective  r  r3   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rM   r$   r  s     r2   r   z'CatTransform.domain.<locals>.<listcomp>  s    ///!QX///r3   r   r  r  r   r  r;   s    r2   r$   zCatTransform.domain  s3     //t///4<
 
 	
r3   c                 `    t          j        d | j        D             | j        | j                  S )Nc                     g | ]	}|j         
S rM   r%   r  s     r2   r   z)CatTransform.codomain.<locals>.<listcomp>  s    111AQZ111r3   r  r;   s    r2   r%   zCatTransform.codomain  s3     1111148T\
 
 	
r3   )r   Nr   rp   )rf   rq   rr   rs   r   r!   rv   r   rw   r/   r	   r:   r  rJ   rT   r[   rd   rx   r   rt   r   r   r$   r%   ry   rz   s   @r2   r   r   :  s          Y
 (, y!  #%	
  
     , 93 9 9 9 ]9 ! ! ! ! ]!Q Q Q Q
0 0 0"0 0 0"## ## ##J 94 9 9 9 X9 #
 
 $#

 #
 
 $#
 
 
 
 
r3   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t          d          rfd|D             }t                                                     t	          |          | _        || _        d S )Nc              3   @   K   | ]}t          |t                    V  d S rL   r  r  s     r2   r   z*StackTransform.__init__.<locals>.<genexpr>  r  r3   r  c                 :    g | ]}|                               S rM   r   r  s     r2   r   z+StackTransform.__init__.<locals>.<listcomp>  r  r3   rG   )r   r   r.   r/   r   r  r   )r0   r  r   r&   r1   s      `r2   r/   zStackTransform.__init__  s     ::T::::: 	U !STTT 	<;;;;d;;;DJ///t**r3   r)   c                 R    | j         |k    r| S t          | j        | j        |          S rL   )r*   r   r  r   rI   s     r2   rJ   zStackTransform.with_cache  s+    z))KdotxDDDr3   c                 n      fdt                               j                            D             S )Nc                 F    g | ]}                     j        |          S rM   )selectr   )r   ir0   ri  s     r2   r   z)StackTransform._slice.<locals>.<listcomp>  s)    GGG!1%%GGGr3   )rangerS  r   )r0   ri  s   ``r2   _slicezStackTransform._slice  s7    GGGGGuQVVDH5E5E/F/FGGGGr3   c           
         |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   t          | j                  k    rGt          d| j          d|                    | j                    dt          | j                             g }t          |                     |          | j                  D ]#\  }}|                     ||                     $t          j	        || j                   S )Nr  r  r  r  r   must equal len(transforms) rl  )
r   r   rS  r   r  r   r  r   r   stack)r0   rU   r  r  r  s        r2   rT   zStackTransform._call  s:   DH....quuww.... StxSSquuwwSSS   66$(s4?3333 l$(lltx(8(8llVYZ^ZiVjVjll    QAA 	* 	*MFENN55==)))){71111r3   c           
         |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   t          | j                  k    rGt          d| j          d|                    | j                    dt          | j                             g }t          |                     |          | j                  D ]-\  }}|                    |                    |                     .t          j
        || j                   S )Nr  r  r  r  r  r  rl  )r   r   rS  r   r  r   r  r   rA   r   r  )r0   rX   r  r  r  s        r2   r[   zStackTransform._inverse  s>   DH....quuww.... StxSSquuwwSSS   66$(s4?3333 l$(lltx(8(8llVYZ^ZiVjVjll    QAA 	. 	.MFENN599V,,----{71111r3   c           
         |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   t          | j                  k    rGt          d| j          d|                    | j                    dt          | j                             |                                  | j         cxk    r|                                 k     s/n t          d| j          d|                                  d          |                    | j                   t          | j                  k    rGt          d| j          d|                    | j                    dt          | j                             g }|                     |          }|                     |          }t          ||| j                  D ]/\  }}}|                    |                    ||                     0t          j
        || j         	          S )
Nr  r  r  r  r  r  r  r  rl  )r   r   rS  r   r  r  r   r   rd   r   r  )	r0   rU   rX   r  r  r  r  r  r  s	            r2   rd   z#StackTransform.log_abs_det_jacobian  s5   DH....quuww.... NtxNN!%%''NNN   66$(s4?3333 l$(lltx(8(8llVYZ^ZiVjVjll   DH....quuww.... NtxNN!%%''NNN   66$(s4?3333 l$(lltx(8(8llVYZ^ZiVjVjll   
++a..++a..%('4?%K%K 	J 	J!FFEe88HHIIII{:484444r3   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rL   r   r  s     r2   r   z+StackTransform.bijective.<locals>.<genexpr>   r  r3   r  r;   s    r2   rt   zStackTransform.bijective  r  r3   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rM   r  r  s     r2   r   z)StackTransform.domain.<locals>.<listcomp>%  s    !D!D!Dq!(!D!D!Dr3   r   r  r  r   r;   s    r2   r$   zStackTransform.domain"  s*      !D!DDO!D!D!DdhOOOr3   c                 T    t          j        d | j        D             | j                  S )Nc                     g | ]	}|j         
S rM   r  r  s     r2   r   z+StackTransform.codomain.<locals>.<listcomp>*  s    !F!F!F!*!F!F!Fr3   r  r;   s    r2   r%   zStackTransform.codomain'  s*      !F!Fdo!F!F!FQQQr3   r\  rp   )rf   rq   rr   rs   r   r!   rv   r   rw   r/   rJ   r  rT   r[   rd   rx   r   rt   r   r   r$   r%   ry   rz   s   @r2   r   r     sR        
 
 Y JK	 	Y'	.1	CF			 	 	 	 	 	E E E E
H H H2 2 22 2 25 5 50 94 9 9 9 X9 #P P $#P #R R $#R R R R Rr3   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j        dz  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~   )r.   r/   r  )r0   r  r&   r1   s      r2   r/   z(CumulativeDistributionTransform.__init__D  s,    J///(r3   c                     | j         j        S rL   )r  supportr;   s    r2   r$   z&CumulativeDistributionTransform.domainH  s     ((r3   c                 6    | j                             |          S rL   )r  cdfr^   s     r2   rT   z%CumulativeDistributionTransform._callL  s     $$Q'''r3   c                 6    | j                             |          S rL   )r  icdfra   s     r2   r[   z(CumulativeDistributionTransform._inverseO  s     %%a(((r3   c                 6    | j                             |          S rL   )r  log_probrc   s      r2   rd   z4CumulativeDistributionTransform.log_abs_det_jacobianR  s     ))!,,,r3   c                 H    | j         |k    r| S t          | j        |          S r~   )r*   r   r  rI   s     r2   rJ   z*CumulativeDistributionTransform.with_cacheU  s+    z))K.t/@ZXXXXr3   ro   rp   )rf   rq   rr   rs   rt   r   r(  r%   rE   r   rw   r/   rx   ru   r$   rT   r[   rd   rJ   ry   rz   s   @r2   r   r   -  s         $ I(HD) )\ )s )4 ) ) ) ) ) ) ).5 ) ) ) X)( ( () ) )- - -Y Y Y Y Y Y Y Yr3   r   )1r   r9  r   r>   collections.abcr   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   rM   r3   r2   <module>r     s          $ $ $ $ $ $                 + + + + + + 9 9 9 9 9 9              . - - - - - - -        0f f f f f f f fRE. E. E. E. E.	 E. E. E.P    y   D &%b)) K8 K8 K8 K8 K89 K8 K8 K8\I+ I+ I+ I+ I+y I+ I+ I+X    9   .(R (R (R (R (RY (R (R (RVN N N
/ / / / /y / / /2    	   0*> *> *> *> *>I *> *> *>Z    9    h
 h
 h
 h
 h
i h
 h
 h
VQ! Q! Q! Q! Q!I Q! Q! Q!h! ! ! ! !y ! ! !H5- 5- 5- 5- 5-Y 5- 5- 5-pL L L L LY L L L,/ / / / /	 / / /(K
 K
 K
 K
 K
9 K
 K
 K
\bR bR bR bR bRY bR bR bRJ+Y +Y +Y +Y +Yi +Y +Y +Y +Y +Yr3   