3
O4W^áT  ã               @   sZ  d dl Z d dlZd dlZd dlZd dljjZd dlm	Z	 d dl
mZmZmZ d dlmZ ddddd	d
dddddddgZG dd„ deƒZG dd„ deƒZG dd„ deƒZeg ƒZG dd	„ d	eƒZG dd„ deƒZdd„ ZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd
„ d
eƒZG d d„ deƒZG d!d„ deƒZdS )"é    N)Úconstraints)Ú_sum_rightmostÚbroadcast_allÚlazy_property)ÚpadÚAbsTransformÚAffineTransformÚCatTransformÚComposeTransformÚExpTransformÚLowerCholeskyTransformÚPowerTransformÚSigmoidTransformÚSoftmaxTransformÚStackTransformÚStickBreakingTransformÚ	TransformÚidentity_transformc                   s‚   e Zd ZdZdZdZd‡ fdd„	Zedd„ ƒZedd	„ ƒZ	d
d„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Z‡  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 tranforms 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.
        event_dim (int): Number of dimensions that are correlated together in
            the transform ``event_shape``. This should be 0 for pointwise
            transforms, 1 for transforms that act jointly on vectors, 2 for
            transforms that act jointly on matrices, etc.
    Fr   c                s@   || _ d | _|dkrn|dkr&d| _ntdƒ‚tt| ƒjƒ  d S )Nr   é   zcache_size must be 0 or 1)NN)Ú_cache_sizeÚ_invÚ_cached_x_yÚ
ValueErrorÚsuperr   Ú__init__)ÚselfÚ
cache_size)Ú	__class__© ú?/tmp/pip-build-e66j97b2/torch/torch/distributions/transforms.pyr   P   s    zTransform.__init__c             C   s6   d}| j dk	r| j ƒ }|dkr2t| ƒ}tj|ƒ| _ |S )z{
        Returns the inverse :class:`Transform` of this transform.
        This should satisfy ``t.inv.inv is t``.
        N)r   Ú_InverseTransformÚweakrefÚref)r   Úinvr   r   r   r#   [   s    
zTransform.invc             C   s   t ‚dS )z˜
        Returns the sign of the determinant of the Jacobian, if applicable.
        In general this only makes sense for bijective transforms.
        N)ÚNotImplementedError)r   r   r   r   Úsigni   s    zTransform.signc             C   s   | |kS )Nr   )r   Úotherr   r   r   Ú__eq__q   s    zTransform.__eq__c             C   s   | j |ƒ S )N)r'   )r   r&   r   r   r   Ú__ne__t   s    zTransform.__ne__c             C   sB   | j dkr| j|ƒS | j\}}||kr*|S | j|ƒ}||f| _|S )z2
        Computes the transform `x => y`.
        r   )r   Ú_callr   )r   ÚxÚx_oldÚy_oldÚyr   r   r   Ú__call__x   s    




zTransform.__call__c             C   sB   | j dkr| j|ƒS | j\}}||kr*|S | j|ƒ}||f| _|S )z1
        Inverts the transform `y => x`.
        r   )r   Ú_inverser   )r   r-   r+   r,   r*   r   r   r   Ú	_inv_call…   s    




zTransform._inv_callc             C   s   t ‚dS )zD
        Abstract method to compute forward transformation.
        N)r$   )r   r*   r   r   r   r)   ’   s    zTransform._callc             C   s   t ‚dS )zD
        Abstract method to compute inverse transformation.
        N)r$   )r   r-   r   r   r   r/   ˜   s    zTransform._inversec             C   s   t ‚dS )zU
        Computes the log det jacobian `log |dy/dx|` given input and output.
        N)r$   )r   r*   r-   r   r   r   Úlog_abs_det_jacobianž   s    zTransform.log_abs_det_jacobianc             C   s   | j jd S )Nz())r   Ú__name__)r   r   r   r   Ú__repr__¤   s    zTransform.__repr__)r   )r2   Ú
__module__Ú__qualname__Ú__doc__Ú	bijectiveÚ	event_dimr   Úpropertyr#   r%   r'   r(   r.   r0   r)   r/   r1   r3   Ú__classcell__r   r   )r   r   r      s   /c                   s„   e Zd ZdZ‡ fdd„Zejdd„ ƒZejdd„ ƒZe	dd	„ ƒZ
e	d
d„ ƒZe	dd„ ƒZe	dd„ ƒZdd„ Zdd„ Zdd„ Z‡  ZS )r    z|
    Inverts a single :class:`Transform`.
    This class is private; please instead use the ``Transform.inv`` property.
    c                s   t t| ƒjƒ  || _d S )N)r   r    r   r   )r   Z	transform)r   r   r   r   ­   s    z_InverseTransform.__init__c             C   s   | j jS )N)r   Úcodomain)r   r   r   r   Údomain±   s    z_InverseTransform.domainc             C   s   | j jS )N)r   r<   )r   r   r   r   r;   µ   s    z_InverseTransform.codomainc             C   s   | j jS )N)r   r7   )r   r   r   r   r7   ¹   s    z_InverseTransform.bijectivec             C   s   | j jS )N)r   r%   )r   r   r   r   r%   ½   s    z_InverseTransform.signc             C   s   | j jS )N)r   r8   )r   r   r   r   r8   Á   s    z_InverseTransform.event_dimc             C   s   | j S )N)r   )r   r   r   r   r#   Å   s    z_InverseTransform.invc             C   s   t |tƒsdS | j|jkS )NF)Ú
isinstancer    r   )r   r&   r   r   r   r'   É   s    
z_InverseTransform.__eq__c             C   s   | j j|ƒS )N)r   r0   )r   r*   r   r   r   r.   Î   s    z_InverseTransform.__call__c             C   s   | j j||ƒ S )N)r   r1   )r   r*   r-   r   r   r   r1   Ñ   s    z&_InverseTransform.log_abs_det_jacobian)r2   r4   r5   r6   r   r   Údependent_propertyr<   r;   r9   r7   r%   r8   r#   r'   r.   r1   r:   r   r   )r   r   r    ¨   s   r    c                   sŒ   e Zd ZdZ‡ fdd„Zdd„ Zejdd„ ƒZejdd	„ ƒZ	e
d
d„ ƒZe
dd„ ƒZe
dd„ ƒZedd„ ƒZdd„ Zdd„ Zdd„ Z‡  ZS )r
   zÉ
    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.
    c                s   t t| ƒjƒ  || _d S )N)r   r
   r   Úparts)r   r?   )r   r   r   r   Ý   s    zComposeTransform.__init__c             C   s   t |tƒsdS | j|jkS )NF)r=   r
   r?   )r   r&   r   r   r   r'   á   s    
zComposeTransform.__eq__c             C   s   | j stjS | j d jS )Nr   )r?   r   Úrealr<   )r   r   r   r   r<   æ   s    zComposeTransform.domainc             C   s   | j stjS | j d jS )Nr   éÿÿÿÿ)r?   r   r@   r;   )r   r   r   r   r;   ì   s    zComposeTransform.codomainc             C   s   t dd„ | jD ƒƒS )Nc             s   s   | ]}|j V  qd S )N)r7   )Ú.0Úpr   r   r   ú	<genexpr>ô   s    z-ComposeTransform.bijective.<locals>.<genexpr>)Úallr?   )r   r   r   r   r7   ò   s    zComposeTransform.bijectivec             C   s"   d}x| j D ]}||j }qW |S )Nr   )r?   r%   )r   r%   rC   r   r   r   r%   ö   s    zComposeTransform.signc             C   s   | j rtdd„ | j D ƒƒS dS )Nc             s   s   | ]}|j V  qd S )N)r8   )rB   rC   r   r   r   rD   ÿ   s    z-ComposeTransform.event_dim.<locals>.<genexpr>r   )r?   Úmax)r   r   r   r   r8   ý   s    zComposeTransform.event_dimc             C   sR   d }| j d k	r| j ƒ }|d krNtdd„ t| jƒD ƒƒ}tj|ƒ| _ tj| ƒ|_ |S )Nc             S   s   g | ]
}|j ‘qS r   )r#   )rB   rC   r   r   r   ú
<listcomp>  s    z(ComposeTransform.inv.<locals>.<listcomp>)r   r
   Úreversedr?   r!   r"   )r   r#   r   r   r   r#     s    
zComposeTransform.invc             C   s   x| j D ]}||ƒ}qW |S )N)r?   )r   r*   Úpartr   r   r   r.     s    zComposeTransform.__call__c             C   s‚   | j stj|ƒS d}x@| j d d… D ].}||ƒ}|t|j||ƒ| j|j ƒ }|}q$W | j d }|t|j||ƒ| j|j ƒ }|S )Nr   r   rA   rA   )r?   ÚtorchZ
zeros_liker   r1   r8   )r   r*   r-   ÚresultrI   Zy_tmpr   r   r   r1     s    

z%ComposeTransform.log_abs_det_jacobianc             C   s2   | j jd }|djdd„ | jD ƒƒ7 }|d7 }|S )Nz(
    z,
    c             S   s   g | ]}|j ƒ ‘qS r   )r3   )rB   rC   r   r   r   rG   !  s    z-ComposeTransform.__repr__.<locals>.<listcomp>z
))r   r2   Újoinr?   )r   Z
fmt_stringr   r   r   r3     s    zComposeTransform.__repr__)r2   r4   r5   r6   r   r'   r   r>   r<   r;   r   r7   r%   r8   r9   r#   r.   r1   r3   r:   r   r   )r   r   r
   Õ   s   c               @   sD   e Zd ZdZejZejZdZ	dZ
dd„ Zdd„ Zdd	„ Zd
d„ ZdS )r   z8
    Transform via the mapping :math:`y = \exp(x)`.
    Tr   c             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'   2  s    zExpTransform.__eq__c             C   s   |j ƒ S )N)Úexp)r   r*   r   r   r   r)   5  s    zExpTransform._callc             C   s   |j ƒ S )N)Úlog)r   r-   r   r   r   r/   8  s    zExpTransform._inversec             C   s   |S )Nr   )r   r*   r-   r   r   r   r1   ;  s    z!ExpTransform.log_abs_det_jacobianNr   )r2   r4   r5   r6   r   r@   r<   Úpositiver;   r7   r%   r'   r)   r/   r1   r   r   r   r   r   )  s   c                   sV   e Zd ZdZejZejZdZdZ	d‡ fdd„	Z
dd„ Zd	d
„ Zdd„ Zdd„ Z‡  ZS )r   zD
    Transform via the mapping :math:`y = x^{\text{exponent}}`.
    Tr   r   c                s"   t t| ƒj|d� t|ƒ\| _d S )N)r   )r   r   r   r   Úexponent)r   rP   r   )r   r   r   r   H  s    zPowerTransform.__init__c             C   s$   t |tƒsdS | jj|jƒjƒ jƒ S )NF)r=   r   rP   ÚeqrE   Úitem)r   r&   r   r   r   r'   L  s    
zPowerTransform.__eq__c             C   s   |j | jƒS )N)ÚpowrP   )r   r*   r   r   r   r)   Q  s    zPowerTransform._callc             C   s   |j d| j ƒS )Nr   )rS   rP   )r   r-   r   r   r   r/   T  s    zPowerTransform._inversec             C   s   | j | | jƒ jƒ S )N)rP   ÚabsrN   )r   r*   r-   r   r   r   r1   W  s    z#PowerTransform.log_abs_det_jacobianr   )r   )r2   r4   r5   r6   r   rO   r<   r;   r7   r%   r   r'   r)   r/   r1   r:   r   r   )r   r   r   ?  s   c             C   s*   t j| jƒ}t jt j| ƒ|jd|j d�S )Ng      ð?)ÚminrF   )rJ   ÚfinfoÚdtypeÚclampZsigmoidÚtinyÚeps)r*   rV   r   r   r   Ú_clipped_sigmoid[  s    r[   c               @   sD   e Zd ZdZejZejZdZ	dZ
dd„ Zdd„ Zdd	„ Zd
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             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'   i  s    zSigmoidTransform.__eq__c             C   s   t |ƒS )N)r[   )r   r*   r   r   r   r)   l  s    zSigmoidTransform._callc             C   s4   t j|jƒ}|j|jd|j d�}|jƒ | jƒ  S )Ng      ð?)rU   rF   )rJ   rV   rW   rX   rY   rZ   rN   Úlog1p)r   r-   rV   r   r   r   r/   o  s    zSigmoidTransform._inversec             C   s   t j| ƒ t j|ƒ S )N)ÚFZsoftplus)r   r*   r-   r   r   r   r1   t  s    z%SigmoidTransform.log_abs_det_jacobianNr   )r2   r4   r5   r6   r   r@   r<   Zunit_intervalr;   r7   r%   r'   r)   r/   r1   r   r   r   r   r   `  s   c               @   s4   e Zd ZdZejZejZdd„ Z	dd„ Z
dd„ ZdS )	r   z4
    Transform via the mapping :math:`y = |x|`.
    c             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'     s    zAbsTransform.__eq__c             C   s   |j ƒ S )N)rT   )r   r*   r   r   r   r)   ‚  s    zAbsTransform._callc             C   s   |S )Nr   )r   r-   r   r   r   r/   …  s    zAbsTransform._inverseN)r2   r4   r5   r6   r   r@   r<   rO   r;   r'   r)   r/   r   r   r   r   r   x  s   c                   s^   e Zd ZdZejZejZdZd‡ fdd„	Z	dd„ Z
edd	„ ƒZd
d„ Zdd„ Zdd„ Z‡  ZS )r   a¤  
    Transform via the pointwise affine mapping :math:`y = \text{loc} + \text{scale} \times x`.

    Args:
        loc (Tensor or float): Location parameter.
        scale (Tensor or float): Scale parameter.
        event_dim (int): Optional size of `event_shape`. This should be zero
            for univariate random variables, 1 for distributions over vectors,
            2 for distributions over matrices, etc.
    Tr   c                s(   t t| ƒj|d� || _|| _|| _d S )N)r   )r   r   r   ÚlocÚscaler8   )r   r^   r_   r8   r   )r   r   r   r   ˜  s    zAffineTransform.__init__c             C   sž   t |tƒsdS t | jtjƒr<t |jtjƒr<| j|jkrTdS n| j|jkjƒ jƒ sTdS t | jtjƒr‚t |jtjƒr‚| j|jkršdS n| j|jkjƒ jƒ sšdS dS )NFT)r=   r   r^   ÚnumbersÚNumberrE   rR   r_   )r   r&   r   r   r   r'   ž  s    
zAffineTransform.__eq__c             C   s8   t | jtjƒr.| jdkrdS | jdk r*dS dS | jjƒ S )Nr   r   rA   )r=   r_   r`   ra   r%   )r   r   r   r   r%   ²  s     zAffineTransform.signc             C   s   | j | j|  S )N)r^   r_   )r   r*   r   r   r   r)   ¸  s    zAffineTransform._callc             C   s   || j  | j S )N)r^   r_   )r   r-   r   r   r   r/   »  s    zAffineTransform._inversec             C   s†   |j }| j}t|tjƒr0tj|tjt	|ƒƒƒ}ntj	|ƒjƒ }| j
r||jƒ d | j
 … d }|j|ƒjdƒ}|d | j
 … }|j|ƒS )Nr   rA   )rA   rA   )Úshaper_   r=   r`   ra   rJ   Z	full_likeÚmathrN   rT   r8   ÚsizeÚviewÚsumÚexpand)r   r*   r-   rb   r_   rK   Zresult_sizer   r   r   r1   ¾  s    z$AffineTransform.log_abs_det_jacobian)r   r   )r2   r4   r5   r6   r   r@   r<   r;   r7   r   r'   r9   r%   r)   r/   r1   r:   r   r   )r   r   r   ‰  s   
c               @   s8   e Zd ZdZejZejZdZ	dd„ Z
dd„ Zd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.
    r   c             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'   Ù  s    zSoftmaxTransform.__eq__c             C   s,   |}||j ddƒd  jƒ }||jddƒ S )Nr   Tr   rA   rA   )rF   rM   rf   )r   r*   ZlogprobsÚprobsr   r   r   r)   Ü  s    zSoftmaxTransform._callc             C   s   |}|j ƒ S )N)rN   )r   r-   rh   r   r   r   r/   á  s    zSoftmaxTransform._inverseN)r2   r4   r5   r6   r   r@   r<   Úsimplexr;   r8   r'   r)   r/   r   r   r   r   r   Ì  s   c               @   sD   e Zd ZdZejZejZdZ	dZ
dd„ Zdd„ Zdd	„ Zd
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.
    Tr   c             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'   ø  s    zStickBreakingTransform.__eq__c             C   sb   |j d d |j|j d ƒjdƒ }t||jƒ  ƒ}d| jdƒ}t|ddd�t|d	dd� }|S )
Nr   r   )ÚvaluerA   rA   rA   rA   )r   r   )r   r   )rb   Únew_onesÚcumsumr[   rN   Zcumprodr   )r   r*   ÚoffsetÚzZ	z_cumprodr-   r   r   r   r)   û  s
    $zStickBreakingTransform._callc             C   sr   |dd d…f }|j d |j|j d ƒjdƒ }d|jdƒ }tj|tj|jƒjd�}|jƒ |jƒ  |jƒ  }|S )	N.r   )rU   rA   rA   rA   rA   rA   )	rb   rk   rl   rJ   rX   rV   rW   rY   rN   )r   r-   Zy_croprm   Zsfr*   r   r   r   r/     s     zStickBreakingTransform._inversec             C   s^   |j d d |j|j d ƒjdƒ }||jƒ  }| tj|ƒ |dd d…f jƒ  jdƒ}|S )Nr   .rA   rA   rA   rA   rA   )rb   rk   rl   rN   r]   Z
logsigmoidrf   )r   r*   r-   rm   ZdetJr   r   r   r1     s    $*z+StickBreakingTransform.log_abs_det_jacobianN)r2   r4   r5   r6   r   r@   r<   ri   r;   r7   r8   r'   r)   r/   r1   r   r   r   r   r   æ  s   
c               @   s8   e Zd ZdZejZejZdZ	dd„ Z
dd„ Zd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.
    é   c             C   s
   t |tƒS )N)r=   r   )r   r&   r   r   r   r'      s    zLowerCholeskyTransform.__eq__c             C   s    |j dƒ|jddd�jƒ jƒ  S )Nr   ro   )Údim1Údim2rA   éþÿÿÿrA   )ÚtrilÚdiagonalrM   Ú
diag_embed)r   r*   r   r   r   r)   #  s    zLowerCholeskyTransform._callc             C   s    |j dƒ|jddd�jƒ jƒ  S )Nr   ro   )rp   rq   rA   rr   rA   )rs   rt   rN   ru   )r   r-   r   r   r   r/   &  s    zLowerCholeskyTransform._inverseN)r2   r4   r5   r6   r   r@   r<   Zlower_choleskyr;   r8   r'   r)   r/   r   r   r   r   r     s   c                   sn   e Zd ZdZd‡ fdd„	Zedd„ ƒZdd	„ Zd
d„ Zdd„ Z	e
dd„ ƒZejdd„ ƒZejdd„ ƒZ‡  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)
    r   Nc                sr   t dd„ |D ƒƒst‚tt| ƒjƒ  t|ƒ| _|d krFdgt| jƒ }t|ƒ| _t| jƒt| jƒksht‚|| _	d S )Nc             s   s   | ]}t |tƒV  qd S )N)r=   r   )rB   Útr   r   r   rD   8  s    z(CatTransform.__init__.<locals>.<genexpr>r   )
rE   ÚAssertionErrorr   r	   r   ÚlistÚ
transformsÚlenÚlengthsÚdim)r   Útseqr|   r{   )r   r   r   r   7  s    

zCatTransform.__init__c             C   s
   t | jƒS )N)rf   r{   )r   r   r   r   ÚlengthA  s    zCatTransform.lengthc             C   s˜   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒ| jks>t‚g }d}x@t| j| jƒD ].\}}|j| j ||ƒ}|j||ƒƒ || }qVW t	j
|| j d�S )Nr   )r|   )r|   rw   rd   r~   Úzipry   r{   ÚnarrowÚappendrJ   Úcat)r   r*   ÚyslicesÚstartÚtransr~   Úxslicer   r   r   r)   E  s    (zCatTransform._callc             C   sš   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒ| jks>t‚g }d}xBt| j| jƒD ]0\}}|j| j ||ƒ}|j|j	|ƒƒ || }qVW t
j|| j d�S )Nr   )r|   )r|   rw   rd   r~   r   ry   r{   r€   r�   r#   rJ   r‚   )r   r-   Úxslicesr„   r…   r~   Úyslicer   r   r   r/   P  s    (zCatTransform._inversec       	      C   sê   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒ| jks>t‚|j ƒ  | j   ko\|j ƒ k n  sft‚|j| j ƒ| jks|t‚g }d}xTt| j| jƒD ]B\}}|j| j ||ƒ}|j| j ||ƒ}|j|j	||ƒƒ || }q”W t
j|| j d�S )Nr   )r|   )r|   rw   rd   r~   r   ry   r{   r€   r�   r1   rJ   r‚   )	r   r*   r-   Ú
logdetjacsr„   r…   r~   r†   rˆ   r   r   r   r1   [  s    ((z!CatTransform.log_abs_det_jacobianc             C   s   t dd„ | jD ƒƒS )Nc             s   s   | ]}|j V  qd S )N)r7   )rB   rv   r   r   r   rD   k  s    z)CatTransform.bijective.<locals>.<genexpr>)rE   ry   )r   r   r   r   r7   i  s    zCatTransform.bijectivec             C   s   t jdd„ | jD ƒ| j| jƒS )Nc             S   s   g | ]
}|j ‘qS r   )r<   )rB   rv   r   r   r   rG   o  s    z'CatTransform.domain.<locals>.<listcomp>)r   r‚   ry   r|   r{   )r   r   r   r   r<   m  s    zCatTransform.domainc             C   s   t jdd„ | jD ƒ| j| jƒS )Nc             S   s   g | ]
}|j ‘qS r   )r;   )rB   rv   r   r   r   rG   t  s    z)CatTransform.codomain.<locals>.<listcomp>)r   r‚   ry   r|   r{   )r   r   r   r   r;   r  s    zCatTransform.codomain)r   N)r2   r4   r5   r6   r   r   r~   r)   r/   r1   r9   r7   r   r>   r<   r;   r:   r   r   )r   r   r	   *  s   
c                   sj   e Zd ZdZd‡ fdd„	Zdd„ Zdd„ Zd	d
„ Zdd„ Ze	dd„ ƒZ
ejdd„ ƒZejdd„ ƒZ‡  ZS )r   aV  
    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   c                s8   t dd„ |D ƒƒst‚tt| ƒjƒ  t|ƒ| _|| _d S )Nc             s   s   | ]}t |tƒV  qd S )N)r=   r   )rB   rv   r   r   r   rD   „  s    z*StackTransform.__init__.<locals>.<genexpr>)rE   rw   r   r   r   rx   ry   r|   )r   r}   r|   )r   r   r   r   ƒ  s    
zStackTransform.__init__c                s    ‡ ‡fdd„t ˆjˆ jƒƒD ƒS )Nc                s   g | ]}ˆj ˆ j|ƒ‘qS r   )Úselectr|   )rB   Úi)r   rn   r   r   rG   Š  s    z)StackTransform._slice.<locals>.<listcomp>)Úrangerd   r|   )r   rn   r   )r   rn   r   Ú_slice‰  s    zStackTransform._slicec             C   s„   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒt| jƒksBt‚g }x,t| j|ƒ| jƒD ]\}}|j||ƒƒ qZW tj	|| j d�S )N)r|   )
r|   rw   rd   rz   ry   r   r�   r�   rJ   Ústack)r   r*   rƒ   r†   r…   r   r   r   r)   Œ  s    (zStackTransform._callc             C   s†   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒt| jƒksBt‚g }x.t| j|ƒ| jƒD ]\}}|j|j|ƒƒ qZW t	j
|| j d�S )N)r|   )r|   rw   rd   rz   ry   r   r�   r�   r#   rJ   rŽ   )r   r-   r‡   rˆ   r…   r   r   r   r/   ”  s    (zStackTransform._inversec       	      C   sÜ   |j ƒ  | j   ko|j ƒ k n  s(t‚|j| j ƒt| jƒksBt‚|j ƒ  | j   ko`|j ƒ k n  sjt‚|j| j ƒt| jƒks„t‚g }| j|ƒ}| j|ƒ}x.t||| jƒD ]\}}}|j|j||ƒƒ q¬W t	j
|| j d�S )N)r|   )r|   rw   rd   rz   ry   r�   r   r�   r1   rJ   rŽ   )	r   r*   r-   r‰   rƒ   r‡   r†   rˆ   r…   r   r   r   r1   œ  s    ((

z#StackTransform.log_abs_det_jacobianc             C   s   t dd„ | jD ƒƒS )Nc             s   s   | ]}|j V  qd S )N)r7   )rB   rv   r   r   r   rD   ª  s    z+StackTransform.bijective.<locals>.<genexpr>)rE   ry   )r   r   r   r   r7   ¨  s    zStackTransform.bijectivec             C   s   t jdd„ | jD ƒ| jƒS )Nc             S   s   g | ]
}|j ‘qS r   )r<   )rB   rv   r   r   r   rG   ®  s    z)StackTransform.domain.<locals>.<listcomp>)r   rŽ   ry   r|   )r   r   r   r   r<   ¬  s    zStackTransform.domainc             C   s   t jdd„ | jD ƒ| jƒS )Nc             S   s   g | ]
}|j ‘qS r   )r;   )rB   rv   r   r   r   rG   ²  s    z+StackTransform.codomain.<locals>.<listcomp>)r   rŽ   ry   r|   )r   r   r   r   r;   °  s    zStackTransform.codomain)r   )r2   r4   r5   r6   r   r�   r)   r/   r1   r9   r7   r   r>   r<   r;   r:   r   r   )r   r   r   x  s   
) rc   r`   r!   rJ   Ztorch.nn.functionalÚnnZ
functionalr]   Ztorch.distributionsr   Ztorch.distributions.utilsr   r   r   r   Ú__all__Úobjectr   r    r
   r   r   r   r[   r   r   r   r   r   r   r	   r   r   r   r   r   Ú<module>   sH    -QC.N