P/j^ddlZddlZddlZddlZddlZddlmZddlZddlm cm Z ddl m Z ddlmZmZmZmZmZddlmZmZgdZGddZGd d eZGd d eZegZGd deZGddeZGddeZGddeZdZGddeZ GddeZ!GddeZ"GddeZ#GddeZ$Gd d!eZ%Gd"d#eZ&Gd$d%eZ'Gd&d'eZ(Gd(d)eZ)Gd*d+eZ*Gd,d-eZ+Gd.d/eZ,y)0N)List) constraints)_sum_rightmost broadcast_all lazy_propertytril_matrix_to_vecvec_to_tril_matrix)padsoftplus) AbsTransformAffineTransform CatTransformComposeTransformCorrCholeskyTransformCumulativeDistributionTransform ExpTransformIndependentTransformLowerCholeskyTransformPositiveDefiniteTransformPowerTransformReshapeTransformSigmoidTransformSoftplusTransform TanhTransformSoftmaxTransformStackTransformStickBreakingTransform Transformidentity_transformceZdZUdZdZej ed<ej ed<dfd ZdZ e dZ e dZ e d Z dd Zd Zd Zd ZdZdZdZdZdZdZdZxZS)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. Fdomaincodomaincz||_d|_|dk(rn|dk(rd|_n tdt|y)Nr)NNzcache_size must be 0 or 1) _cache_size_inv _cached_x_y ValueErrorsuper__init__)self cache_size __class__s a/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/torch/distributions/transforms.pyr*zTransform.__init___sB% ?  1_)D 89 9 cD|jj}d|d<|S)Nr&)__dict__copy)r+states r. __getstate__zTransform.__getstate__js" ""$f  r/c|jj|jjk(r|jjStd)Nz:Please use either .domain.event_dim or .codomain.event_dim)r! event_dimr"r(r+s r.r6zTransform.event_dimos: ;; DMM$;$; ;;;(( (UVVr/cd}|j|j}|%t|}tj||_|S)z{ Returns the inverse :class:`Transform` of this transform. This should satisfy ``t.inv.inv is t``. N)r&_InverseTransformweakrefref)r+invs r.r<z Transform.invusB  99 ))+C ;#D)C C(DI r/ct)z Returns the sign of the determinant of the Jacobian, if applicable. In general this only makes sense for bijective transforms. NotImplementedErrorr7s r.signzTransform.signs "!r/c|j|k(r|St|jtjurt||St t|d)Nr,z.with_cache is not implemented)r%typer*rr?r+r,s r. with_cachezTransform.with_cachesU   z )K :  )"4"4 44:4 4!T$ZL0N"OPPr/c ||uSNr+others r.__eq__zTransform.__eq__s u}r/c&|j| SrG)rKrIs r.__ne__zTransform.__ne__s;;u%%%r/c|jdk(r|j|S|j\}}||ur|S|j|}||f|_|S)z2 Computes the transform `x => y`. r)r%_callr')r+xx_oldy_oldys r.__call__zTransform.__call__sY   q ::a= '' u :L JJqMa4r/c|jdk(r|j|S|j\}}||ur|S|j|}||f|_|S)z1 Inverts the transform `y => x`. r)r%_inverser')r+rSrQrRrPs r. _inv_callzTransform._inv_calls[   q ==# #'' u :L MM! a4r/ct)zD Abstract method to compute forward transformation. r>r+rPs r.rOzTransform._call "!r/ct)zD Abstract method to compute inverse transformation. r>r+rSs r.rVzTransform._inverserZr/ct)zU Computes the log det jacobian `log |dy/dx|` given input and output. r>r+rPrSs r.log_abs_det_jacobianzTransform.log_abs_det_jacobianrZr/c4|jjdzS)Nz())r-__name__r7s r.__repr__zTransform.__repr__s~~&&--r/c|S)z{ Infers the shape of the forward computation, given the input shape. Defaults to preserving shape. rHr+shapes r. forward_shapezTransform.forward_shape  r/c|S)z} Infers the shapes of the inverse computation, given the output shape. Defaults to preserving shape. rHrds r. inverse_shapezTransform.inverse_shapergr/rr$)ra __module__ __qualname____doc__ bijectiver Constraint__annotations__r*r4propertyr6r<r@rErKrMrTrWrOrVr_rbrfri __classcell__r-s@r.rr.s*XI  " ""$$$  WW   ""Q&  " " " .r/rceZdZdZdeffd ZejddZejddZ e dZ e d Z e d Z dd Zd Zd ZdZdZdZdZxZS)r9z| Inverts a single :class:`Transform`. This class is private; please instead use the ``Transform.inv`` property. transformcHt||j||_yNrB)r)r*r%r&)r+rvr-s r.r*z_InverseTransform.__init__s  I$9$9:( r/F is_discretecJ|jJ|jjSrG)r&r"r7s r.r!z_InverseTransform.domains"yy$$$yy!!!r/cJ|jJ|jjSrG)r&r!r7s r.r"z_InverseTransform.codomains"yy$$$yyr/cJ|jJ|jjSrG)r&ror7s r.roz_InverseTransform.bijectives"yy$$$yy"""r/cJ|jJ|jjSrG)r&r@r7s r.r@z_InverseTransform.signs yy$$$yy~~r/c|jSrG)r&r7s r.r<z_InverseTransform.invs yyr/ch|jJ|jj|jSrG)r&r<rErDs r.rEz_InverseTransform.with_caches-yy$$$xx"":.222r/crt|tsy|jJ|j|jk(SNF) isinstancer9r&rIs r.rKz_InverseTransform.__eq__s3%!23yy$$$yyEJJ&&r/c`|jjdt|jdS)N())r-rareprr&r7s r.rbz_InverseTransform.__repr__s)..))*!DO+>r/cT|jJ|jj|SrG)r&rWrYs r.rTz_InverseTransform.__call__s'yy$$$yy""1%%r/cX|jJ|jj|| SrG)r&r_r^s r.r_z&_InverseTransform.log_abs_det_jacobian s,yy$$$ ..q!444r/c8|jj|SrG)r&rirds r.rfz_InverseTransform.forward_shapeyy&&u--r/c8|jj|SrG)r&rfrds r.riz_InverseTransform.inverse_shaperr/rk)rarlrmrnrr*rdependent_propertyr!r"rrror@r<rErKrbrTr_rfrirsrts@r.r9r9s )))$[##6"7"$[##6 7 ##3' ?&5..r/r9ceZdZdZddeeffd ZdZejddZ ejddZ e d Z e d Zed Zdd Zd ZdZdZdZdZxZS)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. partsc~|r|Dcgc]}|j|}}t| |||_ycc}wrx)rEr)r*r)r+rr,partr-s r.r*zComposeTransform.__init__ s? =BCTT__Z0CEC J/ Ds:cVt|tsy|j|jk(Sr)rrrrIs r.rKzComposeTransform.__eq__&s#%!12zzU[[((r/Fryc|jstjS|jdj}|jdjj }t |jD]R}||jj |jj z z }t||jj }T||j k\sJ||j kDr#tj|||j z }|S)Nr) rrrealr!r"r6reversedmax independent)r+r!r6rs r.r!zComposeTransform.domain+szz## #A%%JJrN++55 TZZ( >D ..1H1HH HIIt{{'<'<=I >F,,,,, v'' ' ,,VYAQAQ5QRF r/c|jstjS|jdj}|jdjj }|jD]R}||jj |jj z z }t ||jj }T||j k\sJ||j kDr#tj|||j z }|S)Nrr)rrrr"r!r6rr)r+r"r6rs r.r"zComposeTransform.codomain:szz## #::b>**JJqM((22 JJ @D 004;;3H3HH HIIt}}'>'>?I @H..... x)) )"..xXEWEW9WXHr/c:td|jDS)Nc34K|]}|jywrGro).0ps r. z-ComposeTransform.bijective..Ks311;;3)allrr7s r.rozComposeTransform.bijectiveIs3 333r/cJd}|jD]}||jz}|SNr$)rr@)r+r@rs r.r@zComposeTransform.signMs, !A!&&=D ! r/c$d}|j|j}|jtt|jDcgc]}|jc}}t j ||_t j ||_|Scc}wrG)r&rrrr<r:r;)r+r<rs r.r<zComposeTransform.invTsn 99 ))+C ;"8DJJ3G#HaAEE#HIC C(DI{{4(CH $IsB cR|j|k(r|St|j|Srx)r%rrrDs r.rEzComposeTransform.with_cache_s&   z )K zBBr/c8|jD] }||} |SrG)r)r+rPrs r.rTzComposeTransform.__call__ds#JJ DQA r/c p|jstj|S|g}|jddD]}|j||d|j|g}|jj }t |j|dd|ddD]x\}}}|jt|j||||jj z ||jj |jj z z }ztjtj|S)Nrr$)rtorch zeros_likeappendr!r6ziprr_r" functoolsreduceoperatoradd)r+rPrSxsrtermsr6s r.r_z%ComposeTransform.log_abs_det_jacobianiszz##A& &SJJsO $D IId2b6l # $ ! KK)) djj"Sb'2ab6: IJD!Q LL--a3YAVAV5V  004;;3H3HH HI  I e44r/cJ|jD]}|j|}|SrG)rrfr+rers r.rfzComposeTransform.forward_shape~s*JJ .D&&u-E . r/c\t|jD]}|j|}|SrG)rrrirs r.rizComposeTransform.inverse_shapes/TZZ( .D&&u-E . r/c|jjdz}|dj|jDcgc]}|j c}z }|dz }|Scc}w)Nz( z, z ))r-rajoinrrb)r+ fmt_stringrs r.rbzComposeTransform.__repr__sT^^,,y8 innDJJ%Gqajjl%GHH e &HsA rjrk)rarlrmrnrrr*rKrrr!r"rror@rrr<rErTr_rfrirbrsrts@r.rrsd9o ) $[##6 7 $[##6 7 44 C  5*  r/rceZdZdZdfd ZddZejddZejddZ e dZ e d Z d Z d Zd Zd ZdZdZxZS)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. c`t|||j||_||_yrx)r)r*rEbase_transformreinterpreted_batch_ndims)r+rrr,r-s r.r*zIndependentTransform.__init__s. J/,77 C)B&r/ch|j|k(r|St|j|j|Srx)r%rrrrDs r.rEzIndependentTransform.with_caches5   z )K#   !?!?J  r/Frycjtj|jj|jSrG)rrrr!rr7s r.r!zIndependentTransform.domains,&&    & &(F(F  r/cjtj|jj|jSrG)rrrr"rr7s r.r"zIndependentTransform.codomains,&&    ( ($*H*H  r/c.|jjSrG)rror7s r.rozIndependentTransform.bijectives"",,,r/c.|jjSrG)rr@r7s r.r@zIndependentTransform.signs""'''r/c|j|jjkr td|j |SNToo few dimensions on input)dimr!r6r(rrYs r.rOzIndependentTransform._calls7 557T[[** *:; ;""1%%r/c|j|jjkr td|jj |Sr)rr"r6r(rr<r\s r.rVzIndependentTransform._inverses= 557T]],, ,:; ;""&&q))r/cj|jj||}t||j}|SrG)rr_rr)r+rPrSresults r.r_z)IndependentTransform.log_abs_det_jacobians1$$99!Q?(F(FG r/cz|jjdt|jd|jdS)Nrz, r)r-rarrrr7s r.rbzIndependentTransform.__repr__s:..))*!D1D1D,E+FbIgIgHhhijjr/c8|jj|SrG)rrfrds r.rfz"IndependentTransform.forward_shape""0077r/c8|jj|SrG)rrirds r.riz"IndependentTransform.inverse_shaperr/rjrk)rarlrmrnr*rErrr!r"rrror@rOrVr_rbrfrirsrts@r.rrs C  $[##6 7 $[##6 7 --((& *  k88r/rceZdZdZdZd fd ZejdZejdZ d dZ dZ dZ d Z d Zd ZxZS)raM 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. Tctj||_tj||_|jj |jj k7r t dt ||y)Nz6in_shape, out_shape have different numbers of elementsrB)rSizein_shape out_shapenumelr(r)r*)r+rrr,r-s r.r*zReshapeTransform.__init__sa 8, I. ==   DNN$8$8$: :UV V J/r/cptjtjt|jSrG)rrrlenrr7s r.r!zReshapeTransform.domains$&&{'7'7T]]9KLLr/cptjtjt|jSrG)rrrrrr7s r.r"zReshapeTransform.codomains$&&{'7'7T^^9LMMr/ch|j|k(r|St|j|j|Srx)r%rrrrDs r.rEzReshapeTransform.with_caches,   z )K t~~*UUr/c|jd|jt|jz }|j ||j zSrG)rerrrreshaper)r+rP batch_shapes r.rOzReshapeTransform._calls?gg<#dmm*< <= yyt~~566r/c|jd|jt|jz }|j ||j zSrG)rerrrrr)r+rSrs r.rVzReshapeTransform._inverses?gg=#dnn*= => yyt}}455r/c|jd|jt|jz }|j |SrG)rerrr new_zeros)r+rPrSrs r.r_z%ReshapeTransform.log_abs_det_jacobians6gg<#dmm*< <= {{;''r/c t|t|jkr tdt|t|jz }||d|jk7rtd||dd|j|d||jzSNrzShape mismatch: expected z but got )rrr(rr+recuts r.rfzReshapeTransform.forward_shapes u:DMM* *:; ;%j3t}}-- ;$-- '+E#$K= $--Q Tc{T^^++r/c t|t|jkr tdt|t|jz }||d|jk7rtd||dd|j|d||jzSr)rrr(rrs r.rizReshapeTransform.inverse_shapes u:DNN+ +:; ;%j3t~~.. ;$.. (+E#$K= $..AQR Tc{T]]**r/rjrk)rarlrmrnror*rrr!r"rErOrVr_rfrirsrts@r.rrsk I0##M$M##N$NV 76(,+r/rc`eZdZdZej ZejZdZ dZ dZ dZ dZ dZy) rz8 Transform via the mapping :math:`y = \exp(x)`. Tr$c"t|tSrG)rrrIs r.rKzExpTransform.__eq__%%..r/c"|jSrG)exprYs r.rOzExpTransform._call( uuwr/c"|jSrGlogr\s r.rVzExpTransform._inverse+rr/c|SrGrHr^s r.r_z!ExpTransform.log_abs_det_jacobian.r/Nrarlrmrnrrr!positiver"ror@rKrOrVr_rHr/r.rrs=  F##HI D/r/rceZdZdZej Zej ZdZd fd Z d dZ e dZ dZ dZdZd Zd Zd ZxZS)rzD Transform via the mapping :math:`y = x^{\text{exponent}}`. TcJt||t|\|_yrx)r)r*rexponent)r+rr,r-s r.r*zPowerTransform.__init__:s" J/(2r/cR|j|k(r|St|j|Srx)r%rrrDs r.rEzPowerTransform.with_cache>s&   z )Kdmm CCr/c6|jjSrG)rr@r7s r.r@zPowerTransform.signCs}}!!##r/ct|tsy|jj|jj j Sr)rrreqritemrIs r.rKzPowerTransform.__eq__Gs:%0}}/335::<|jd|jz Srrr\s r.rVzPowerTransform._inverseOsuuQ&''r/c^|j|z|z jjSrG)rabsrr^s r.r_z#PowerTransform.log_abs_det_jacobianRs( !A%**,0022r/cXtj|t|jddSNrerHrbroadcast_shapesgetattrrrds r.rfzPowerTransform.forward_shapeU"%%eWT]]GR-PQQr/cXtj|t|jddSrrrds r.rizPowerTransform.inverse_shapeXrr/rjrk)rarlrmrnrrr!r"ror*rErr@rKrOrVr_rfrirsrts@r.rr2sd ! !F##HI3D $$= $(3RRr/rctj|j}tjtj||j d|j z SN?minr)rfinfodtypeclampsigmoidtinyeps)rPrs r._clipped_sigmoidr\s< KK E ;;u}}Q'UZZS599_ MMr/c`eZdZdZej ZejZdZ dZ dZ dZ dZ dZy) rzg Transform via the mapping :math:`y = \frac{1}{1 + \exp(-x)}` and :math:`x = \text{logit}(y)`. Tr$c"t|tSrG)rrrIs r.rKzSigmoidTransform.__eq__j%!122r/ct|SrG)rrYs r.rOzSigmoidTransform._callms ""r/ctj|j}|j|jd|j z }|j | jz Sr)rrr r r r rlog1p)r+rSrs r.rVzSigmoidTransform._inversepsK AGG$ GG eiiG 8uuw1"%%r/c\tj|  tj|z SrG)Fr r^s r.r_z%SigmoidTransform.log_abs_det_jacobianus! A2A..r/N)rarlrmrnrrr! unit_intervalr"ror@rKrOrVr_rHr/r.rras=  F((HI D3#& /r/rc`eZdZdZej ZejZdZ dZ dZ dZ dZ dZy) 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$c"t|tSrG)rrrIs r.rKzSoftplusTransform.__eq__s%!233r/ct|SrGr rYs r.rOzSoftplusTransform._calls {r/cb| jjj|zSrG)expm1negrr\s r.rVzSoftplusTransform._inverses'zz|!%%'!++r/ct|  SrGrr^s r.r_z&SoftplusTransform.log_abs_det_jacobians! }r/NrrHr/r.rrys=  F##HI D4,r/rcneZdZdZej ZejddZdZ dZ dZ dZ dZ d Zy ) ra~ Transform via the mapping :math:`y = \tanh(x)`. It is equivalent to ``` ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)]) ``` However this might not be numerically stable, thus it is recommended to use `TanhTransform` instead. Note that one should use `cache_size=1` when it comes to `NaN/Inf` values. grTr$c"t|tSrG)rrrIs r.rKzTanhTransform.__eq__s%//r/c"|jSrG)tanhrYs r.rOzTanhTransform._calls vvxr/c,tj|SrG)ratanhr\s r.rVzTanhTransform._inverses{{1~r/cVdtjd|z td|zz zS)N@g)mathrr r^s r.r_z"TanhTransform.log_abs_det_jacobians*dhhsma'(4!8*<<==r/N)rarlrmrnrrr!intervalr"ror@rKrOrVr_rHr/r.rrsF   F#{##D#.HI D0 >r/rcReZdZdZej ZejZdZ dZ dZ y)r z4 Transform via the mapping :math:`y = |x|`. c"t|tSrG)rr rIs r.rKzAbsTransform.__eq__rr/c"|jSrG)rrYs r.rOzAbsTransform._callrr/c|SrGrHr\s r.rVzAbsTransform._inverserr/N) rarlrmrnrrr!rr"rKrOrVrHr/r.r r s.  F##H/r/r ceZdZdZdZdfd ZedZejddZ ejddZ dd Z d Z ed Zd Zd ZdZdZdZxZS)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. TcPt||||_||_||_yrx)r)r*locscale _event_dim)r+r0r1r6r,r-s r.r*zAffineTransform.__init__s( J/ #r/c|jSrG)r2r7s r.r6zAffineTransform.event_dims r/Fryc|jdk(rtjStjtj|jSNrr6rrrr7s r.r!zAffineTransform.domain7 >>Q ## #&&{'7'7HHr/c|jdk(rtjStjtj|jSr5r6r7s r.r"zAffineTransform.codomainr7r/c~|j|k(r|St|j|j|j|Srx)r%r r0r1r6rDs r.rEzAffineTransform.with_caches7   z )K HHdjj$..Z  r/ct|tsyt|jtjr>t|jtjr|j|jk7r7y|j|jk(j j syt|jtjr?t|jtjr|j|jk7ryy|j|jk(j j syy)NFT)rr r0numbersNumberrrr1rIs r.rKzAffineTransform.__eq__s%1 dhh /J IIw~~5 xx599$HH )..0557 djj'.. 1j KK7 zzU[[( JJ%++-22499;r/ct|jtjr6t |jdkDrdSt |jdkrdSdS|jj S)Nrr$r)rr1r;Realfloatr@r7s r.r@zAffineTransform.signsV djj',, /djj)A-1 Utzz9JQ9N2 UTU Uzz  r/c:|j|j|zzSrGr0r1rYs r.rOzAffineTransform._call sxx$**q.((r/c:||jz |jz SrGrAr\s r.rVzAffineTransform._inversesDHH  **r/c|j}|j}t|tjr3t j |tjt|}n#t j|j}|jrQ|jd|j dz}|j|jd}|d|j }|j|S)N)rr)rer1rr;r>r full_liker(rrr6sizeviewsumexpand)r+rPrSrer1r result_sizes r.r_z$AffineTransform.log_abs_det_jacobians  eW\\ *__QU(<=FYYu%))+F >> ++-(94>>/:UBK[[-11"5F+T^^O,E}}U##r/c tj|t|jddt|jddSrrrrr0r1rds r.rfzAffineTransform.forward_shape 7%% 7488Wb174::wPR3S  r/c tj|t|jddt|jddSrrKrds r.rizAffineTransform.inverse_shape%rLr/rrrk)rarlrmrnror*rrr6rrr!r"rErKr@rOrVr_rfrirsrts@r.r r s I$ $[##6I7I $[##6I7I  0!! )+ $  r/r cdeZdZdZej ZejZdZ dZ dZ d dZ dZ dZy) 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}`. Tctj|}tj|jj}|j d|zd|z }t |d}|dz}d|z jjd}|tj|jd|j|jz}|t|dddfddgd z}|S) Nrr$rdiag)r device.rvalue) rr#rr r r r sqrtcumprodeyererTr )r+rPr rzz1m_cumprod_sqrtrSs r.rOzCorrCholeskyTransform._call?s JJqMkk!''"&& GGSa#gG . qr * qDE<<>11"5  !''"+QWWQXXF F $S#2#X.Aa@ @r/c,dtj||zdz }t|dddfddgd}t|d}t|d}||j z }|j |j j z dz }|S) Nr$rr.rrUrQrS)rcumsumr rrWrr)r+rSy_cumsumy_cumsum_shiftedy_vec y_cumsum_vectrPs r.rVzCorrCholeskyTransform._inverseNsu||AEr22xSbS1Aq6C"12.)*:D \'') ) WWY (A -r/Ncd||zjdz }t|d}d|jjdz}d|t d|zzt jdz jdz}||zS)Nr$rr^rQ?r')r_rrrGr r()r+rPrS intermediates y1m_cumsumy1m_cumsum_trilstick_breaking_logdet tanh_logdets r.r_z*CorrCholeskyTransform.log_abs_det_jacobianZs !a%B// -ZbA #&;&;&=&A&A"&E EAa 00488C=@EE"EMM ${22r/ct|dkr td|d}tdd|zzdzdz}||dz zdz|k7r td|dd||fzS)Nr$rrg?rSrgz-Input is not a flattend lower-diagonal number)rr(round)r+reNDs r.rfz#CorrCholeskyTransform.forward_shapehst u:>:; ; "I 4!a%:; ; 9b !23 3 "I QK1 SbzQD  r/rG)rarlrmrnr real_vectorr! corr_choleskyr"rorOrVr_rfrirHr/r.rr+s= $ $F((HI   3#!r/rc^eZdZdZej ZejZdZ dZ dZ dZ dZ y)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. c"t|tSrG)rrrIs r.rKzSoftmaxTransform.__eq__rr/c||}||jdddz j}||jddz S)NrTr)rrrG)r+rPlogprobsprobss r.rOzSoftmaxTransform._calls@HLLT2155::<uyyT***r/c&|}|jSrGr)r+rSrys r.rVzSoftmaxTransform._inversesyy{r/c8t|dkr td|SNr$rrrrds r.rfzSoftmaxTransform.forward_shape u:>:; ; r/c8t|dkr td|Sr|rrrds r.rizSoftmaxTransform.inverse_shaper}r/N)rarlrmrnrrsr!simplexr"rKrOrVrfrirHr/r.rr}s8 $ $F""H3+  r/rcheZdZdZej ZejZdZ dZ dZ dZ dZ dZdZy ) 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. Tc"t|tSrG)rrrIs r.rKzStickBreakingTransform.__eq__%!788r/c(|jddz|j|jdjdz }t||j z }d|z j d}t |ddgdt |ddgdz}|S)Nrr$rrU)renew_onesr_rrrXr )r+rPoffsetr[ z_cumprodrSs r.rOzStickBreakingTransform._callsq1::aggbk#:#A#A"#EE Q- .UOOB' Aq6 #c)aV1&E Er/c|dddf}|jd|j|jdjdz }d|jdz }tj|tj |j j}|j|jz |jz}|S)N.rr$)r) rerr_rr rr r r)r+rSy_croprsfrPs r.rVzStickBreakingTransform._inverses38qzz&,,r*:;BB2FF r" "[[QWW!5!:!: ; JJL2668 #fjjl 2r/c,|jddz|j|jdjdz }||jz }| t j |z|dddfjzj d}|S)Nrr$.)rerr_rr logsigmoidrG)r+rPrSrdetJs r.r_z+StickBreakingTransform.log_abs_det_jacobiansq1::aggbk#:#A#A"#EE  Q\\!_$qcrc{'88==bA r/cRt|dkr td|dd|ddzfzSNr$rrrrrds r.rfz$StickBreakingTransform.forward_shape5 u:>:; ;SbzU2Y],,,r/cRt|dkr td|dd|ddz fzSrrrrds r.riz$StickBreakingTransform.inverse_shaperr/N)rarlrmrnrrsr!rr"rorKrOrVr_rfrirHr/r.rrsB  $ $F""HI9- -r/rcteZdZdZej ej dZejZ dZ dZ dZ y)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. rSc"t|tSrG)rrrIs r.rKzLowerCholeskyTransform.__eq__rr/c|jd|jddjjzSNrrf)dim1dim2)trildiagonalr diag_embedrYs r.rOzLowerCholeskyTransform._call4vvbzAJJBRJ8<<>IIKKKr/c|jd|jddjjzSr)rrrrr\s r.rVzLowerCholeskyTransform._inverserr/N) rarlrmrnrrrr!lower_choleskyr"rKrOrVrHr/r.rrs?%[ $ $[%5%5q 9F))H9LLr/rcteZdZdZej ej dZejZ dZ dZ dZ y)rzN Transform from unconstrained matrices to positive-definite matrices. rSc"t|tSrG)rrrIs r.rKz PositiveDefiniteTransform.__eq__s%!:;;r/c@t|}||jzSrG)rmTrYs r.rOzPositiveDefiniteTransform._calls $ " $Q '144xr/crtjj|}tj |SrG)rlinalgcholeskyrr<r\s r.rVz"PositiveDefiniteTransform._inverses* LL ! !! $%'++A..r/N) rarlrmrnrrrr!positive_definiter"rKrOrVrHr/r.rrs=%[ $ $[%5%5q 9F,,H</r/rceZdZUdZeeed<d fd ZedZ edZ ddZ dZ dZ d Zed Zej$d Zej$d ZxZS)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) transformscvtd|DsJ|r|Dcgc]}|j|}}t| |t ||_|dgt |j z}t ||_t |jt |j k(sJ||_ycc}w)Nc3<K|]}t|tywrGrrrrds r.rz(CatTransform.__init__..::a+:rBr$) rrEr)r*listrrlengthsr)r+tseqrrr,rdr-s r.r*zCatTransform.__init__s:T:::: 6:;ALL,;D; J/t* ?cC00GG} 4<< C$8888.!811;;8r)rrr7s r.r6zCatTransform.event_dim8888r/c,t|jSrG)rGrr7s r.lengthzCatTransform.length#s4<<  r/c||j|k(r|St|j|j|j|SrG)r%rrrrrDs r.rEzCatTransform.with_cache's2   z )KDOOTXXt||ZPPr/c|j |jcxkr|jksJJ|j|j|jk(sJg}d}t|j|j D]>\}}|j |j||}|j||||z}@tj||jSNrr^) rrErrrrnarrowrrcat)r+rPyslicesstarttransrxslices r.rOzCatTransform._call,sx488-aeeg-----vvdhh4;;... $,,? #ME6XXdhhv6F NN5= )FNE #yydhh//r/c|j |jcxkr|jksJJ|j|j|jk(sJg}d}t|j|j D]G\}}|j |j||}|j|j|||z}Itj||jSr) rrErrrrrrr<rr)r+rSxslicesrrryslices r.rVzCatTransform._inverse7sx488-aeeg-----vvdhh4;;... $,,? #ME6XXdhhv6F NN599V, -FNE #yydhh//r/c|j |jcxkr|jksJJ|j|j|jk(sJ|j |jcxkr|jksJJ|j|j|jk(sJg}d}t|j|j D]\}}|j |j||}|j |j||}|j||} |j|jkr#t| |j|jz } |j| ||z}|j} | dk\r| |jz } | |jz} | dkrtj|| St|Sr)rrErrrrrr_r6rrrrrG) r+rPrS logdetjacsrrrrr logdetjacrs r.r_z!CatTransform.log_abs_det_jacobianBsx488-aeeg-----vvdhh4;;...x488-aeeg-----vvdhh4;;...  $,,? #ME6XXdhhv6FXXdhhv6F2266BI/*9dnnu6VW   i (FNE #hh !8-CDNN" 799ZS1 1z? "r/c:td|jDS)Nc34K|]}|jywrGrrs r.rz)CatTransform.bijective..]rrrrr7s r.rozCatTransform.bijective[rr/ctj|jDcgc]}|jc}|j|j Scc}wrG)rrrr!rrr+rds r.r!zCatTransform.domain_s8# /!QXX /4<<  /Actj|jDcgc]}|jc}|j|j Scc}wrG)rrrr"rrrs r.r"zCatTransform.codomaines8!% 1AQZZ 1488T\\  1r)rNrrk)rarlrmrnrrrqr*rr6rrErOrVr_rrrorrr!r"rsrts@r.rrs Y 99!!Q 0 0#299## $ ## $ r/rceZdZUdZeeed<d fd Zd dZdZ dZ dZ dZ e d Zej d Zej d ZxZS)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) rctd|DsJ|r|Dcgc]}|j|}}t| |t ||_||_ycc}w)Nc3<K|]}t|tywrGrrs r.rz*StackTransform.__init__..|rrrB)rrEr)r*rrr)r+rrr,rdr-s r.r*zStackTransform.__init__{s]:T:::: 6:;ALL,;D; J/t*.rrrr7s r.rozStackTransform.bijectiverr/ctj|jDcgc]}|jc}|jScc}wrG)rrrr!rrs r.r!zStackTransform.domains/  DOO!Dq!((!DdhhOO!DActj|jDcgc]}|jc}|jScc}wrG)rrrr"rrs r.r"zStackTransform.codomains/  doo!F!**!FQQ!FrrNrk)rarlrmrnrrrqr*rErrOrVr_rrrorrr!r"rsrts@r.rrls YE H22 599##P$P##R$Rr/rcneZdZdZdZej ZdZd fd Z e dZ dZ dZ dZd d ZxZS) 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$c4t||||_yrx)r)r* distribution)r+rr,r-s r.r*z(CumulativeDistributionTransform.__init__s J/(r/c.|jjSrG)rsupportr7s r.r!z&CumulativeDistributionTransform.domains  (((r/c8|jj|SrG)rcdfrYs r.rOz%CumulativeDistributionTransform._calls  $$Q''r/c8|jj|SrG)ricdfr\s r.rVz(CumulativeDistributionTransform._inverses  %%a((r/c8|jj|SrG)rlog_probr^s r.r_z4CumulativeDistributionTransform.log_abs_det_jacobians  ))!,,r/cR|j|k(r|St|j|Srx)r%rrrDs r.rEz*CumulativeDistributionTransform.with_caches(   z )K.t/@/@ZXXr/rjrk)rarlrmrnrorrr"r@r*rrr!rOrVr_rErsrts@r.rrsM$I((H D)))()-Yr/r)-rr(r;rr:typingrrtorch.nn.functionalnn functionalrtorch.distributionsrtorch.distributions.utilsrrrrr r r __all__rr9rrrrrrrrrrr r rrrrrrrrrHr/r.rs_  +. 0ffR;. ;.|wywt&b)D89D8N@+y@+F9,'RY'RTN /y/0 .!>I!>H9"c ic LO!IO!d y F5-Y5-pLYL,/ /(g 9g TERYERP+Yi+Yr/