f^(hҢbddlZddlZddlZddlZddlmZddlZddlmcm Z ddl m Z ddl mZmZmZmZmZddlmZmZddlmZgdZGdd ZGd d eZGd d eZegZGddeZGddeZGddeZGddeZdZ GddeZ!GddeZ"GddeZ#GddeZ$Gdd eZ%Gd!d"eZ&Gd#d$eZ'Gd%d&eZ(Gd'd(eZ)Gd)d*eZ*Gd+d,eZ+Gd-d.eZ,Gd/d0eZ-y)1N)Optional) constraints)_sum_rightmost broadcast_all lazy_propertytril_matrix_to_vecvec_to_tril_matrix)padsoftplus)_Number) AbsTransformAffineTransform CatTransformComposeTransformCorrCholeskyTransformCumulativeDistributionTransform ExpTransformIndependentTransformLowerCholeskyTransformPositiveDefiniteTransformPowerTransformReshapeTransformSigmoidTransformSoftplusTransform TanhTransformSoftmaxTransformStackTransformStickBreakingTransform Transformidentity_transformceZdZUdZdZej ed<ej ed<dfd ZdZ e de fdZ e dd Z e de fd Zdd Zd Zd ZdZdZdZdZdZdZdZdZxZS)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 \/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/distributions/transforms.pyr+zTransform.__init___sB%@D ?  1_)D 89 9 cD|jj}d|d<|S)Nr')__dict__copy)r,states r/ __getstate__zTransform.__getstate__js" ""$f  r0returnc|jj|jjk(r|jjStd)Nz:Please use either .domain.event_dim or .codomain.event_dim)r" event_dimr#r)r,s r/r8zTransform.event_dimos: ;; DMM$;$; ;;;(( (UVVr0cd}|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 r0ct)z Returns the sign of the determinant of the Jacobian, if applicable. In general this only makes sense for bijective transforms. NotImplementedErrorr9s r/signzTransform.signs "!r0c|j|k(r|St|jtjurt||St t|d)Nr-z.with_cache is not implemented)r&typer+rrAr,r-s r/ with_cachezTransform.with_cachesU   z )K :  )"4"4 44:4 4!T$ZL0N"OPPr0c ||uSNr,others r/__eq__zTransform.__eq__s u}r0c&|j| SrI)rMrKs r/__ne__zTransform.__ne__s;;u%%%r0c|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 JJqMa4r0c|jdk(r|j|S|j\}}||ur|S|j|}||f|_|S)z1 Inverts the transform `y => x`. r)r&_inverser()r,rUrSrTrRs r/ _inv_callzTransform._inv_calls[   q ==# #'' u :L MM! a4r0ct)zD Abstract method to compute forward transformation. r@r,rRs r/rQzTransform._call "!r0ct)zD Abstract method to compute inverse transformation. r@r,rUs r/rXzTransform._inverser\r0ct)zU Computes the log det jacobian `log |dy/dx|` given input and output. r@r,rRrUs r/log_abs_det_jacobianzTransform.log_abs_det_jacobianr\r0c4|jjdzS)Nz())r.__name__r9s r/__repr__zTransform.__repr__s~~&&--r0c|S)z{ Infers the shape of the forward computation, given the input shape. Defaults to preserving shape. rJr,shapes r/ forward_shapezTransform.forward_shape  r0c|S)z} Infers the shapes of the inverse computation, given the output shape. Defaults to preserving shape. rJrfs r/ inverse_shapezTransform.inverse_shaperir0r)r6rr%)rc __module__ __qualname____doc__ bijectiver Constraint__annotations__r+r5propertyintr8r>rBrGrMrOrVrYrQrXrardrhrk __classcell__r.s@r/rr.s*XI  " ""$$$  W3WW   "c""Q&  " " " .r0rceZdZdZdeffd ZejddZejddZ e de fd Z e de fd Ze defd Zdd Zd ZdZdZdZdZdZxZS)r;z| Inverts a single :class:`Transform`. This class is private; please instead use the ``Transform.inv`` property. transformcHt||j||_yNrD)r*r+r&r')r,ryr.s r/r+z_InverseTransform.__init__s  I$9$9:( r0F is_discretecJ|jJ|jjSrI)r'r#r9s r/r"z_InverseTransform.domains"yy$$$yy!!!r0cJ|jJ|jjSrI)r'r"r9s r/r#z_InverseTransform.codomains"yy$$$yyr0r6cJ|jJ|jjSrI)r'rqr9s r/rqz_InverseTransform.bijectives"yy$$$yy"""r0cJ|jJ|jjSrI)r'rBr9s r/rBz_InverseTransform.signs yy$$$yy~~r0c|jSrI)r'r9s r/r>z_InverseTransform.invs yyr0ch|jJ|jj|jSrI)r'r>rGrFs r/rGz_InverseTransform.with_caches-yy$$$xx"":.222r0crt|tsy|jJ|j|jk(SNF) isinstancer;r'rKs r/rMz_InverseTransform.__eq__s3%!23yy$$$yyEJJ&&r0c`|jjdt|jdS)N())r.rcreprr'r9s r/rdz_InverseTransform.__repr__s)..))*!DO+>r0cT|jJ|jj|SrI)r'rYr[s r/rVz_InverseTransform.__call__s'yy$$$yy""1%%r0cX|jJ|jj|| SrI)r'rar`s r/raz&_InverseTransform.log_abs_det_jacobian s,yy$$$ ..q!444r0c8|jj|SrI)r'rkrfs r/rhz_InverseTransform.forward_shapeyy&&u--r0c8|jj|SrI)r'rhrfs r/rkz_InverseTransform.inverse_shaperr0rm)rcrnrorprr+rdependent_propertyr"r#rtboolrqrurBr>rGrMrdrVrarhrkrvrws@r/r;r;s )))$[##6"7"$[##6 7 #4##cY3' ?&5..r0r;ceZdZdZddeeffd ZdZejddZ ejddZ e d e fd Ze d efd Zed efd Zdd ZdZdZdZdZdZxZS)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}wr{)rGr*r+r)r,rr-partr.s r/r+zComposeTransform.__init__ s? =BCTT__Z0CEC J/ Ds:cVt|tsy|j|jk(Sr)rrrrKs r/rMzComposeTransform.__eq__&s#%!12zzU[[((r0Fr|c|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#r8reversedmax independent)r,r"r8rs r/r"zComposeTransform.domain+szz## #A%%JJrN++55 TZZ( >D ..1H1HH HIIt{{'<'<=I >F,,,,, v'' ' ,,VYAQAQ5QRF r0c|jstjS|jdj}|jdjj }|jD]R}||jj |jj z z }t ||jj }T||j k\sJ||j kDr#tj|||j z }|S)Nrr)rrrr#r"r8rr)r,r#r8rs r/r#zComposeTransform.codomain:szz## #::b>**JJqM((22 JJ @D 004;;3H3HH HIIt}}'>'>?I @H..... x)) )"..xXEWEW9WXHr0r6c:td|jDS)Nc34K|]}|jywrIrq).0ps r/ z-ComposeTransform.bijective..Ks311;;3)allrr9s r/rqzComposeTransform.bijectiveIs3 333r0cJd}|jD]}||jz}|SNr%)rrB)r,rBrs r/rBzComposeTransform.signMs, !A!&&=D ! r0c$d}|j|j}|jtt|jDcgc]}|jc}}t j ||_t j ||_|Scc}wrI)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|Sr{)r&rrrFs r/rGzComposeTransform.with_cache_s&   z )K zBBr0c8|jD] }||} |SrI)r)r,rRrs r/rVzComposeTransform.__call__ds#JJ DQA r0c 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"r8ziprrar# functoolsreduceoperatoradd)r,rRrUxsrtermsr8s r/raz%ComposeTransform.log_abs_det_jacobianiszz##A& &SJJsO $D IId2b6l # $ ! KK)) djj"Sb'2ab6: IJD!Q LL--a3YAVAV5V  004;;3H3HH HI  I e44r0cJ|jD]}|j|}|SrI)rrhr,rgrs r/rhzComposeTransform.forward_shape~s*JJ .D&&u-E . r0c\t|jD]}|j|}|SrI)rrrkrs r/rkzComposeTransform.inverse_shapes/TZZ( .D&&u-E . r0c|jjdz}|dj|jDcgc]}|j c}z }|dz }|Scc}w)Nz( z, z ))r.rcjoinrrd)r, fmt_stringrs r/rdzComposeTransform.__repr__sT^^,,y8 innDJJ%Gqajjl%GHH e &HsA rlrm)rcrnrorplistrr+rMrrr"r#rrrqrurBrtr>rGrVrarhrkrdrvrws@r/rrsd9o ) $[##6 7 $[##6 7 4444c YC  5*  r0rceZdZdZdfd ZddZejddZejddZ e de fd Z e de fd Zd Zd Zd ZdZdZdZxZS)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||_||_yr{)r*r+rGbase_transformreinterpreted_batch_ndims)r,rrr-r.s r/r+zIndependentTransform.__init__s. J/,77 C)B&r0ch|j|k(r|St|j|j|Sr{)r&rrrrFs r/rGzIndependentTransform.with_caches5   z )K#   !?!?J  r0Fr|cjtj|jj|jSrI)rrrr"rr9s r/r"zIndependentTransform.domains,&&    & &(F(F  r0cjtj|jj|jSrI)rrrr#rr9s r/r#zIndependentTransform.codomains,&&    ( ($*H*H  r0r6c.|jjSrI)rrqr9s r/rqzIndependentTransform.bijectives"",,,r0c.|jjSrI)rrBr9s r/rBzIndependentTransform.signs""'''r0c|j|jjkr td|j |SNToo few dimensions on input)dimr"r8r)rr[s r/rQzIndependentTransform._calls7 557T[[** *:; ;""1%%r0c|j|jjkr td|jj |Sr)rr#r8r)rr>r^s r/rXzIndependentTransform._inverses= 557T]],, ,:; ;""&&q))r0cj|jj||}t||j}|SrI)rrarr)r,rRrUresults r/raz)IndependentTransform.log_abs_det_jacobians1$$99!Q?(F(FG r0cz|jjdt|jd|jdS)Nrz, r)r.rcrrrr9s r/rdzIndependentTransform.__repr__s:..))*!D1D1D,E+FbIgIgHhhijjr0c8|jj|SrI)rrhrfs r/rhz"IndependentTransform.forward_shape""0077r0c8|jj|SrI)rrkrfs r/rkz"IndependentTransform.inverse_shaperr0rlrm)rcrnrorpr+rGrrr"r#rtrrqrurBrQrXrardrhrkrvrws@r/rrs C  $[##6 7 $[##6 7 -4--(c((& *  k88r0rceZdZdZdZd fd ZejdZejdZ d dZ dZ dZ d Z d Zd ZxZS)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.) Tctj||_tj||_|jj |jj k7r t dt ||y)Nz6in_shape, out_shape have different numbers of elementsrD)rSizein_shape out_shapenumelr)r*r+)r,rrr-r.s r/r+zReshapeTransform.__init__sa 8, I. ==   DNN$8$8$: :UV V J/r0cptjtjt|jSrI)rrrlenrr9s r/r"zReshapeTransform.domains$&&{'7'7T]]9KLLr0cptjtjt|jSrI)rrrrrr9s r/r#zReshapeTransform.codomains$&&{'7'7T^^9LMMr0ch|j|k(r|St|j|j|Sr{)r&rrrrFs r/rGzReshapeTransform.with_caches,   z )K t~~*UUr0c|jd|jt|jz }|j ||j zSrI)rgrrrreshaper)r,rR batch_shapes r/rQzReshapeTransform._calls?gg<#dmm*< <= yyt~~566r0c|jd|jt|jz }|j ||j zSrI)rgrrrrr)r,rUrs r/rXzReshapeTransform._inverses?gg=#dnn*= => yyt}}455r0c|jd|jt|jz }|j |SrI)rgrrr new_zeros)r,rRrUrs r/raz%ReshapeTransform.log_abs_det_jacobians6gg<#dmm*< <= {{;''r0c t|t|jkr tdt|t|jz }||d|jk7rtd||dd|j|d||jzSNrzShape mismatch: expected z but got )rrr)rr,rgcuts r/rhzReshapeTransform.forward_shape s u:DMM* *:; ;%j3t}}-- ;$-- '+E#$K= $--Q Tc{T^^++r0c t|t|jkr tdt|t|jz }||d|jk7rtd||dd|j|d||jzSr)rrr)rrs r/rkzReshapeTransform.inverse_shapes u:DNN+ +:; ;%j3t~~.. ;$.. (+E#$K= $..AQR Tc{T]]**r0rlrm)rcrnrorprqr+rrr"r#rGrQrXrarhrkrvrws@r/rrsk I0##M$M##N$NV 76(,+r0rc`eZdZdZej ZejZdZ dZ dZ dZ dZ dZy) rz8 Transform via the mapping :math:`y = \exp(x)`. Tr%c"t|tSrI)rrrKs r/rMzExpTransform.__eq__(%..r0c"|jSrI)expr[s r/rQzExpTransform._call+ uuwr0c"|jSrIlogr^s r/rXzExpTransform._inverse.rr0c|SrIrJr`s r/raz!ExpTransform.log_abs_det_jacobian1r0Nrcrnrorprrr"positiver#rqrBrMrQrXrarJr0r/rrs=  F##HI D/r0rceZdZdZej Zej ZdZd fd Z ddZ e de fdZ dZdZd Zd Zd Zd ZxZS)rzD Transform via the mapping :math:`y = x^{\text{exponent}}`. TcJt||t|\|_yr{)r*r+rexponent)r,rr-r.s r/r+zPowerTransform.__init__>s" J/(2r0cR|j|k(r|St|j|Sr{)r&rrrFs r/rGzPowerTransform.with_cacheBs&   z )Kdmm CCr0r6c6|jjSrI)rrBr9s r/rBzPowerTransform.signGs}}!!##r0ct|tsy|jj|jj j Sr)rrreqritemrKs r/rMzPowerTransform.__eq__Ks:%0}}/335::<|jd|jz Srrr^s r/rXzPowerTransform._inverseSsuuQ&''r0c^|j|z|z jjSrI)rabsrr`s r/raz#PowerTransform.log_abs_det_jacobianVs( !A%**,0022r0cXtj|t|jddSNrgrJrbroadcast_shapesgetattrrrfs r/rhzPowerTransform.forward_shapeY"%%eWT]]GR-PQQr0cXtj|t|jddSrrrfs r/rkzPowerTransform.inverse_shape\rr0rlrm)rcrnrorprrr"r#rqr+rGrrurBrMrQrXrarhrkrvrws@r/rr5sk ! !F##HI3D $c$$= $(3RRr0rctj|j}tjtj||j d|j z SN?minr)rfinfodtypeclampsigmoidtinyeps)rRr s r/_clipped_sigmoidr`s< KK E ;;u}}Q'UZZS599_ MMr0c`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|tSrI)rrrKs r/rMzSigmoidTransform.__eq__o%!122r0ct|SrI)rr[s r/rQzSigmoidTransform._callrs ""r0ctj|j}|j|jd|j z }|j | jz Sr )rr rrrrrlog1p)r,rUr s r/rXzSigmoidTransform._inverseusK AGG$ GG eiiG 8uuw1"%%r0c\tj|  tj|z SrI)Fr r`s r/raz%SigmoidTransform.log_abs_det_jacobianzs! A2A..r0N)rcrnrorprrr" unit_intervalr#rqrBrMrQrXrarJr0r/rres=  F((HI D3#& /r0rc`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|tSrI)rrrKs r/rMzSoftplusTransform.__eq__s%!233r0ct|SrIr r[s r/rQzSoftplusTransform._calls {r0cb| jjj|zSrI)expm1negrr^s r/rXzSoftplusTransform._inverses'zz|!%%'!++r0ct|  SrIr r`s r/raz&SoftplusTransform.log_abs_det_jacobians! }r0NrrJr0r/rr~s=   F##HI D4,r0rcneZdZdZej ZejddZdZ dZ dZ dZ dZ d Zy ) 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. gr Tr%c"t|tSrI)rrrKs r/rMzTanhTransform.__eq__s%//r0c"|jSrI)tanhr[s r/rQzTanhTransform._calls vvxr0c,tj|SrI)ratanhr^s r/rXzTanhTransform._inverses{{1~r0cVdtjd|z td|zz zS)N@g)mathrr r`s r/raz"TanhTransform.log_abs_det_jacobians*dhhsma'(4!8*<<==r0N)rcrnrorprrr"intervalr#rqrBrMrQrXrarJr0r/rrsF,  F#{##D#.HI D0 >r0rcReZdZdZej ZejZdZ dZ dZ y)r z*Transform via the mapping :math:`y = |x|`.c"t|tSrI)rr rKs r/rMzAbsTransform.__eq__rr0c"|jSrI)rr[s r/rQzAbsTransform._callrr0c|SrIrJr^s r/rXzAbsTransform._inverserr0N) rcrnrorprrr"rr#rMrQrXrJr0r/r r s*5   F##H/r0r ceZdZdZdZdfd ZedefdZe jddZ e jdd Z dd Z d Zedefd Zd ZdZdZdZdZxZS)ra 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||||_||_||_yr{)r*r+locscale _event_dim)r,r5r6r8r-r.s r/r+zAffineTransform.__init__s( J/ #r0r6c|jSrI)r7r9s r/r8zAffineTransform.event_dims r0Fr|c|jdk(rtjStjtj|jSNrr8rrrr9s r/r"zAffineTransform.domain7 >>Q ## #&&{'7'7HHr0c|jdk(rtjStjtj|jSr:r;r9s r/r#zAffineTransform.codomainr<r0c~|j|k(r|St|j|j|j|Sr{)r&rr5r6r8rFs r/rGzAffineTransform.with_caches7   z )K HHdjj$..Z  r0c8t|tsyt|jtr4t|jtr|j|jk7r7y|j|jk(j j syt|j tr5t|j tr|j |j k7ryy|j |j k(j j syy)NFT)rrr5r rrr6rKs r/rMzAffineTransform.__eq__s%1 dhh (Z 7-Kxx599$HH )..0557 djj' *z%++w/OzzU[[( JJ%++-22499;r0ct|jtr6t|jdkDrdSt|jdkrdSdS|jj S)Nrr%r)rr6r floatrBr9s r/rBzAffineTransform.signsR djj' *djj)A-1 Utzz9JQ9N2 UTU Uzz  r0c:|j|j|zzSrIr5r6r[s r/rQzAffineTransform._callsxx$**q.((r0c:||jz |jz SrIrCr^s r/rXzAffineTransform._inversesDHH  **r0c|j}|j}t|tr3t j |t jt|}n#t j|j}|jrQ|jd|j dz}|j|jd}|d|j }|j|S)N)rr)rgr6rr r full_liker-rrr8sizeviewsumexpand)r,rRrUrgr6r result_sizes r/raz$AffineTransform.log_abs_det_jacobians  eW %__QU(<=FYYu%))+F >> ++-(94>>/:UBK[[-11"5F+T^^O,E}}U##r0c tj|t|jddt|jddSrrrrr5r6rfs r/rhzAffineTransform.forward_shape+7%% 7488Wb174::wPR3S  r0c tj|t|jddt|jddSrrMrfs r/rkzAffineTransform.inverse_shape0rNr0rrrm)rcrnrorprqr+rtrur8rrr"r#rGrMrBrQrXrarhrkrvrws@r/rrs I$ 3$[##6I7I $[##6I7I  (!c!! )+ $  r0rcdeZdZdZej 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%r diag)rdevice.rvalue) rr(r rrrr sqrtcumprodeyergrVr )r,rRrrzz1m_cumprod_sqrtrUs r/rQzCorrCholeskyTransform._callKs JJqMkk!''"&& GGSa#gG . qr * qDE<<>11"5  !''"+QWWQXXF F $S#2#X.Aa@ @r0c,dtj||zdz }t|dddfddgd}t|d}t|d}||j z }|j |j j z dz }|S) Nr%rr.rrWrSrU)rcumsumr rrYrr#)r,rUy_cumsumy_cumsum_shiftedy_vec y_cumsum_vectrRs r/rXzCorrCholeskyTransform._inverseZsu||AEr22xSbS1Aq6C"12.)*:D \'') ) WWY (A -r0Ncd||zjdz }t|d}d|jjdz}d|t d|zzt jdz jdz}||zS)Nr%rr`rS?r,)rarrrIr r-)r,rRrU intermediates y1m_cumsumy1m_cumsum_trilstick_breaking_logdet tanh_logdets r/raz*CorrCholeskyTransform.log_abs_det_jacobianfs !a%B// -ZbA #&;&;&=&A&A"&E EAa 00488C=@EE"EMM ${22r0ct|dkr td|d}tdd|zzdzdz}||dz zdz|k7r td|dd||fzS)Nr%rrg?rUriz-Input is not a flattend lower-diagonal number)rr)round)r,rgNDs r/rhz#CorrCholeskyTransform.forward_shapetst u:>:; ; "I 4!a%:; ; 9b !23 3 "I QK1 SbzQD  r0rI)rcrnrorpr real_vectorr" corr_choleskyr#rqrQrXrarhrkrJr0r/rr6s=  $ $F((HI   3#!r0rc^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|tSrI)rrrKs r/rMzSoftmaxTransform.__eq__rr0c||}||jdddz j}||jddz S)NrTr)rrrI)r,rRlogprobsprobss r/rQzSoftmaxTransform._calls@HLLT2155::<uyyT***r0c&|}|jSrIr)r,rUr{s r/rXzSoftmaxTransform._inversesyy{r0c8t|dkr td|SNr%rrtrfs r/rhzSoftmaxTransform.forward_shape u:>:; ; r0c8t|dkr td|Sr~rtrfs r/rkzSoftmaxTransform.inverse_shaperr0N)rcrnrorprrur"simplexr#rMrQrXrhrkrJr0r/rrs8 $ $F""H3+  r0rcheZdZdZej 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|tSrI)rrrKs r/rMzStickBreakingTransform.__eq__%!788r0c(|jddz|j|jdjdz }t||j z }d|z j d}t |ddgdt |ddgdz}|S)Nrr%rrW)rgnew_onesrarrrZr )r,rRoffsetr] z_cumprodrUs r/rQzStickBreakingTransform._callsq1::aggbk#:#A#A"#EE Q- .UOOB' Aq6 #c)aV1&E Er0c|dddf}|jd|j|jdjdz }d|jdz }tj|tj |j j}|j|jz |jz}|S)N.rr%)r ) rgrrarrr rrr)r,rUy_croprsfrRs r/rXzStickBreakingTransform._inverses38qzz&,,r*:;BB2FF r" "[[QWW!5!:!: ; JJL2668 #fjjl 2r0c,|jddz|j|jdjdz }||jz }| t j |z|dddfjzj d}|S)Nrr%.)rgrrarr logsigmoidrI)r,rRrUrdetJs r/raz+StickBreakingTransform.log_abs_det_jacobiansq1::aggbk#:#A#A"#EE  Q\\!_$qcrc{'88==bA r0cRt|dkr td|dd|ddzfzSNr%rrrtrfs r/rhz$StickBreakingTransform.forward_shape5 u:>:; ;SbzU2Y],,,r0cRt|dkr td|dd|ddz fzSrrtrfs r/rkz$StickBreakingTransform.inverse_shaperr0N)rcrnrorprrur"rr#rqrMrQrXrarhrkrJr0r/rrsB  $ $F""HI9- -r0rcteZdZdZej 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. rUc"t|tSrI)rrrKs r/rMzLowerCholeskyTransform.__eq__rr0c|jd|jddjjzSNrrh)dim1dim2)trildiagonalr diag_embedr[s r/rQzLowerCholeskyTransform._call4vvbzAJJBRJ8<<>IIKKKr0c|jd|jddjjzSr)rrrrr^s r/rXzLowerCholeskyTransform._inverserr0N) rcrnrorprrrr"lower_choleskyr#rMrQrXrJr0r/rrs?%[ $ $[%5%5q 9F))H9LLr0rcteZdZdZej ej dZejZ dZ dZ dZ y)rzN Transform from unconstrained matrices to positive-definite matrices. rUc"t|tSrI)rrrKs r/rMz PositiveDefiniteTransform.__eq__s%!:;;r0c@t|}||jzSrI)rmTr[s r/rQzPositiveDefiniteTransform._calls $ " $Q '144xr0crtjj|}tj |SrI)rlinalgcholeskyrr>r^s r/rXz"PositiveDefiniteTransform._inverse s* LL ! !! $%'++A..r0N) rcrnrorprrrr"positive_definiter#rMrQrXrJr0r/rrs=%[ $ $[%5%5q 9F,,H</r0rceZdZUdZeeed<dfd Zede fdZ ede fdZ ddZ dZ d Zd Zedefd 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|tywrIrrrrfs r/rz(CatTransform.__init__..!::a+:rDr%) rrGr*r+rrrlengthsr)r,tseqrrr-rfr.s r/r+zCatTransform.__init__ s:T:::: 6:;ALL,;D; J/t* ?cC00GG} 4<< C$8888..811;;8r)rrr9s r/r8zCatTransform.event_dim,8888r0c,t|jSrI)rIrr9s r/lengthzCatTransform.length0s4<<  r0c||j|k(r|St|j|j|j|SrI)r&rrrrrFs r/rGzCatTransform.with_cache4s2   z )KDOOTXXt||ZPPr0c|j |jcxkr|jksJJ|j|j|jk(sJg}d}t|j|j D]>\}}|j |j||}|j||||z}@tj||jSNrr`) rrGrrrrnarrowrrcat)r,rRyslicesstarttransrxslices r/rQzCatTransform._call9sx488-aeeg-----vvdhh4;;... $,,? #ME6XXdhhv6F NN5= )FNE #yydhh//r0c|j |jcxkr|jksJJ|j|j|jk(sJg}d}t|j|j D]G\}}|j |j||}|j|j|||z}Itj||jSr) rrGrrrrrrr>rr)r,rUxslicesrrryslices r/rXzCatTransform._inverseDsx488-aeeg-----vvdhh4;;... $,,? #ME6XXdhhv6F NN599V, -FNE #yydhh//r0c|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)rrGrrrrrrar8rrrrrI) r,rRrU logdetjacsrrrrr logdetjacrs r/raz!CatTransform.log_abs_det_jacobianOsx488-aeeg-----vvdhh4;;...x488-aeeg-----vvdhh4;;...  $,,? #ME6XXdhhv6FXXdhhv6F2266BI/*9dnnu6VW   i (FNE #hh !8-CDNN" 799ZS1 1z? "r0c:td|jDS)Nc34K|]}|jywrIrrs r/rz)CatTransform.bijective..jrrrrr9s r/rqzCatTransform.bijectivehrr0ctj|jDcgc]}|jc}|j|j Scc}wrI)rrrr"rrr,rfs r/r"zCatTransform.domainls8# /!QXX /4<<  /Actj|jDcgc]}|jc}|j|j Scc}wrI)rrrr#rrrs r/r#zCatTransform.codomainrs8!% 1AQZZ 1488T\\  1r)rNrrm)rcrnrorprrrsr+rrur8rrGrQrXrartrrqrrr"r#rvrws@r/rrs Y 9399!!!Q 0 0#29499## $ ## $ r0rceZdZUdZeeed<d fd ZddZdZ dZ dZ dZ e d efd 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|tywrIrrs r/rz*StackTransform.__init__..rrrD)rrGr*r+rrr)r,rrr-rfr.s r/r+zStackTransform.__init__s]:T:::: 6:;ALL,;D; J/t*rr)r,rUrrrs r/rXzStackTransform._inversesx488-aeeg-----vvdhh3t#7777 QA .MFE NN599V, - .{{711r0c|j |jcxkr|jksJJ|j|jt|jk(sJ|j |jcxkr|jksJJ|j|jt|jk(sJg}|j |}|j |}t |||jD]'\}}}|j |j||)tj||jSr) rrGrrrrrrarr) r,rRrUrrrrrrs r/raz#StackTransform.log_abs_det_jacobiansx488-aeeg-----vvdhh3t#7777x488-aeeg-----vvdhh3t#7777 ++a.++a.%('4??%K J !FFE   e88H I J{{:48844r0r6c:td|jDS)Nc34K|]}|jywrIrrs r/rz+StackTransform.bijective..rrrr9s r/rqzStackTransform.bijectiverr0ctj|jDcgc]}|jc}|jScc}wrI)rrrr"rrs r/r"zStackTransform.domains/  DOO!Dq!((!DdhhOO!DActj|jDcgc]}|jc}|jScc}wrI)rrrr#rrs r/r#zStackTransform.codomains/  doo!F!**!FQQ!FrrPrm)rcrnrorprrrsr+rGrrQrXrartrrqrrr"r#rvrws@r/rrys YE H22 59499##P$P##R$Rr0rceZdZdZdZej ZdZd fd Z e dejfdZ dZ dZd Zd 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||||_yr{)r*r+ distribution)r,rr-r.s r/r+z(CumulativeDistributionTransform.__init__s J/(r0r6c.|jjSrI)rsupportr9s r/r"z&CumulativeDistributionTransform.domains  (((r0c8|jj|SrI)rcdfr[s r/rQz%CumulativeDistributionTransform._calls  $$Q''r0c8|jj|SrI)ricdfr^s r/rXz(CumulativeDistributionTransform._inverses  %%a((r0c8|jj|SrI)rlog_probr`s r/raz4CumulativeDistributionTransform.log_abs_det_jacobians  ))!,,r0cR|j|k(r|St|j|Sr{)r&rrrFs r/rGz*CumulativeDistributionTransform.with_caches(   z )K.t/@/@ZXXr0rlrm)rcrnrorprqrrr#rBr+rtrrr"rQrXrarGrvrws@r/rrsZ$I((H D)) ..))()-Yr0r).rr-rr<typingrrtorch.nn.functionalnn functionalrtorch.distributionsrtorch.distributions.utilsrrrrr r r torch.typesr __all__rr;rr rrrrrrrrr rrrrrrrrrrJr0r/rs_  +. 0ffR;. ;.|wywt&b)D89D8NB+yB+J9.(RY(RVN /y/2 0*>I*>Z 9  ` i` FP!IP!f!y!H5-Y5-pLYL,/ /(g 9g TERYERP+Yi+Yr0