o hҢ@sddlZddlZddlZddlZddlmZddlZddlmm Z ddl m Z ddl mZmZmZmZmZddlmZmZddlmZgdZGdd d ZGd d d eZGd d d eZegZGdddeZGdddeZGdddeZGdddeZddZ GdddeZ!GdddeZ"GdddeZ#GdddeZ$Gd d!d!eZ%Gd"d#d#eZ&Gd$d%d%eZ'Gd&d'd'eZ(Gd(d)d)eZ)Gd*d+d+eZ*Gd,d-d-eZ+Gd.d/d/eZ,Gd0d1d1eZ-dS)2N)Optional) constraints)_sum_rightmost broadcast_all lazy_propertytril_matrix_to_vecvec_to_tril_matrix)padsoftplus)_Number) AbsTransformAffineTransform CatTransformComposeTransformCorrCholeskyTransformCumulativeDistributionTransform ExpTransformIndependentTransformLowerCholeskyTransformPositiveDefiniteTransformPowerTransformReshapeTransformSigmoidTransformSoftplusTransform TanhTransformSoftmaxTransformStackTransformStickBreakingTransform Transformidentity_transformcseZdZUdZdZejed<ejed<d(fdd Zdd Z e d e fd d Z e d)d dZ e d e fddZd*ddZddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'ZZS)+ra 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. Fdomaincodomainrcs<||_d|_|dkr n |dkrd|_ntdtdS)Nr)NNzcache_size must be 0 or 1) _cache_size_inv _cached_x_y ValueErrorsuper__init__self cache_size __class__r/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/distributions/transforms.pyr(_szTransform.__init__cCs|j}d|d<|S)Nr$)__dict__copy)r*stater.r.r/ __getstate__js zTransform.__getstate__returncCs |jj|jjkr |jjStd)Nz:Please use either .domain.event_dim or .codomain.event_dim)r event_dimr!r&r*r.r.r/r5oszTransform.event_dimcCs6d}|jdur |}|durt|}t||_|S)z{ Returns the inverse :class:`Transform` of this transform. This should satisfy ``t.inv.inv is t``. N)r$_InverseTransformweakrefrefr*invr.r.r/r;us  z Transform.invcCt)z Returns the sign of the determinant of the Jacobian, if applicable. In general this only makes sense for bijective transforms. NotImplementedErrorr6r.r.r/signszTransform.signr"cCs>|j|kr|St|jtjurt||dStt|d)Nr+z.with_cache is not implemented)r#typer(rr>r)r.r.r/ with_caches zTransform.with_cachecCs||uSNr.r*otherr.r.r/__eq__zTransform.__eq__cCs || SrC)rFrDr.r.r/__ne__s zTransform.__ne__cCsB|jdkr ||S|j\}}||ur|S||}||f|_|S)z2 Computes the transform `x => y`. r)r#_callr%)r*xx_oldy_oldyr.r.r/__call__     zTransform.__call__cCsB|jdkr ||S|j\}}||ur|S||}||f|_|S)z1 Inverts the transform `y => x`. r)r#_inverser%)r*rMrKrLrJr.r.r/ _inv_callrOzTransform._inv_callcCr<)zD Abstract method to compute forward transformation. r=r*rJr.r.r/rIzTransform._callcCr<)zD Abstract method to compute inverse transformation. r=r*rMr.r.r/rPrSzTransform._inversecCr<)zU Computes the log det jacobian `log |dy/dx|` given input and output. r=r*rJrMr.r.r/log_abs_det_jacobianrSzTransform.log_abs_det_jacobiancCs |jjdS)Nz())r-__name__r6r.r.r/__repr__ zTransform.__repr__cC|S)z{ Infers the shape of the forward computation, given the input shape. Defaults to preserving shape. r.r*shaper.r.r/ forward_shapezTransform.forward_shapecCrZ)z} Infers the shapes of the inverse computation, given the output shape. Defaults to preserving shape. r.r[r.r.r/ inverse_shaper^zTransform.inverse_shaper)r4rr")rW __module__ __qualname____doc__ bijectiver Constraint__annotations__r(r3propertyintr5r;r?rBrFrHrNrQrIrPrVrXr]r_ __classcell__r.r.r,r/r.s0 ,        rcseZdZdZdeffdd ZejddddZejddd d Z e d e fd d Z e d e fddZe d efddZd!ddZddZddZddZddZddZdd ZZS)"r7z| Inverts a single :class:`Transform`. This class is private; please instead use the ``Transform.inv`` property. transformcstj|jd||_dSNr@)r'r(r#r$)r*rkr,r.r/r(s z_InverseTransform.__init__F is_discretecC|jdusJ|jjSrC)r$r!r6r.r.r/r z_InverseTransform.domaincCrorC)r$r r6r.r.r/r!rpz_InverseTransform.codomainr4cCrorC)r$rer6r.r.r/rerpz_InverseTransform.bijectivecCrorC)r$r?r6r.r.r/r?rpz_InverseTransform.signcC|jSrC)r$r6r.r.r/r;z_InverseTransform.invr"cCs|jdusJ|j|jSrC)r$r;rBr)r.r.r/rBsz_InverseTransform.with_cachecCs(t|tsdS|jdusJ|j|jkSNF) isinstancer7r$rDr.r.r/rFs  z_InverseTransform.__eq__cCs|jjdt|jdS)N())r-rWreprr$r6r.r.r/rXsz_InverseTransform.__repr__cCs|jdusJ|j|SrC)r$rQrRr.r.r/rNs z_InverseTransform.__call__cCs|jdusJ|j|| SrC)r$rVrUr.r.r/rV z&_InverseTransform.log_abs_det_jacobiancC |j|SrC)r$r_r[r.r.r/r]rYz_InverseTransform.forward_shapecCryrC)r$r]r[r.r.r/r_rYz_InverseTransform.inverse_shapera)rWrbrcrdrr(rdependent_propertyr r!rhboolrerir?r;rBrFrXrNrVr]r_rjr.r.r,r/r7s(     r7cseZdZdZd"deeffdd ZddZej dd d d Z ej dd d d Z e de fddZe defddZedefddZd#ddZddZddZddZddZd d!ZZS)$rab 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. rpartscs.r fdd|D}tjd||_dS)Ncg|]}|qSr.rB).0partr@r.r/ "z-ComposeTransform.__init__..r@)r'r(r|)r*r|r+r,r@r/r( s zComposeTransform.__init__cCst|tsdS|j|jkSrs)rtrr|rDr.r.r/rF&s  zComposeTransform.__eq__FrmcCs|jstjS|jdj}|jdjj}t|jD]}||jj|jj7}t||jj}q||jks3J||jkrAt|||j}|S)Nr) r|rrealr r!r5reversedmax independent)r*r r5rr.r.r/r +s  zComposeTransform.domaincCs|jstjS|jdj}|jdjj}|jD]}||jj|jj7}t||jj}q||jks1J||jkr?t|||j}|S)Nrr)r|rrr!r r5rr)r*r!r5rr.r.r/r!:s   zComposeTransform.codomainr4cCtdd|jDS)Ncs|]}|jVqdSrCrerpr.r.r/ Kz-ComposeTransform.bijective..)allr|r6r.r.r/reIzComposeTransform.bijectivecCsd}|jD]}||j}q|SNr")r|r?)r*r?rr.r.r/r?Ms  zComposeTransform.signcCsRd}|jdur |}|dur'tddt|jD}t||_t||_|S)NcSg|]}|jqSr.)r;rr.r.r/rZz(ComposeTransform.inv..)r$rrr|r8r9r:r.r.r/r;Ts   zComposeTransform.invr"cC|j|kr|St|j|dSrl)r#rr|r)r.r.r/rB_ zComposeTransform.with_cachecCs|jD]}||}q|SrC)r|)r*rJrr.r.r/rNds  zComposeTransform.__call__cCs|jst|S|g}|jddD] }|||dq||g}|jj}t|j|dd|ddD]\}}}|t|||||jj||j j|jj7}q8t t j |S)Nrr")r|torch zeros_likeappendr r5ziprrVr! functoolsreduceoperatoradd)r*rJrMxsrtermsr5r.r.r/rVis   (z%ComposeTransform.log_abs_det_jacobiancCs|jD]}||}q|SrC)r|r]r*r\rr.r.r/r]~s  zComposeTransform.forward_shapecCst|jD]}||}q|SrC)rr|r_rr.r.r/r_ zComposeTransform.inverse_shapecCs2|jjd}|ddd|jD7}|d7}|S)Nz( z, cSsg|]}|qSr.)rXrr.r.r/rsz-ComposeTransform.__repr__..z ))r-rWjoinr|)r* fmt_stringr.r.r/rXs zComposeTransform.__repr__r`ra)rWrbrcrdlistrr(rFrrzr r!rr{rerir?rhr;rBrNrVr]r_rXrjr.r.r,r/rs(      rcseZdZdZdfdd Zd ddZejdd d d Zejdd d d Z e de fddZ e de fddZddZddZddZddZddZddZZS)!ra 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. rcs$tj|d|||_||_dSrl)r'r(rBbase_transformreinterpreted_batch_ndims)r*rrr+r,r.r/r(s  zIndependentTransform.__init__r"cC |j|kr|St|j|j|dSrl)r#rrrr)r.r.r/rBs  zIndependentTransform.with_cacheFrmcCt|jj|jSrC)rrrr rr6r.r.r/r  zIndependentTransform.domaincCrrC)rrrr!rr6r.r.r/r!rzIndependentTransform.codomainr4cC|jjSrC)rrer6r.r.r/rezIndependentTransform.bijectivecCrrC)rr?r6r.r.r/r?rzIndependentTransform.signcCs"||jjkr td||SNToo few dimensions on input)dimr r5r&rrRr.r.r/rIs zIndependentTransform._callcCs$||jjkr td|j|Sr)rr!r5r&rr;rTr.r.r/rPs zIndependentTransform._inversecCs|j||}t||j}|SrC)rrVrr)r*rJrMresultr.r.r/rVrz)IndependentTransform.log_abs_det_jacobiancCs"|jjdt|jd|jdS)Nruz, rv)r-rWrwrrr6r.r.r/rXs"zIndependentTransform.__repr__cCryrC)rr]r[r.r.r/r]rYz"IndependentTransform.forward_shapecCryrC)rr_r[r.r.r/r_rYz"IndependentTransform.inverse_shaper`ra)rWrbrcrdr(rBrrzr r!rhr{rerir?rIrPrVrXr]r_rjr.r.r,r/rs$     rcsteZdZdZdZdfdd ZejddZejdd Z dd d Z d dZ ddZ ddZ ddZddZZS)ra 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.) TrcsFt||_t||_|j|jkrtdtj|ddS)Nz6in_shape, out_shape have different numbers of elementsr@)rSizein_shape out_shapenumelr&r'r()r*rrr+r,r.r/r(s  zReshapeTransform.__init__cCttjt|jSrC)rrrlenrr6r.r.r/r rzReshapeTransform.domaincCrrC)rrrrrr6r.r.r/r!rzReshapeTransform.codomainr"cCrrl)r#rrrr)r.r.r/rBs zReshapeTransform.with_cachecC,|jd|t|j}|||jSrC)r\rrrreshaper)r*rJ batch_shaper.r.r/rIzReshapeTransform._callcCrrC)r\rrrrr)r*rMrr.r.r/rPrzReshapeTransform._inversecCs&|jd|t|j}||SrC)r\rrr new_zeros)r*rJrMrr.r.r/rVs z%ReshapeTransform.log_abs_det_jacobiancCnt|t|jkr tdt|t|j}||d|jkr.td||dd|j|d||jSNrzShape mismatch: expected z but got )rrr&rr*r\cutr.r.r/r] zReshapeTransform.forward_shapecCrr)rrr&rrr.r.r/r_rzReshapeTransform.inverse_shaper`ra)rWrbrcrdrer(rrzr r!rBrIrPrVr]r_rjr.r.r,r/rs     rc@DeZdZdZejZejZdZ dZ ddZ ddZ dd Z d d Zd S) rz8 Transform via the mapping :math:`y = \exp(x)`. Tr"cC t|tSrC)rtrrDr.r.r/rF( zExpTransform.__eq__cC|SrC)exprRr.r.r/rI+rGzExpTransform._callcCrrClogrTr.r.r/rP.rGzExpTransform._inversecCrZrCr.rUr.r.r/rV1z!ExpTransform.log_abs_det_jacobianNrWrbrcrdrrr positiver!rer?rFrIrPrVr.r.r.r/rs rcs~eZdZdZejZejZdZdfdd Z dddZ e d e fd d Z d d ZddZddZddZddZddZZS)rzD Transform via the mapping :math:`y = x^{\text{exponent}}`. Trcstj|dt|\|_dSrl)r'r(rexponent)r*rr+r,r.r/r(>rxzPowerTransform.__init__r"cCrrl)r#rrr)r.r.r/rBBrzPowerTransform.with_cacher4cCs |jSrC)rr?r6r.r.r/r?G zPowerTransform.signcCs$t|tsdS|j|jSrs)rtrreqritemrDr.r.r/rFKs zPowerTransform.__eq__cCs ||jSrCpowrrRr.r.r/rIPrYzPowerTransform._callcCs|d|jSrrrTr.r.r/rPSzPowerTransform._inversecCs|j||SrC)rabsrrUr.r.r/rVVz#PowerTransform.log_abs_det_jacobiancCt|t|jddSNr\r.rbroadcast_shapesgetattrrr[r.r.r/r]YrzPowerTransform.forward_shapecCrrrr[r.r.r/r_\rzPowerTransform.inverse_shaper`ra)rWrbrcrdrrr r!rer(rBrrir?rFrIrPrVr]r_rjr.r.r,r/r5s rcCs*t|j}tjt||jd|jdSN?minr)rfinfodtypeclampsigmoidtinyeps)rJrr.r.r/_clipped_sigmoid`s rc@r) rzg Transform via the mapping :math:`y = \frac{1}{1 + \exp(-x)}` and :math:`x = \text{logit}(y)`. Tr"cCrrC)rtrrDr.r.r/rForzSigmoidTransform.__eq__cCt|SrC)rrRr.r.r/rIrrGzSigmoidTransform._callcCs4t|j}|j|jd|jd}|| Sr)rrrrrrrlog1p)r*rMrr.r.r/rPus zSigmoidTransform._inversecCst|  t|SrC)Fr rUr.r.r/rVzsz%SigmoidTransform.log_abs_det_jacobianN)rWrbrcrdrrr unit_intervalr!rer?rFrIrPrVr.r.r.r/res rc@r) rz Transform via the mapping :math:`\text{Softplus}(x) = \log(1 + \exp(x))`. The implementation reverts to the linear function when :math:`x > 20`. Tr"cCrrC)rtrrDr.r.r/rFrzSoftplusTransform.__eq__cCrrCr rRr.r.r/rIrGzSoftplusTransform._callcCs| |SrC)expm1negrrTr.r.r/rPrzSoftplusTransform._inversecCs t|  SrCrrUr.r.r/rVrYz&SoftplusTransform.log_abs_det_jacobianNrr.r.r.r/r~s rc@sJeZdZdZejZeddZdZ dZ ddZ dd Z d d Z d d ZdS)ra 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. grTr"cCrrC)rtrrDr.r.r/rFrzTanhTransform.__eq__cCrrC)tanhrRr.r.r/rIrGzTanhTransform._callcCs t|SrC)ratanhrTr.r.r/rPs zTanhTransform._inversecCsdtd|td|S)N@g)mathrr rUr.r.r/rVsz"TanhTransform.log_abs_det_jacobianN)rWrbrcrdrrr intervalr!rer?rFrIrPrVr.r.r.r/rs  rc@s4eZdZdZejZejZddZ ddZ ddZ dS) r z*Transform via the mapping :math:`y = |x|`.cCrrC)rtr rDr.r.r/rFrzAbsTransform.__eq__cCrrC)rrRr.r.r/rIrGzAbsTransform._callcCrZrCr.rTr.r.r/rPrzAbsTransform._inverseN) rWrbrcrdrrr rr!rFrIrPr.r.r.r/r s r cseZdZdZdZd fdd ZedefddZe j d d d d Z e j d d d dZ d!ddZ ddZedefddZddZddZddZddZddZZS)"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. Trcs$tj|d||_||_||_dSrl)r'r(locscale _event_dim)r*rrr5r+r,r.r/r(s zAffineTransform.__init__r4cCrqrC)rr6r.r.r/r5rrzAffineTransform.event_dimFrmcC |jdkrtjSttj|jSNrr5rrrr6r.r.r/r  zAffineTransform.domaincCrrrr6r.r.r/r!rzAffineTransform.codomainr"cCs$|j|kr|St|j|j|j|dSrl)r#r rrr5r)r.r.r/rBs zAffineTransform.with_cachecCst|tsdSt|jtrt|jtr|j|jkrdSn |j|jks(dSt|jtr>t|jtr>|j|jkrt|jtrt|jdkrdSt|jdkrdSdS|jS)Nrr"r)rtrr floatr?r6r.r.r/r?s ( zAffineTransform.signcCs|j|j|SrCrrrRr.r.r/rIrzAffineTransform._callcCs||j|jSrCrrTr.r.r/rPrzAffineTransform._inversecCs|j}|j}t|trt|tt|}nt|}|j r=| d|j d}| | d}|d|j }| |S)N)rr)r\rrtr r full_likerrrr5sizeviewsumexpand)r*rJrMr\rr result_sizer.r.r/rVs  z$AffineTransform.log_abs_det_jacobiancC"t|t|jddt|jddSrrrrrrr[r.r.r/r]+zAffineTransform.forward_shapecCrrrr[r.r.r/r_0rzAffineTransform.inverse_shaperrra)rWrbrcrdrer(rhrir5rrzr r!rBrFr?rIrPrVr]r_rjr.r.r,r/r s&       r c@sJeZdZdZejZejZdZ ddZ ddZ ddd Z d d Z d d ZdS)ra Transforms an uncontrained real vector :math:`x` with length :math:`D*(D-1)/2` into the Cholesky factor of a D-dimension correlation matrix. This Cholesky factor is a lower triangular matrix with positive diagonals and unit Euclidean norm for each row. The transform is processed as follows: 1. First we convert x into a lower triangular matrix in row order. 2. For each row :math:`X_i` of the lower triangular part, we apply a *signed* version of class :class:`StickBreakingTransform` to transform :math:`X_i` into a unit Euclidean length vector using the following steps: - Scales into the interval :math:`(-1, 1)` domain: :math:`r_i = \tanh(X_i)`. - Transforms into an unsigned domain: :math:`z_i = r_i^2`. - Applies :math:`s_i = StickBreakingTransform(z_i)`. - Transforms back into signed domain: :math:`y_i = sign(r_i) * \sqrt{s_i}`. TcCst|}t|jj}|jd|d|d}t|dd}|d}d|d}|tj |j d|j|j d}|t |dddfddgdd }|S) Nrr"rdiag)rdevice.rvalue) rrrrrrrsqrtcumprodeyer\rr )r*rJrrzz1m_cumprod_sqrtrMr.r.r/rIKs  "zCorrCholeskyTransform._callcCstdtj||dd}t|dddfddgdd}t|dd}t|dd}||}||d}|S) Nr"rr.rrrr)rcumsumr rrrr)r*rMy_cumsumy_cumsum_shiftedy_vec y_cumsum_vectrJr.r.r/rPZs   zCorrCholeskyTransform._inverseNcCs`d||jdd}t|dd}d|d}d|td|tdjdd}||S)Nr"rrr?r)rrrrr r)r*rJrM intermediates y1m_cumsumy1m_cumsum_trilstick_breaking_logdet tanh_logdetr.r.r/rVfs  &z*CorrCholeskyTransform.log_abs_det_jacobiancCsdt|dkr td|d}tdd|dd}||dd|kr(td|dd||fS)Nr"rrg?rrz-Input is not a flattend lower-diagonal number)rr&round)r*r\NDr.r.r/r]ts z#CorrCholeskyTransform.forward_shapecCsVt|dkr td|d|dkrtd|d}||dd}|dd|fS)NrrrrzInput is not squarer"rr&)r*r\rrr.r.r/r_~s z#CorrCholeskyTransform.inverse_shaperC)rWrbrcrdr real_vectorr corr_choleskyr!rerIrPrVr]r_r.r.r.r/r6s  rc@sDeZdZdZejZejZddZ ddZ ddZ dd Z d d Z d S) ra< 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. cCrrC)rtrrDr.r.r/rFrzSoftmaxTransform.__eq__cCs,|}||ddd}||ddS)NrTr)rrr)r*rJlogprobsprobsr.r.r/rIszSoftmaxTransform._callcCs |}|SrCr)r*rMr#r.r.r/rPszSoftmaxTransform._inversecCt|dkr td|SNr"rrr[r.r.r/r] zSoftmaxTransform.forward_shapecCr$r%rr[r.r.r/r_r&zSoftmaxTransform.inverse_shapeN)rWrbrcrdrr r simplexr!rFrIrPr]r_r.r.r.r/rs  rc@sPeZdZdZejZejZdZ ddZ ddZ ddZ d d Z d d Zd dZdS)ra 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. TcCrrC)rtrrDr.r.r/rFrzStickBreakingTransform.__eq__cCsj|jdd||jdd}t||}d|d}t|ddgddt|ddgdd}|S)Nrr"rr)r\new_onesrrrr r )r*rJoffsetr  z_cumprodrMr.r.r/rIs $$zStickBreakingTransform._callcCsr|dddf}|jd||jdd}d|d}tj|t|jjd}|||}|S)N.rr")r) r\r(rrrrrrr)r*rMy_cropr)sfrJr.r.r/rPs  zStickBreakingTransform._inversecCs^|jdd||jdd}||}| t||dddfd}|S)Nrr".)r\r(rrr logsigmoidr)r*rJrMr)detJr.r.r/rVs$ *z+StickBreakingTransform.log_abs_det_jacobiancCs.t|dkr td|dd|ddfSNr"rrrr[r.r.r/r] z$StickBreakingTransform.forward_shapecCs.t|dkr td|dd|ddfSr/rr[r.r.r/r_r0z$StickBreakingTransform.inverse_shapeN)rWrbrcrdrr r r'r!rerFrIrPrVr]r_r.r.r.r/rs   rc@<eZdZdZeejdZejZ ddZ ddZ ddZ d S) rz 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. rcCrrC)rtrrDr.r.r/rFrzLowerCholeskyTransform.__eq__cC |d|jdddSNrr)dim1dim2)trildiagonalr diag_embedrRr.r.r/rI zLowerCholeskyTransform._callcCr2r3)r6r7rr8rTr.r.r/rPr9zLowerCholeskyTransform._inverseN) rWrbrcrdrrrr lower_choleskyr!rFrIrPr.r.r.r/rs rc@r1) rzN Transform from unconstrained matrices to positive-definite matrices. rcCrrC)rtrrDr.r.r/rFrz PositiveDefiniteTransform.__eq__cCst|}||jSrC)rmTrRr.r.r/rIs  zPositiveDefiniteTransform._callcCstj|}t|SrC)rlinalgcholeskyrr;rTr.r.r/rP s  z"PositiveDefiniteTransform._inverseN) rWrbrcrdrrrr positive_definiter!rFrIrPr.r.r.r/rs rcseZdZUdZeeed<dfdd Zede fdd Z ede fd d Z dd dZ ddZ ddZddZedefddZejddZejddZZS)ra 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) transformsrNcstdd|Ds Jrfdd|D}tjdt||_|dur.dgt|j}t||_t|jt|jks?J||_dS)Ncs|]}t|tVqdSrCrtrrrr.r.r/r!z(CatTransform.__init__..cr}r.r~rBr@r.r/r#rz)CatTransform.__init__..r@r")rr'r(rr?rlengthsr)r*tseqrrDr+r,r@r/r( s   zCatTransform.__init__r4cCr)NcsrrC)r5rBr.r.r/r.rz)CatTransform.event_dim..)rr?r6r.r.r/r5,rzCatTransform.event_dimcCs t|jSrC)rrDr6r.r.r/length0rzCatTransform.lengthr"cCs"|j|kr|St|j|j|j|SrC)r#rr?rrDr)r.r.r/rB4s zCatTransform.with_cachecCs| |jkr|ksJJ||j|jksJg}d}t|j|jD]\}}||j||}|||||}q*tj ||jdSNrr) rrrFrr?rDnarrowrrcat)r*rJyslicesstarttransrFxslicer.r.r/rI9s( zCatTransform._callcCs| |jkr|ksJJ||j|jksJg}d}t|j|jD]\}}||j||}|||||}q*t j ||jdSrG) rrrFrr?rDrHrr;rrI)r*rMxslicesrKrLrFyslicer.r.r/rPDs( zCatTransform._inversec Cs:| |jkr|ksJJ||j|jksJ| |jkr0|ks3JJ||j|jks>Jg}d}t|j|jD]2\}}||j||}||j||}|||} |j|jkrrt | |j|j} | | ||}qI|j} | dkr| |} | |j} | dkrt j || dSt |SrG)rrrFrr?rDrHrVr5rrrrIr) r*rJrM logdetjacsrKrLrFrMrO logdetjacrr.r.r/rVOs*((      z!CatTransform.log_abs_det_jacobiancCr)NcsrrCrrBr.r.r/rjrz)CatTransform.bijective..rr?r6r.r.r/rehrzCatTransform.bijectivecCtdd|jD|j|jS)NcSrr.r rBr.r.r/rorz'CatTransform.domain..rrIr?rrDr6r.r.r/r lzCatTransform.domaincCrS)NcSrr.r!rBr.r.r/rurz)CatTransform.codomain..rUr6r.r.r/r!rrVzCatTransform.codomain)rNrra)rWrbrcrdrrrgr(rrir5rFrBrIrPrVrhr{rerrzr r!rjr.r.r,r/rs$       rcseZdZUdZeeed<dfdd ZdddZd d Z d d Z d dZ ddZ e defddZejddZejddZZS)raW 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?rcsNtdd|Ds Jrfdd|D}tjdt||_||_dS)Ncsr@rCrArBr.r.r/rrCz*StackTransform.__init__..cr}r.r~rBr@r.r/rrz+StackTransform.__init__..r@)rr'r(rr?r)r*rErr+r,r@r/r(s   zStackTransform.__init__r"cCs|j|kr|St|j|j|SrC)r#rr?rr)r.r.r/rBs zStackTransform.with_cachecs fddtjDS)Ncsg|] }j|qSr.)selectr)rir*r r.r/rsz)StackTransform._slice..)rangerrrZr.rZr/_slicer9zStackTransform._slicecCs| |jkr|ksJJ||jt|jks!Jg}t|||jD] \}}|||q,tj||jdSNr) rrrr?rr\rrstack)r*rJrJrMrLr.r.r/rIs (zStackTransform._callcCs| |jkr|ksJJ||jt|jks!Jg}t|||jD] \}}|||q,tj ||jdSr]) rrrr?rr\rr;rr^)r*rMrNrOrLr.r.r/rPs (zStackTransform._inversec Cs| |jkr|ksJJ||jt|jks!J| |jkr2|ks5JJ||jt|jksBJg}||}||}t|||jD]\}}}||||qUtj ||jdSr]) rrrr?r\rrrVrr^) r*rJrMrPrJrNrMrOrLr.r.r/rVs((  z#StackTransform.log_abs_det_jacobianr4cCr)NcsrrCrrBr.r.r/rrz+StackTransform.bijective..rRr6r.r.r/rerzStackTransform.bijectivecCtdd|jD|jS)NcSrr.rTrBr.r.r/rrz)StackTransform.domain..rr^r?rr6r.r.r/r zStackTransform.domaincCr_)NcSrr.rWrBr.r.r/rrz+StackTransform.codomain..r`r6r.r.r/r!razStackTransform.codomainrra)rWrbrcrdrrrgr(rBr\rIrPrVrhr{rerrzr r!rjr.r.r,r/rys     rcsfeZdZdZdZejZdZdfdd Z e dej fdd Z d d Z d d ZddZdddZZS)raA 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"rcstj|d||_dSrl)r'r( distribution)r*rbr+r,r.r/r(s z(CumulativeDistributionTransform.__init__r4cCrrC)rbsupportr6r.r.r/r rz&CumulativeDistributionTransform.domaincCryrC)rbcdfrRr.r.r/rIrYz%CumulativeDistributionTransform._callcCryrC)rbicdfrTr.r.r/rPrYz(CumulativeDistributionTransform._inversecCryrC)rblog_probrUr.r.r/rVrYz4CumulativeDistributionTransform.log_abs_det_jacobiancCrrl)r#rrbr)r.r.r/rBrz*CumulativeDistributionTransform.with_cacher`ra)rWrbrcrdrerrr!r?r(rhrfr rIrPrVrBrjr.r.r,r/rsr).rrrr8typingrrtorch.nn.functionalnn functionalrtorch.distributionsrtorch.distributions.utilsrrrrrr r torch.typesr __all__rr7rrrrrrrrrrr r rrrrrrrrr.r.r.r/sF   *>zGE+-cS$8jH