AVhdZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZddl mZddl mZddlmZ d3dZdZ d4dZdZd5dZ d6dZdZdZdZdZ dZ!dZ" d7dZ# d8dZ$d9dZ%d:d Z&d;d!Z'dd(Z.d>d)Z/d?d*Z0 d@d+Z1d5d,Z2d-Z3 d5d.Z4dAd/Z5d0Z6Gd1d2Z7y)Bz(Utilities for probability distributions.N) constant_op)dtypes)ops) tensor_shape) tensor_util) array_ops)array_ops_stack) check_ops)cond)control_flow_ops) linalg_ops)math_ops)nn) tf_inspectc tj|||g5tj|d}|jjrt j cdddS|xsdj|}|t tjtjtjtjtjtji|jj}t'j(|t+j,t+j,|||j||||cdddS#t $r/t#dj|jj$wxYw#1swYyxYw)axAssert that x has integer components (or floats equal to integers). Args: x: Floating-point `Tensor` data: The tensors to print out if the condition is `False`. Defaults to error message and first few entries of `x` and `y`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. int_dtype: A `tf.dtype` used to cast the float to. The default (`None`) implies the smallest possible signed int will be used for casting. name: A name for this operation (optional). Returns: Op raising `InvalidArgumentError` if `cast(x, int_dtype) != x`. valuesxnameNz{} has non-integer componentszUnrecognized type {})data summarizemessager)r name_scopeconvert_to_tensordtype is_integerr no_opformatrfloat16int16float32int32float64int64 base_dtypeKeyError TypeErrorrr assert_equalrcast)rrrr int_dtypers X/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/distributions/util.pyassert_integer_formr-&s9* ~~dAt9- ac*Aww  # # %B8??BGE NNFLL NNFLL NNFLL  ''      ! !  hmmAy1177;    E.55aggllCDDEs,AF%F=A3E0A F8E>>FF ctj|}tjt j ||g|SN)rmatrix_transposer with_dependenciesr r))matrixmatrix_ts r,assert_symmetricr4Rs:  ' ' /(  + +fh/0& ::crtj||g5tj|d}tj|dj |g}|j js |t|dj |gz }tj||cdddS#1swYyxYw)z>Assert x is a non-negative tensor, and optionally of integers.rrrz'{}' must be non-negative.rz*'{}' cannot contain fractional components.N) rrrr assert_non_negativerrrr-r r1)rr assertionss r,$embed_check_nonnegative_integer_formr:Xs ~~dA3' = ac*A%% 3::1= ?J 77   BII!L Nj  - -j! < = = =s B B--B6ctjdtjdfd}tjt j t jt j|dS)zReturns whether a and b have the same dynamic shape. Args: a: `Tensor` b: `Tensor` Returns: `bool` `Tensor` representing if both tensors have the same shape. arbc Ftjtjtjtj tj gdtjtj tj gdS)Nr)r reduce_allequalrconcatshape)r<r=sr,all_shapes_equalz,same_dynamic_shape..all_shapes_equalzsv      #Y__Q%78! =   #Y__Q%78! = > ??r5c,tjdS)NF)rconstantr5r,z$same_dynamic_shape..s 4 4U ;r5)rrtf_condr rr@rrank)r<r=rCs`` r,same_dynamic_shaperJjsg AC(! AC(! ? nnY^^A& q(9:; ==r5c||S tj|}|||Stj||S#t$r|}Y)wxYw)a`Helper which tries to return a static value. Given `x`, extract it's value statically, optionally casting to a specific dtype. If this is not possible, None is returned. Args: x: `Tensor` for which to extract a value statically. dtype: Optional dtype to cast to. Returns: Statically inferred value if possible, otherwise None. )rconstant_valuer(nparray)rrx_s r,maybe_get_static_valuerPsZY H  # #A &BZ5= I "e   B s7 AAc tj|||g5|du|duk(r td|tj|d|}|jj s t d|r/|r t|}|tj|dfcdddS|tj|dfcdddStj|d|}|jj s t d |rtjd 5tjd |j}tj|g}|r* A BB }$$V(%Hf \\ % %;<<  6v>&rzz&w771F1FX%%f7; ;1F1F  ! !%gU CE ;; " " 8 99 >>* +H""2u{{3!55e<= 5e<% ##%%eR046  , ))&LN  ,!22<G!H$  ! F ||E"E) F FO1F1Fb\\% 8>>#+#> > E F FO1F1F*HH$ F F FO1F1F1FsVA7I!I!=AI! B'H?4I!I * I!=/I , I!?I I! I I!!I*ctjdtjdtjdij |j dS)z7Helper returning True if dtype is known to be unsigned.TF)rbooluint8uint16getr&dts r,_is_known_unsigned_by_dtyperms; kk4 llD mmT C u r5ctjdtjdtjdtjdtj dtj dtjdij|jdS)z5Helper returning True if dtype is known to be signed.TF) rr r"r$int8r!r#r%rjr&rks r,_is_known_signed_by_dtyperps_ nnd nnd nnd kk4 llD llD llD C ur5c2t|xs t|S)z(Helper returning True if dtype is known.)rmrprks r,_is_known_dtyperr s $R ( I,Eb,IIr5ct|s$tdj|j|jr8t dt j|jjdzzS|jr)t j|jjS|jtjk(r t dStdj|j)zDHelper returning the largest integer exactly representable by dtype.Unrecognized dtype: {})rrr(rrrXintrMfinfoas_numpy_dtypenmantriinfomaxr&rrgrks r,_largest_integer_by_dtyper}s   ,33BGG< ==^^ q288B--.44q89 ::]] 88B%% & * **]]fkk! q6M*11"'':;;r5ct|s$tdj|jt |rydt |zS)zEHelper returning the smallest integer exactly representable by dtype.rtrrV)rrr(rrrmr}rks r,_smallest_integer_by_dtypersA   ,33BGG< == $ '+ ++r5ct|s$tdj|j|jxs|j t jk(S)z7Helper returning True if dtype.is_integer or is `bool`.rt)rrr(rrrr&rrgrks r,_is_integer_like_by_dtyper%sA   ,33BGG< ==  6"--6;;66r5c tj||g5tj|d}|jj}|j r t |nd}|dk(r$tdj|j |jjd}tj|d_|jdj }|d kr td ||kDr&td j|j|||cd d d St#j$|d d}t'j(t+j,|ddt+j.t#j$|dd d t+j0||dj|j|g|cd d d S#t$r tdwxYw#1swYy xYw)aEmbeds checks that categorical distributions don't have too many classes. A categorical-type distribution is one which, e.g., returns the class label rather than a one-hot encoding. E.g., `Categorical(probs)`. Since distributions output samples in the same dtype as the parameters, we must ensure that casting doesn't lose precision. That is, the `parameter.dtype` implies a maximum number of classes. However, since shape is `int32` and categorical variables are presumed to be indexes into a `Tensor`, we must also ensure that the number of classes is no larger than the largest possible `int32` index, i.e., `2**31-1`. In other words the number of classes, `K`, must satisfy the following condition: ```python K <= min( int(2**31 - 1), # Largest float as an index. { dtypes.float16: int(2**11), # Largest int as a float16. dtypes.float32: int(2**24), dtypes.float64: int(2**53), }.get(categorical_param.dtype.base_dtype, 0)) ``` Args: categorical_param: Floating-point `Tensor` representing parameters of distribution over categories. The rightmost shape is presumed to be the number of categories. name: A name for this operation (optional). Returns: categorical_param: Input `Tensor` with appropriate assertions embedded. Raises: TypeError: if `categorical_param` has an unknown `dtype`. ValueError: if we can statically identify `categorical_param` as being too large (for being closed under int32/float casting). rcategorical_paramrrz3Unable to validate size of unrecognized dtype ({}).rvzDA categorical-distribution parameter must have at least 1 dimension.rVNruzAA categorical-distribution parameter must have at least 2 events.zZNumber of classes exceeds `dtype` precision, i.e., {} implies shape ({}) cannot exceed {}.x_shaper7zSNumber of classes exceeds `dtype` precision, i.e., {} dtype cannot exceed {} shape.)rrrrr&rXr}r(rr get_shapewith_rank_at_leastrWrdimension_valuedimsvaluerrBr r1r assert_rank_at_leastassert_greater_equalr^)rrrx_dtypemax_event_sizex_shape_static event_sizes r,rYrY,sR ~~d$5#673  /6IJAgg  G.5.A.A!'*q $fW\\2 440{{}77:n##N2$67C!&&r*00j a+, , n $CCI6$\\:~DGH H?3 3 B??195b9j  / /  ( (/ 1  ( (ooa $) +  % %77=v,,80  11" # E3 3 & 0 / 000'3 3 s,A0G& G)A-G& B$G&G##G&&G/c tj||g5tj|d}t|jsD|jj s.t dj|jjt|s0|j s$t dj|jt|jsEt|s:t dj||jj|jg}|r|tj|dgz }|jj r,|t||d j|j gz }nt|jt|kDr=|tj|t|d jt|gz }|s^t|jt|kr=|tj|t|d jt|gz }|s |cd d d St!j"||cd d d S#1swYy xYw)aEnsures integers remain unaffected despite casting to/from int/float types. Example integer-types: `uint8`, `int32`, `bool`. Example floating-types: `float32`, `float64`. The largest possible integer representable by an IEEE754 floating-point is `2**(1 + mantissa_bits)` yet the largest possible integer as an int-type is `2**(bits - 1) - 1`. This function ensures that a `Tensor` purporting to have integer-form values can be cast to some other type without loss of precision. The smallest representable integer is the negative of the largest representable integer, except for types: `uint8`, `uint16`, `bool`. For these types, the smallest representable integer is `0`. Args: x: `Tensor` representing integer-form values. target_dtype: TF `dtype` under which `x` should have identical values. assert_nonnegative: `bool` indicating `x` should contain nonnegative values. name: A name for this operation (optional). Returns: x: Input `Tensor` with appropriate assertions embedded. Raises: TypeError: if `x` is neither integer- nor floating-type. TypeError: if `target_dtype` is neither integer- nor floating-type. TypeError: if neither `x` nor `target_dtype` are integer-type. rrrz+{}.dtype must be floating- or integer-type.z4target_dtype ({}) must be floating- or integer-type.zIAt least one of {}.dtype ({}) and target_dtype ({}) must be integer-type.zElements must be non-negative.r7zElements must be {}-equivalent.)r+rzElements cannot exceed {}.z#Elements cannot be smaller than {}.N)rrrrrrXr(rrr r8r-r}r^rrr r1)r target_dtypeassert_nonnegativerr9s r,"embed_check_integer_casting_closedrsIB ~~dA3'7= ac*A %agg .qww7J7J &&,fQWW\\&: << %l 3  $ $ &&,f\->->&? AA %agg . %l 3 ..4fQ 5A5F5F/H IIJ  ' '9 ;j  ww $7>>##% &j $AGG , #L 1 2   ' '),75<<-l;= ?  !&@ '''/ ='>  * **<8>EE.|<> @    m7=7=n  - -j! = 2`, where the last two dimensions are equal. transform: Element-wise function mapping `Tensors` to `Tensors`. To be applied to the diagonal of `matrix`. If `None`, `matrix` is returned unchanged. Defaults to `None`. name: A name to give created ops. Defaults to "matrix_diag_transform". Returns: A `Tensor` with same shape and `dtype` as `matrix`. matrix_diag_transformr2rN)rrrrmatrix_diag_partmatrix_set_diag)r2 transformrdiagtransformed_diagtransformed_mats r,rrsd ~~d3fX>J  " "6 9F JJ  % %f -D //8HIOJ J sA;3A;;Bc tj|||g5tj|d}tj|d}tj|t j |}|jj}|||dkr |cdddStj|t||zz}|dk(r |cdddStjtj||}tj||cdddStj |}tj"t%j&|dt%j(| ||t%j(||z }t%j*d|}t%j*||}tj,||gd}tj||cdddS#1swYyxYw) a)Circularly moves dims left or right. Effectively identical to: ```python numpy.transpose(x, numpy.roll(numpy.arange(len(x.shape)), shift)) ``` When `validate_args=False` additional graph-runtime checks are performed. These checks entail moving data from to GPU to CPU. Example: ```python x = tf.random.normal([1, 2, 3, 4]) # Tensor of shape [1, 2, 3, 4]. rotate_transpose(x, -1).shape == [2, 3, 4, 1] rotate_transpose(x, -2).shape == [3, 4, 1, 2] rotate_transpose(x, 1).shape == [4, 1, 2, 3] rotate_transpose(x, 2).shape == [3, 4, 1, 2] rotate_transpose(x, 7).shape == rotate_transpose(x, 3).shape # [2, 3, 4, 1] rotate_transpose(x, -7).shape == rotate_transpose(x, -3).shape # [4, 1, 2, 3] ``` Args: x: `Tensor`. shift: `Tensor`. Number of dimensions to transpose left (shift<0) or transpose right (shift>0). name: Python `str`. The name to give this op. Returns: rotated_x: Input `Tensor` with dimensions circularly rotated by shift. Raises: TypeError: if shift is not integer type. rrrshiftNrur)perm)rrrr assert_integerrrLrndimsrMsignabsrollaranger transposerIwhere_v2rlessmodrangerA)rrrshift_value_staticrrfirstlasts r,rotate_transposerFsH ~~dAu:.&/ ac*A  ! !%g 6E U#$33E: KKM  E /; &/&/77#56  !E )+ q &/&/WWRYYu%'9 :d   .&/&/<nnQe  --q ! ,,vu % (,,ue, ,.ennQ&e ^^E5 )d   tUmQ /d   .M&/&/&/sA=G.!*G.?G.CG..G7c 0tj||||f5tj|d}|jtj k7r+t |d|jdtj tj|}||r|n|cdddStj|d}tj|d}|j|jk7r*t |d|jd |d|jtj|d }tjtj||gd tj|d |gtj||d gcdddS#1swYyxYw) aPicks possibly different length row `Tensor`s based on condition. Value `Tensor`s should have exactly one dimension. If `cond` is a python Boolean or `tf.constant` then either `true_vector` or `false_vector` is immediately returned. I.e., no graph nodes are created and no validation happens. Args: cond: `Tensor`. Must have `dtype=tf.bool` and be scalar. true_vector: `Tensor` of one dimension. Returned when cond is `True`. false_vector: `Tensor` of one dimension. Returned when cond is `False`. name: Python `str`. The name to give this op. Example: ```python pick_vector(tf.less(0, 5), tf.range(10, 12), tf.range(15, 18)) # [10, 11] pick_vector(tf.less(5, 0), tf.range(10, 12), tf.range(15, 18)) # [15, 16, 17] ``` Returns: true_or_false_vector: `Tensor`. Raises: TypeError: if `cond.dtype != tf.bool` TypeError: if `cond` is not a constant and `true_vector.dtype != false_vector.dtype` rr rz.dtype=z which is not N true_vector false_vectorz does not match rrV)rrrrrrgr(rrLrrBslicerArwhere)r rrrcond_value_staticrs r, pick_vectorrsa4 ~~dD+|#DEJ  F 3D zzV[[ TZZ6 77#2248$-[<JJ'' -HK((NKLL...   ))<9K9K M NN  $Q'A ??+|4a8   D!Q '(9??4B+G*H JJJJsA.make_shape_tensors  " "17&,, GGr5ct|tjr|Stj|}|tj|Syr/) isinstancer TensorShaperrL)ss_rs r,get_tensor_shapez7prefer_static_broadcast_shape..get_tensor_shapesG A|// 0  % %&7&: ;b ''++ r5ct|tjs|S|jr|j St d)Nz6Cannot broadcast from partially defined `TensorShape`.)rrris_fully_definedas_listrW)rrs r,get_shape_tensorz7prefer_static_broadcast_shape..get_shape_tensorsM <33 4 ##    -- 0 11r5N)rrrbroadcast_static_shapebroadcast_dynamic_shape)shape1shape2rrrshape1_shape2_rs @r,prefer_static_broadcast_shapers ~~dFF#34?H1v&Gv&Gw2  - -gw ?1??4v&Gv&G  , ,Wg >9???s7B %B  Bc>ttj|S)zReturn static rank of tensor `x` if available, else `tf.rank(x)`. Args: x: `Tensor` (already converted). Returns: Numpy array (if static rank is obtainable), else `Tensor`. )prefer_static_valuerrIrs r,prefer_static_rankrs Y^^A. //r5c>ttj|S)zReturn static shape of tensor `x` if available, else `tf.shape(x)`. Args: x: `Tensor` (already converted). Returns: Numpy array (if static shape is obtainable), else `Tensor`. )rrrBrs r,prefer_static_shapers Y__Q/ 00r5c8tj|}||S|S)zReturn static value of tensor `x` if available, else `x`. Args: x: `Tensor` (already converted). Returns: Numpy array (if static value is obtainable), else `Tensor`. )rrL)rstatic_xs r,rrs$ ' ' *(  O (r5c|yt||zjd}ttj|j ddddzS)z2Generate a new seed, from the given seed and salt.Nzutf-8i)strencoderwhashlibmd5 hexdigest)seedsaltstrings r, gen_new_seedrsN \  I  $ $W -& W[[ * * ,Ra 0" 5 BBr5c tj|d|g5tj|d}tj|j j dd tj|j jdj}tjdd |zzd z }|tj|k7rtd j|tj|}|j ddj||g}nt!j |d}t#j$t#jdt#j$d |zt&j( zt&j }|j j dddjddg}t+|}|r%|t!j,|d|df|dz gg}n$|d|dft!j,||dz gg}|j/r|j1n0t!j2t!j |dd||ggd}t!j4t!j2|d|}t!j6||rdnd|rdnd}|j9||cdddS#1swYyxYw)aCreates a (batch of) triangular matrix from a vector of inputs. Created matrix can be lower- or upper-triangular. (It is more efficient to create the matrix as upper or lower, rather than transpose.) Triangular matrix elements are filled in a clockwise spiral. See example, below. If `x.get_shape()` is `[b1, b2, ..., bB, d]` then the output shape is `[b1, b2, ..., bB, n, n]` where `n` is such that `d = n(n+1)/2`, i.e., `n = int(np.sqrt(0.25 + 2. * m) - 0.5)`. Example: ```python fill_triangular([1, 2, 3, 4, 5, 6]) # ==> [[4, 0, 0], # [6, 5, 0], # [3, 2, 1]] fill_triangular([1, 2, 3, 4, 5, 6], upper=True) # ==> [[1, 2, 3], # [0, 5, 6], # [0, 0, 4]] ``` For comparison, a pure numpy version of this function can be found in `util_test.py`, function `_fill_triangular`. Args: x: `Tensor` representing lower (or upper) triangular elements. upper: Python `bool` representing whether output matrix should be upper triangular (`True`) or lower triangular (`False`, default). name: Python `str`. The name to give this op. Returns: tril: `Tensor` with lower (or upper) triangular elements filled from `x`. Raises: ValueError: if `x` cannot be mapped to a triangular matrix. fill_triangularrrrrvrVNg?@g?zGInput right-most shape ({}) does not correspond to a triangular matrix.rur.rr) num_lower num_upper)rrrrrrBrrMr#rrsqrtfloorrWr concatenaterrr*rr"rreverserrrAreshapematrix_band_part set_shape) rupperrmrstatic_final_shaperx_list new_shapes r,rrs{V ~~d-qc:E  ac*A## ""1%b)+267 ((177<<#)) *a ''$a- 3 &a bhhqk >>DfQiI I ((1+a773B<33QF; //! R a -- --x}}QU&..II J  a7755a8"=II ,J q !E 9$$QsABwZuqykBCf#qr' I--auqykBCf(:(K(K(M""$   yq1#26A?a H )**6;YGA"" 5abEbq KAKK"# KE E E s J2KKc tj|d|g5tj|d}tj|j j dd ttj|j jdj}tj||dzzdz}|j dd j|g}nQtj |d}||dzzdz}|j j ddd jdg}t|}|r|d d ddf}|d ddddf}n/tj|d dddf|dz g }|d ddddf}tjtj||dz g |dz g } || z} tj| tj tj |dd ||dz zggd } tj || d d||z fgd } | j#|| cdddS#1swYyxYw) aCreates a vector from a (batch of) triangular matrix. The vector is created from the lower-triangular or upper-triangular portion depending on the value of the parameter `upper`. If `x.shape` is `[b1, b2, ..., bB, n, n]` then the output shape is `[b1, b2, ..., bB, d]` where `d = n (n + 1) / 2`. Example: ```python fill_triangular_inverse( [[4, 0, 0], [6, 5, 0], [3, 2, 1]]) # ==> [1, 2, 3, 4, 5, 6] fill_triangular_inverse( [[1, 2, 3], [0, 5, 6], [0, 0, 4]], upper=True) # ==> [1, 2, 3, 4, 5, 6] ``` Args: x: `Tensor` representing lower (or upper) triangular elements. upper: Python `bool` representing whether output matrix should be upper triangular (`True`) or lower triangular (`False`, default). name: Python `str`. The name to give this op. Returns: flat_tril: (Batch of) vector-shaped `Tensor` representing vectorized lower (or upper) triangular elements from `x`. fill_triangular_inverserrrrurVNrv.rr)rrrrrrBrrMr#rrrrrrrrAr) rrrrrrrinitial_elementstriangular_portionrotated_triangular_portionconsolidated_matrix end_sequenceys r,rrs9L ~~d5qcB  ac*A## ""1%b)+267 ((177<<#)) *a ((AQKA% &a773B<33QC8 //! R a A;1 a7755a8"=II & q !E 319S!"aZ="**1S"aZ= {KS#2#q[>!*!2!2,EAI;?ai["-/II$$)//!,Sb1AQK=AJLL *Lfq1uf,EFRPAKK"# 9   s HH>>Icd}d}tj|d|||g5| array([[ 4., 8., 0., 0.], # [ 1., 5., 9., 0.], # [ 0., 2., 6., 10.], # [ 0., 0., 3., 7.]], dtype=float32) ``` Warning: This Op is intended for convenience, not efficiency. Args: below: `Tensor` of shape `[B1, ..., Bb, d-1]` corresponding to the below diagonal part. `None` is logically equivalent to `below = 0`. diag: `Tensor` of shape `[B1, ..., Bb, d]` corresponding to the diagonal part. `None` is logically equivalent to `diag = 0`. above: `Tensor` of shape `[B1, ..., Bb, d-1]` corresponding to the above diagonal part. `None` is logically equivalent to `above = 0`. name: Python `str`. The name to give this op. Returns: tridiag: `Tensor` with values set above, below and on the diagonal. Raises: ValueError: if all inputs are `None`. ctjtj|dddggd}tj||j}tj|||gdS)zBPrepends and appends a zero to every vector in a batch of vectors.NrVrvrrr)rrArBzerosr)rrBzs r,_padztridiag.._padsX   iooa0"5s;! DEQWW-A   Q1IB //r5cLd}|D]}|||} ||z }| td|S)z&Adds list of Tensors, ignoring `None`.Nz6Must specify at least one of `below`, `diag`, `above`.)rW)rrrs r,_addztridiag.._addsI A   9  Q  y O PP Hr5tridiagNbelowr.rVrvrabove)rrrr matrix_diag)r rr rrrs r,r r sB0   ~~dItU';< $ ##E8e##DK0crc12>e   " "4f 5d  " "4 (d ##E8e##DK0ab#2#>e tU # $ $ $s B4CC(ctj|d||g5tj|d}|Gtj|||}|r"t j |}||fcdddS|cdddStj||jd}|tjtj|z}tj||d} t jtj| t j| | } tj|tj|| z z} tj | ||} |st j"| |} tj| }| tj|| zz}|r ||fcdddS|cdddS#1swYyxYw) aComputes `log(abs(sum(weight * exp(elements across tensor dimensions))))`. If all weights `w` are known to be positive, it is more efficient to directly use `reduce_logsumexp`, i.e., `tf.reduce_logsumexp(logx + tf.math.log(w))` is more efficient than `du.reduce_weighted_logsumexp(logx, w)`. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keep_dims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. This function is more numerically stable than log(sum(w * exp(input))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs. For example: ```python x = tf.constant([[0., 0, 0], [0, 0, 0]]) w = tf.constant([[-1., 1, 1], [1, 1, 1]]) du.reduce_weighted_logsumexp(x, w) # ==> log(-1*1 + 1*1 + 1*1 + 1*1 + 1*1 + 1*1) = log(4) du.reduce_weighted_logsumexp(x, w, axis=0) # ==> [log(-1+1), log(1+1), log(1+1)] du.reduce_weighted_logsumexp(x, w, axis=1) # ==> [log(-1+1+1), log(1+1+1)] du.reduce_weighted_logsumexp(x, w, axis=1, keep_dims=True) # ==> [[log(-1+1+1)], [log(1+1+1)]] du.reduce_weighted_logsumexp(x, w, axis=[0, 1]) # ==> log(-1+5) ``` Args: logx: The tensor to reduce. Should have numeric type. w: The weight tensor. Should have numeric type identical to `logx`. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keep_dims: If true, retains reduced dimensions with length 1. return_sign: If `True`, returns the sign of the result. name: A name for the operation (optional). Returns: lswe: The `log(abs(sum(weight * exp(x))))` reduced tensor. sign: (Optional) The sign of `sum(weight * exp(x))`. reduce_weighted_logsumexplogxrN)rkeepdimswrrT)rrrrreduce_logsumexpr ones_likerr_r reduce_maxris_inf zeros_likerexpr]squeeze) rrr keep_dims return_signrlswesgn log_absw_xmax_log_absw_xwx_over_max_absw_xsum_wx_over_max_absw_xs r,rrs@ ~~d7$C  F 3Dy  & &t$ Kd !!$'Sy  atzzn --. /C HLL/E)EF FD 3Y78 9sA G0G;D5G:GGc tj|d|g5tj|d}tjtj |j jjdz}tj|tj|}tj|| }tj|}|}tjtj||tj ||}|tjtj"|  z}tj||tj|||cdddS#1swYyxYw)acComputes the inverse softplus, i.e., x = softplus_inverse(softplus(x)). Mathematically this op is equivalent to: ```none softplus_inverse = log(exp(x) - 1.) ``` Args: x: `Tensor`. Non-negative (not enforced), floating-point. name: A name for the operation (optional). Returns: `Tensor`. Has the same type/shape as input `x`. softplus_inverserrrrN)rrrrMr_rxrryepsrrrgreaterrr logical_orrexpm1)rr threshold is_too_small is_too_largetoo_small_valuetoo_large_valuers r,r#r#{s&  ~~d.s;%> ac*A.rxx 6 67;;G%>%>%>s EE22E;ctj|jjt j ||}||St j||S)z)Returns the size of a specific dimension.)rrrBrrMrr)rrrs r,dimension_sizer.sQ""gg  .t46!] H  D !!r5c "tj|d|g5|tjjj d\}}|j |j}|j |j}|tjj|ddz}tj|d| }tj|d | }||fcdddSt|\}}tj|d| }tj|d | }|tj|dd dd z}d}||||}}|"| ||k7rtdj|||rwtj t#|d t#|d dg} tj$| 5t'j(|}t'j(|}ddd||fcdddS#1swYxYw#1swYyxYw)aValidates quadrature grid, probs or computes them as necessary. Args: quadrature_grid_and_probs: Python pair of `float`-like `Tensor`s representing the sample points and the corresponding (possibly normalized) weight. When `None`, defaults to: `np.polynomial.hermite.hermgauss(deg=8)`. dtype: The expected `dtype` of `grid` and `probs`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. name: Python `str` name prefixed to Ops created by this class. Returns: quadrature_grid_and_probs: Python pair of `float`-like `Tensor`s representing the sample points and the corresponding (possibly normalized) weight. Raises: ValueError: if `quadrature_grid_and_probs is not None` and `len(quadrature_grid_and_probs[0]) != len(quadrature_grid_and_probs[1])` !process_quadrature_grid_and_probsNr)degrvT)ordrgridrSrTunnormalized_probsrV)r2rrrcdtj|jjddS)z:Returns the static size of a specific dimension or `None`.rvrV)rrrBrrs r,_static_event_sizez=process_quadrature_grid_and_probs.._static_event_sizes'  ) )!''*D*DQ*G*K LLr5zm`quadrature_grid_and_probs` must be a `tuple` of same-length zero-th-dimension `Tensor`s (saw lengths {}, {})rzX`quadrature_grid_and_probs` must be a `tuple` of same-length zero-th-dimension `Tensor`sr7)rrrM polynomialhermite hermgaussastyperylinalgnormrtupler rWrr r)r.control_dependenciesridentity) quadrature_grid_and_probsrrbrr3rTr6rrr9s r,r0r0s6 ~~d?013% (MM))333:kdE [[-- .dll5//0e ryy~~eT~::e  " "4fE Bd##EuEe 5[%%12KD%  F% @D  ! !%.B% PE Z__UT PPEM e $&8&>qA} a006q! > >   U,T+A Cj  # #J /*!!$'""5)* ;K%%D**E%%s+B>H!CH9+G9$ H9H >HHc *tj|d|||g5tj|d}tj||jd}tj|d}|jjs.t dj |jj|s |s td|jj|jjntj|d }tj|d }tj|}||}|d kr||z}tj|} |d k\s|jj|jd |} tj | d n(tj"|j|| ||zzz} |j|d zd } | j%| j%| } n"d } ntj&|d k||z|}d } tj(|tj*t-j.|r|nd|r|ndg|d |t0j2|}| |j5| |cd d d S#1swYy xYw)aZPads `value` to the front and/or back of a `Tensor` dim, `count` times. Args: x: `Tensor` input. axis: Scalar `int`-like `Tensor` representing the single dimension to pad. (Negative indexing is supported.) front: Python `bool`; if `True` the beginning of the `axis` dimension is padded with `value`, `count` times. If `False` no front padding is made. back: Python `bool`; if `True` the end of the `axis` dimension is padded with `value`, `count` times. If `False` no end padding is made. value: Scalar `int`-like `Tensor` representing the actual value added to the front and/or back of the `axis` dimension of `x`. count: Scalar `int`-like `Tensor` representing number of elements added to the front and/or back of the `axis` dimension of `x`. E.g., if `front = back = True` then `2 * count` elements are added. name: Python `str` name prefixed to Ops created by this function. Returns: pad: The padded version of input `x`. Raises: ValueError: if both `front` and `back` are `False`. TypeError: if `count` is not `int`-like. padrrrrcountz(`count.dtype` (`{}`) must be `int`-like.z/At least one of `front`, `back` must be `True`.NrrrrvrV)indicesdepthron_valuer)paddingsconstant_values)rrrrrr(rrrWrBrrrIrrLrrdimension_at_indexrrrBone_hotr stackrr#r)rrfrontbackrrCrraxis_count_headmiddletail final_shapes r,rBrBsO2 ~~dEAue#45+  ac*A  ! !%qwwW EE  ! !%g 6E ;; ! ! @GG ++     H II2  G9   F 3D  & &t ,E  d t|))%0f !qww}}0wwu~))&.$  + +AGGT :V T\> wwtaxy!&&v'9'9$'?@    q%$, =dk  ""#))B"=?,,   Akk+ W+ + + s I$J  Jc6tjjtjjdd\}}}}|j |i|j |i}i}|D]}|j |||<|j ||S)aLReturns parent frame arguments. When called inside a function, returns a dictionary with the caller's function arguments. These are positional arguments and keyword arguments (**kwargs), while variable arguments (*varargs) are excluded. When called at global scope, this will return an empty dictionary, since there are no arguments. WARNING: If caller function argument names are overloaded before invoking this method, then values will reflect the overloaded value. For this reason, we recommend calling `parent_frame_arguments` at the beginning of the function. rvr)r_inspect getargvaluesrKpopupdate) arg_namesvariable_arg_namekeyword_arg_name local_vars keyword_args final_argsarg_names r,parent_frame_argumentsr`Is"&&    # # %a ( +-=)  0* .."B' 0"5,*4h%>>(3Jx4 L! r5ceZdZdZddZdZy)AppendDocstringaLHelper class to promote private subclass docstring to public counterpart. Example: ```python class TransformedDistribution(Distribution): @distribution_util.AppendDocstring( additional_note="A special note!", kwargs_dict={"foo": "An extra arg."}) def _prob(self, y, foo=None): pass ``` In this case, the `AppendDocstring` decorator appends the `additional_note` to the docstring of `prob` (not `_prob`) and adds a new `kwargs` section with each dictionary item as a bullet-point. For a more detailed example, see `TransformedDistribution`. Ncb||_|rg}t|jD]`}||}td|Drt d|z|j }d|vrt d|z|j d|d|b|xjddj|zz c_yy) aInitializes the AppendDocstring object. Args: additional_note: Python string added as additional docstring to public version of function. kwargs_dict: Python string/string dictionary representing specific kwargs expanded from the **kwargs input. Raises: ValueError: if kwargs_dict.key contains whitespace. ValueError: if kwargs_dict.value contains newlines. c3<K|]}|jywr/)isspace).0rs r, z+AppendDocstring.__init__..s(qqyy{(sz(Parameter name "%s" contains whitespace. z1Parameter description for "%s" contains newlines.z* `z`: z ##### `kwargs`: N)_additional_notesortedkeysanyrWlstripappendjoin)selfadditional_note kwargs_dictbulletskeyrs r,__init__zAppendDocstring.__init__s,Dg ((*+5#C  (C( (G#MN N  5=CcIK KU345  9DIIg._fns    r5z %s) functoolswraps__doc__ri)rprzr{s ` r,__call__zAppendDocstring.__call__s^__R!! {{))ck J kkVd3333k Jr5)N)__name__ __module__ __qualname__r~rurrFr5r,rbrbns(P6 r5rb)NNNNr-)r:r/)NNFFreN)rY)Tembed_check_casting_closed)r)NN)r)r)r)FN)NNNN)NNFFN)FFrrvN)8r~r|rnumpyrMtensorflow.python.frameworkrrrrrtensorflow.python.opsrr r r rHr r rrtensorflow.python.utilrr-r4r:rJrPrermrprrr}rrrYrrrrrrrrrrrrr rr#r.r0rBr`rbrFr5r,rsZ/3.+43+1+12,*$-""& $"&2 )X: 3=$=>2!%#*/',4# NFb J <,7B\ B;?,HX=v7D;|J/Z+J`(G*?Z 0 1  Cp fB JA$J!%#'(-*/#' \D5>r",0@FD N"J::r5