AVhMHdZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZeej8ej:ej<ej>ej@ejBejDejFejHejJejLejNejPejRejTejVejXejZej\gZ/gdZ0dZ1dZ2dZ3dZ4dZ5dZ6dZ7dZ8dZ9edddg ejtejvdd!Z<ed"g ejtdd#Z=ed"d$g ejtejvd$e4d%d&dd'Z>ed(g ejtdd)Z?ed(d*g ejtejvd*e4d+d,dd-Z@ed.g ejtdd/ZAed.d0g ejtejvd0e4d1d2dd3ZBed4g ejtdd5ZCed4d6g ejtejvd6e4d7d8dd9ZDed:d;g ejejte6dZFed:d;g ejejte5d 0" sym_name: English-language name for the op described by sym Returns: Decorator that adds the appropriate docstring to the function for symbol `sym`. cr|j}j}dj|||_|S)zGenerated decorator that adds the appropriate docstring to the function for symbol `sym`. Args: func: Function for a TensorFlow op Returns: Version of `func` with documentation attached. a Assert the condition `x {sym}` holds element-wise. When running in graph mode, you should add a dependency on this operation to ensure that it runs. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.debugging.{opname}(x, y)]): output = tf.reduce_sum(x) ``` {sym_name} means, for every element `x[i]` of `x`, we have `x[i] {sym}`. If `x` is empty this is trivially satisfied. Args: x: Numeric `Tensor`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "{opname}". Returns: Op that raises `InvalidArgumentError` if `x {sym}` is False. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x {sym}` is False. The check can be performed immediately during eager execution or if `x` is statically known. )symsym_nameopname)__name__ capitalizeformat__doc__)funcrN cap_sym_namerLrMs r5 _decoratorz%_unary_assert_doc.._decoratorlsJ]]F&&(L @  ,v  7A LD Kr7)rLrMrUs`` r5_unary_assert_docrW`s.` r7cfd}|S)afCommon docstring for most of the v1 assert_* ops that compare two tensors element-wise. Args: sym: Binary operation symbol, i.e. "==" test_var: a string that represents the variable in the right-hand side of binary operator of the test case Returns: Decorator that adds the appropriate docstring to the function for symbol `sym`. cR|j}dj||_|S)zGenerated decorator that adds the appropriate docstring to the function for symbol `sym`. Args: func: Function for a TensorFlow op Returns: A version of `func` with documentation attached. a Assert the condition `x {sym} y` holds element-wise. This condition holds if for every pair of (possibly broadcast) elements `x[i]`, `y[i]`, we have `x[i] {sym} y[i]`. If both `x` and `y` are empty, this is trivially satisfied. When running in graph mode, you should add a dependency on this operation to ensure that it runs. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.{opname}(x, y)]): output = tf.reduce_sum(x) ``` Args: x: Numeric `Tensor`. y: Numeric `Tensor`, same dtype as and broadcastable to `x`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`, `y`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "{opname}". Returns: Op that raises `InvalidArgumentError` if `x {sym} y` is False. Raises: InvalidArgumentError: if the check can be performed immediately and `x {sym} y` is False. The check can be performed immediately during eager execution or if `x` and `y` are statically known. @compatibility(TF2) `tf.compat.v1.{opname}` is compatible with eager execution and `tf.function`. Please use `tf.debugging.{opname}` instead when migrating to TF2. Apart from `data`, all arguments are supported with the same argument name. If you want to ensure the assert statements run before the potentially-invalid computation, please use `tf.control_dependencies`, as tf.function auto-control dependencies are insufficient for assert statements. #### Structural Mapping to Native TF2 Before: ```python tf.compat.v1.{opname}( x=x, y=y, data=data, summarize=summarize, message=message, name=name) ``` After: ```python tf.debugging.{opname}( x=x, y=y, message=message, summarize=summarize, name=name) ``` #### TF1 & TF2 Usage Example TF1: >>> g = tf.Graph() >>> with g.as_default(): ... a = tf.compat.v1.placeholder(tf.float32, [2]) ... b = tf.compat.v1.placeholder(tf.float32, [2]) ... result = tf.compat.v1.{opname}(a, b, ... message='"a {sym} b" does not hold for the given inputs') ... with tf.compat.v1.control_dependencies([result]): ... sum_node = a + b >>> sess = tf.compat.v1.Session(graph=g) >>> val = sess.run(sum_node, feed_dict={{a: [1, 2], b:{test_var}}}) TF2: >>> a = tf.Variable([1, 2], dtype=tf.float32) >>> b = tf.Variable({test_var}, dtype=tf.float32) >>> assert_op = tf.debugging.{opname}(a, b, message= ... '"a {sym} b" does not hold for the given inputs') >>> # When working with tf.control_dependencies >>> with tf.control_dependencies([assert_op]): ... val = a + b @end_compatibility rLrNtest_var)rOrQrRrSrNrLr[s r5rUz&_binary_assert_doc.._decorators=]]FXp    3q Lt Kr7rV)rLr[rUs`` r5_binary_assert_docr]seN r7cfd}|S)aOCommon docstring for v2 assert_* ops that compare two tensors element-wise. Args: sym: Binary operation symbol, i.e. "==" opname: Name for the symbol, i.e. "assert_equal" test_var: A number used in the docstring example Returns: Decorator that adds the appropriate docstring to the function for symbol `sym`. c:dj|_|S)zDecorator that adds docstring to the function for symbol `sym`. Args: func: Function for a TensorFlow op Returns: A version of `func` with documentation attached. a Assert the condition `x {sym} y` holds element-wise. This Op checks that `x[i] {sym} y[i]` holds for every pair of (possibly broadcast) elements of `x` and `y`. If both `x` and `y` are empty, this is trivially satisfied. If `x` {sym} `y` does not hold, `message`, as well as the first `summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is raised. When using inside `tf.function`, this API takes effects during execution. It's recommended to use this API with `tf.control_dependencies` to ensure the correct execution order. In the following example, without `tf.control_dependencies`, errors may not be raised at all. Check `tf.control_dependencies` for more details. >>> def check_size(x): ... with tf.control_dependencies([ ... tf.debugging.{opname}(tf.size(x), {test_var}, ... message='Bad tensor size')]): ... return x >>> check_size(tf.ones([2, 3], tf.float32)) Traceback (most recent call last): ... InvalidArgumentError: ... Args: x: Numeric `Tensor`. y: Numeric `Tensor`, same dtype as and broadcastable to `x`. message: A string to prefix to the default message. (optional) summarize: Print this many entries of each tensor. (optional) name: A name for this operation (optional). Defaults to "{opname}". Returns: Op that raises `InvalidArgumentError` if `x {sym} y` is False. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x == y` is False. The check can be performed immediately during eager execution or if `x` and `y` are statically known. rZ)rQrRr\s r5rUz)_binary_assert_doc_v2.._decorator#s10`    3a Ld Kr7rV)rLrNr[rUs``` r5_binary_assert_doc_v2r`s<| r7crg}|jd|z|dkDr|j|jk(rF|jjr+tj|}t j |}|j}t j||} t j||} t||jd} |jd| z|j|d| |jd|j| jjdd| |jd|j| jjdd| |jjd} |jjd} t| j|}t| j|}|jd|z|j| d||jd |z|j| d||S) aSubroutine of _binary_assert that generates the components of the default error message when running in eager mode. Args: sym: Mathematical symbol for the test to apply to pairs of tensor elements, i.e. "==" x: First input to the assertion after applying `convert_to_tensor()` y: Second input to the assertion summarize: Value of the "summarize" parameter to the original assert_* call; tells how many elements of each tensor to print. test_op: TensorFlow op that returns a Boolean tensor with True in each position where the assertion is satisfied. Returns: List of tensors and scalars that, when stringified and concatenated, will produce the error message string. zCondition x %s y did not hold.rz%Indices of first %d different values:NzCorresponding x values:zCorresponding y values:zFirst %d elements of x:zFirst %d elements of y:) appendrFas_listr logical_notr wherenumpy boolean_maskminreshapesize)rLrBy summarizetest_oprAmaskindices indices_npx_valsy_valsnum_valsx_npy_npx_sumy_sums r5_make_assert_msg_datarzds$ $++.45]ww!''aggoo/  ! !' *d%g==?j%%a.f%%a.fY 0 0 34h kk9HDE kk*Yh'( kk+, kk&,,.((/ :; kk+, kk&,,.((/ :; 779  U #D 779  U #D  9 %E  9 %EKK)E12KKVe KK)E12KKVe  +r7cvt|tjr|j}t j |r t |S|jd}|d|Dcgc] }t |}}t||jkr|jdt |St |Scc}w)aTFormat a data item for use in an error message in eager mode. Args: data_item: One of the items in the "data" argument to an assert_* function. Can be a Tensor or a scalar value. summarize: How many elements to retain of each tensor-valued entry in data. Returns: An appropriate string representation of data_item rbNz...) r.r/r0rhnpisscalarr1rklenrlrd) data_itemrnarrflatrBlsts r5 _pretty_printrs :,,- // C {{3 Xo [[ d!*9- .SV .c . SDII  5 Xo y> /s#B6c ztj| ||||g5tj|d}tj|d}tjr|||} t j | } | r dddydndkrd|t|||| }||gt|z}tjdddjfd |D |$d |zd |jz|d |jz|g}||gt|z}t j |||} tj|} tj|} | *| (tj || | }t#||t%j&| |cdddS#1swYyxYw)aGeneric binary elementwise assertion. Implements the behavior described in _binary_assert_doc() above. Args: sym: Mathematical symbol for the test to apply to pairs of tensor elements, i.e. "==" opname: Name of the assert op in the public API, i.e. "assert_equal" op_func: Function that, if passed the two Tensor inputs to the assertion (x and y), will return the test to be passed to reduce_all() i.e. static_func: Function that, if passed numpy ndarray versions of the two inputs to the assertion, will return a Boolean ndarray with containing True in all positions where the assertion PASSES. i.e. np.equal for assert_equal() x: Numeric `Tensor`. y: Numeric `Tensor`, same dtype as and broadcastable to `x`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`, `y`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to the value of `opname`. Returns: See docstring template in _binary_assert_doc(). rBrHrmNrgeAr9c36K|]}t|ywr-)r).0drns r5 z!_binary_assert..sGQ]1i8Gsr:z+Condition x %s y did not hold element-wise: x (%s) = y (%s) = rn)r name_scopeconvert_to_tensorrexecuting_eagerlyr reduce_allrzlistrr>r?rHr r2r|allrDrAssert)rLrNop_func static_funcrBrmrArnr=rHror@x_staticy_staticcondition_statics ` r5_binary_assertrs6 ~~dFQ4L1-N ac*A ac*A  "1 g%%g.i -N-N   q= $S!Q 7C  y4:%  ' ' 99G$GG JJ  9C ? !&& ! !&& !   y4:%%%gam4i++A.h++A.h  ("666+h"AB'. ' ' 49 M[-N-N-NsA$F1 DF11F:z debugging.assert_proper_iterabler)v1ctjtjtj ft jz}t||rtdt|zt|dstdt|zy)aStatic assert that values is a "proper" iterable. `Ops` that expect iterables of `Tensor` can call this to validate input. Useful since `Tensor`, `ndarray`, byte/text type are all iterables themselves. Args: values: Object to be checked. Raises: TypeError: If `values` is not iterable or is one of `Tensor`, `SparseTensor`, `np.array`, `tf.compat.bytes_or_text_types`. z@Expected argument "values" to be a "proper" iterable. Found: %s__iter__z5Expected argument "values" to be iterable. Found: %sN) r/r0r SparseTensorr|ndarrayrbytes_or_text_typesr. TypeErrortypehasattr)valuesunintentional_iterabless r5rrs&-44bjjA""#/0 J V     $ ?$v,N PP %r7zdebugging.assert_negativec t||||S)aAssert the condition `x < 0` holds element-wise. This Op checks that `x[i] < 0` holds for every element of `x`. If `x` is empty, this is trivially satisfied. If `x` is not negative everywhere, `message`, as well as the first `summarize` entries of `x` are printed, and `InvalidArgumentError` is raised. Args: x: Numeric `Tensor`. message: A string to prefix to the default message. summarize: Print this many entries of each tensor. name: A name for this operation (optional). Defaults to "assert_negative". Returns: Op raising `InvalidArgumentError` unless `x` is all negative. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x[i] < 0` is False. The check can be performed immediately during eager execution or if `x` is statically known. rBr=rnrH)rrs r5assert_negative_v2rs< 1g NNr7rz< 0negativecrt|}tj|d||g5tj|d}|5t j r t |}n |j}|dd|z|g}tjd|j}t||||cdddS#1swYyxYw) NrrBrz*Condition x < 0 did not hold element-wise:rrrGrArn _message_prefixrrrrrrIrHrGrrBrArnr=rHzeros r5rr@s G $' ~~d-4y9 @ ac*A |  " " $#A&vv  6  a!d  !'' 2D q$TY ? @ @ @ A>B--B6zdebugging.assert_positivec t||||S)aAssert the condition `x > 0` holds element-wise. This Op checks that `x[i] > 0` holds for every element of `x`. If `x` is empty, this is trivially satisfied. If `x` is not positive everywhere, `message`, as well as the first `summarize` entries of `x` are printed, and `InvalidArgumentError` is raised. Args: x: Numeric `Tensor`. message: A string to prefix to the default message. summarize: Print this many entries of each tensor. name: A name for this operation (optional). Defaults to "assert_positive". Returns: Op raising `InvalidArgumentError` unless `x` is all positive. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x[i] > 0` is False. The check can be performed immediately during eager execution or if `x` is statically known. rBrnr=rH)rrs r5assert_positive_v2rUs< 1 7 NNr7rz> 0positivecrt|}tj|d||g5tj|d}|5t j r t |}n |j}|dd|z|g}tjd|j}t||||cdddS#1swYyxYw) NrrBrz*Condition x > 0 did not hold element-wise:rrrrrrs r5rrvs G $' ~~d-4y9 @ ac*A |  " " $#A&vv ?  a!d  !'' 2D tQTY ? @ @ @rzdebugging.assert_non_negativec t||||S)aAssert the condition `x >= 0` holds element-wise. This Op checks that `x[i] >= 0` holds for every element of `x`. If `x` is empty, this is trivially satisfied. If `x` is not >= 0 everywhere, `message`, as well as the first `summarize` entries of `x` are printed, and `InvalidArgumentError` is raised. Args: x: Numeric `Tensor`. message: A string to prefix to the default message. summarize: Print this many entries of each tensor. name: A name for this operation (optional). Defaults to "assert_non_negative". Returns: Op raising `InvalidArgumentError` unless `x` is all non-negative. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x[i] >= 0` is False. The check can be performed immediately during eager execution or if `x` is statically known. r)rrs r5assert_non_negative_v2r> qIw"& ((r7rz>= 0z non-negativecrt|}tj|d||g5tj|d}|5t j r t |}n |j}|dd|z|g}tjd|j}t||||cdddS#1swYyxYw) NrrBrz+Condition x >= 0 did not hold element-wise:rrrr rrrrrrrIrHrGrrs r5rrs G $' ~~d1At9= F ac*A |  " " $#A&vv  7  a!d  !'' 2D T149 E F F Frzdebugging.assert_non_positivec t||||S)aAssert the condition `x <= 0` holds element-wise. This Op checks that `x[i] <= 0` holds for every element of `x`. If `x` is empty, this is trivially satisfied. If `x` is not <= 0 everywhere, `message`, as well as the first `summarize` entries of `x` are printed, and `InvalidArgumentError` is raised. Args: x: Numeric `Tensor`. message: A string to prefix to the default message. summarize: Print this many entries of each tensor. name: A name for this operation (optional). Defaults to "assert_non_positive". Returns: Op raising `InvalidArgumentError` unless `x` is all non-positive. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x[i] <= 0` is False. The check can be performed immediately during eager execution or if `x` is statically known. r)rrs r5assert_non_positive_v2rrr7rz<= 0z non-positivecpt|}tj|d||g5tj|d}|4t j r t |}n |j}|d|z|g}tjd|j}t||||cdddS#1swYyxYw)NrrBrz4Condition x <= 0 did not hold element-wise:x (%s) = rrrrrs r5rrs G $' ~~d1At9= F ac*A |  " " $#A&vv   !d  !'' 2D Q49 E F F Fs A=B,,B5zdebugging.assert_equalr==rc"t|||||SNrBrmrnr=rH)rrBrmr=rnrHs r5assert_equal_v2rs Q)W4 PPr7z[1, 2]c 0tj|d|||g5||ur3tjrdnt j cdddS dddt ddtjtj|||||| S#1swY9xYw)Nrr) rrrrrno_oprrequalr|rBrmrArnr=rHs r5rrs  ~~dNQ4L9OAv..0T6F6L6L6NOO O nhnnbhh1i$ 88 OOs .B  Bzdebugging.assert_none_equal!=rc"t|||||Sr)rrs r5assert_none_equal_v2rs Q!y' $ &&r7z[2, 1]c btddtjtj|||||| S)Nrr)rr not_equalr|rs r5rrs3 183E3E aD)Wd LLr7zdebugging.assert_nearc &t|||||||S)aAssert the condition `x` and `y` are close element-wise. This Op checks that `x[i] - y[i] < atol + rtol * tf.abs(y[i])` holds for every pair of (possibly broadcast) elements of `x` and `y`. If both `x` and `y` are empty, this is trivially satisfied. If any elements of `x` and `y` are not close, `message`, as well as the first `summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is raised. The default `atol` and `rtol` is `10 * eps`, where `eps` is the smallest representable positive number such that `1 + eps != 1`. This is about `1.2e-6` in `32bit`, `2.22e-15` in `64bit`, and `0.00977` in `16bit`. See `numpy.finfo`. Args: x: Float or complex `Tensor`. y: Float or complex `Tensor`, same dtype as and broadcastable to `x`. rtol: `Tensor`. Same `dtype` as, and broadcastable to, `x`. The relative tolerance. Default is `10 * eps`. atol: `Tensor`. Same `dtype` as, and broadcastable to, `x`. The absolute tolerance. Default is `10 * eps`. message: A string to prefix to the default message. summarize: Print this many entries of each tensor. name: A name for this operation (optional). Defaults to "assert_near". Returns: Op that raises `InvalidArgumentError` if `x` and `y` are not close enough. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x != y` is False for any pair of elements in `x` and `y`. The check can be performed immediately during eager execution or if `x` and `y` are statically known. @compatibility(numpy) Similar to `numpy.testing.assert_allclose`, except tolerance depends on data type. This is due to the fact that `TensorFlow` is often used with `32bit`, `64bit`, and even `16bit` data. @end_compatibility )rBrmrtolatolrnr=rH)r)rBrmrrr=rnrHs r5assert_near_v2r#s!f qADty$4 11r7rc t|}tj|d|||||g5tj|d}tj|d|j}|j}|j r |j }tj|jj} |d| zn|}|d| zn|}tj|d|}tj|d |}tjrt|} t|} n|j} |j} ||d |d |d | z|d | z|g}||tj |zz} tj ||z } tj"tj$| | }t'j(|||cdddS#1swYyxYw)aAssert the condition `x` and `y` are close element-wise. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.assert_near(x, y)]): output = tf.reduce_sum(x) ``` This condition holds if for every pair of (possibly broadcast) elements `x[i]`, `y[i]`, we have ```tf.abs(x[i] - y[i]) <= atol + rtol * tf.abs(y[i])```. If both `x` and `y` are empty, this is trivially satisfied. The default `atol` and `rtol` is `10 * eps`, where `eps` is the smallest representable positive number such that `1 + eps != 1`. This is about `1.2e-6` in `32bit`, `2.22e-15` in `64bit`, and `0.00977` in `16bit`. See `numpy.finfo`. Args: x: Float or complex `Tensor`. y: Float or complex `Tensor`, same `dtype` as, and broadcastable to, `x`. rtol: `Tensor`. Same `dtype` as, and broadcastable to, `x`. The relative tolerance. Default is `10 * eps`. atol: `Tensor`. Same `dtype` as, and broadcastable to, `x`. The absolute tolerance. Default is `10 * eps`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`, `y`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_near". Returns: Op that raises `InvalidArgumentError` if `x` and `y` are not close enough. @compatibility(numpy) Similar to `numpy.testing.assert_allclose`, except tolerance depends on data type. This is due to the fact that `TensorFlow` is often used with `32bit`, `64bit`, and even `16bit` data. @end_compatibility rrBrrm)rHrGN rrz&x and y not equal to tolerance rtol = z , atol = rrr)rrrrrG is_complex real_dtyper|finfoas_numpy_dtypeepsrrrIrHrabsrlessrr)rBrmrrrArnr=rHrGrx_namey_nametoldiffr@s r5rrZsd G $' ~~dMAq$d+CDL ac*A ac9A GGE e ((5'' ( , ,C|28D|28D  F% @D  F% @D  "#A&f#A&fvvfvvf | CG N  ;#7d  Q' 'C <<A D##HMM$$<=I  % %i K=LLLs FGGzdebugging.assert_lessr c"t|||||Sr)r rs r5assert_greater_v2rs !qIw! ##r7z[0, 1]c btddtjtj|||||| S)Nrr )rrgreaterr|rs r5r r s1 -x/?/?Q4GT ;;r7zdebugging.assert_greater_equal>=r!c"t|||||Sr)r!rs r5assert_greater_equal_v2rs Q)W#' ))r7z[1, 0]c btddtjtj|||||| S)Nrr!)rr greater_equalr|rs r5r!r!s5 4h6L6L((!Qi$ PPr7ct|tjtj|}|b|j dk7r t d|jj}|,|||s t d||tjdS|tj||}|)d|g} t|d| } tj| g|}tj |||S) aAssert `x` has a rank that satisfies a given condition. Args: x: Numeric `Tensor`. rank: Scalar `Tensor`. static_condition: A python function that takes `[actual_rank, given_rank]` and returns `True` if the condition is satisfied, `False` otherwise. dynamic_condition: An `op` that takes [actual_rank, given_rank] and return `True` if the condition is satisfied, `False` otherwise. data: The tensors to print out if the condition is false. Defaults to error message and first few entries of `x`. summarize: Print this many entries of each tensor. Returns: Op raising `InvalidArgumentError` if `x` fails dynamic_condition. Raises: ValueError: If static checks determine `x` fails static_condition. rRank must be a scalar.Static rank condition failedstatic_checks_determined_all_okr&Rank must be a scalar. Received rank: rAr)r'rint32r r2ndim ValueError get_shapendimsrrr rankr"with_dependenciesrr) rBrstatic_conditiondynamic_conditionrArn rank_static x_rank_staticr@ this_data rank_checks r5_assert_rank_conditionrs*dFLL!**40+1 / 00KKM''M m[ 9 *M;H H  # #)J KK q 148)94@IT195J 22J<KI  # #Ity IIr7zdebugging.assert_rankr"c t||||S)aAssert that `x` has rank equal to `rank`. This Op checks that the rank of `x` is equal to `rank`. If `x` has a different rank, `message`, as well as the shape of `x` are printed, and `InvalidArgumentError` is raised. Args: x: `Tensor`. rank: Scalar integer `Tensor`. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank". Returns: Op raising `InvalidArgumentError` unless `x` has specified rank. If static checks determine `x` has correct rank, a `no_op` is returned. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: if the check can be performed immediately and `x` does not have rank `rank`. The check can be performed immediately during eager execution or if the shape of `x` is statically known. rBrr=rH)r"r s r5assert_rank_v2r (s> qtW4 @@r7c tj|d||ft|xsgz5t|tj stj |d}tj |d}t|}d}tj}tjst|tj rd}n |j}||d|z|d tj|g} t||||||} ddd|S#t $rj} | j"d d k(r;t!d ||| j"d | j"d|j%fzt!| j"d d} ~ wwxYw#1swYSxYw)a-Assert `x` has rank equal to `rank`. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.assert_rank(x, 2)]): output = tf.reduce_sum(x) ``` Args: x: Numeric `Tensor`. rank: Scalar integer `Tensor`. data: The tensors to print out if the condition is False. Defaults to error message and the shape of `x`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank". Returns: Op raising `InvalidArgumentError` unless `x` has specified rank. If static checks determine `x` has correct rank, a `no_op` is returned. Raises: ValueError: If static checks determine `x` has wrong rank. r"rBrrc ||k(Sr-rV actual_rank given_ranks r5zassert_rank..l {j7Pr7NzTensor %s must have rankReceived shape: rrz:%sTensor %s must have rank %d. Received rank %d, shape %s)rrtupler.rrrrrrrrrHr rFrrargsr rBrrArnr=rHrr assert_opes r5r"r"Jsy8 ~~dMAt9uTZR7H+HI$ a33 4   ,a  F 3Dg&GP   "jM4N4N&O d VVd |  $t +T3E //! d $(D2B):D)Mi-$B  $ 4 4 H dAFF1Iqvvay!++- @ AB B## $3$B s+CE?.D  E<A%E77E<<E??F zdebugging.assert_rank_at_leastc t||||S)aAssert that `x` has rank of at least `rank`. This Op checks that the rank of `x` is greater or equal to `rank`. If `x` has a rank lower than `rank`, `message`, as well as the shape of `x` are printed, and `InvalidArgumentError` is raised. Args: x: `Tensor`. rank: Scalar integer `Tensor`. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank_at_least". Returns: Op raising `InvalidArgumentError` unless `x` has specified rank or higher. If static checks determine `x` has correct rank, a `no_op` is returned. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: `x` does not have rank at least `rank`, but the rank cannot be statically determined. ValueError: If static checks determine `x` has mismatched rank. r )r#r s r5assert_rank_at_least_v2rs> gD IIr7r#c tj|d||ft|xsgz5tj|d}tj|d}t |}d}t j }tjrd}n |j}||d|z|d tj|g} t||||||} ddd|S#t$rS} | jd d k(r;td ||| jd | jd|jfzd} ~ wwxYw#1swYSxYw)aXAssert `x` has rank equal to `rank` or higher. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.assert_rank_at_least(x, 2)]): output = tf.reduce_sum(x) ``` Args: x: Numeric `Tensor`. rank: Scalar `Tensor`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank_at_least". Returns: Op raising `InvalidArgumentError` unless `x` has specified rank or higher. If static checks determine `x` has correct rank, a `no_op` is returned. Raises: ValueError: If static checks determine `x` has wrong rank. r#rBrrc ||k\Sr-rVr s r5rz&assert_rank_at_least..rr7rNz!Tensor %s must have rank at leastrrrzC%sTensor %s must have rank at least %d. Received rank %d, shape %srr)rrrrrrrrrrHr rFrrrrrs r5r#r#sR> ~~ "QIdjb0A$AC ac*A  F 3Dg&GP ..  " d VVd |  - 4d iooa0d (D2B):D)Mi-B   4 4 !4AFF1Iq{{}M NO O  3B s+BD4:C D1AD,,D11D44D>c ||vSr-rV)r given_rankss r5_static_rank_inr!s  ##r7ct|dkrtjdStj|d|}|ddD],}tj |tj||}.|S)NrFr)r~rrrr logical_or)rr resultrs r5_dynamic_rank_inr%sp   '' >>+a.+ 6&O9j  z;79F9 -r7c|D]}t|tjt|Dcgc]}t j |c}}t d|Dsi|D]}|jdk7std|jj} | ,|| |s td| |tjdS|tj||} t||D]1\}}| d|g} t!|d| } tj"| g| } 3t%j&| || Scc}w) aAssert `x` has a rank that satisfies a given condition. Args: x: Numeric `Tensor`. ranks: Scalar `Tensor`. static_condition: A python function that takes `[actual_rank, given_ranks]` and returns `True` if the condition is satisfied, `False` otherwise. dynamic_condition: An `op` that takes [actual_rank, given_ranks] and return `True` if the condition is satisfied, `False` otherwise. data: The tensors to print out if the condition is false. Defaults to error message and first few entries of `x`. summarize: Print this many entries of each tensor. Returns: Op raising `InvalidArgumentError` if `x` fails dynamic_condition. Raises: ValueError: If static checks determine `x` fails static_condition. c3$K|]}|du ywr-rVrrs r5rz*_assert_ranks_condition..s -1Q$Y -srrrrrrrr)r'rrrr r2anyrrrrrrr rzipr"rrr) rBranksrrrArnr ranks_staticrrr@rrs r5_assert_ranks_conditionr.sH,$dfll#$UKT 2248KL, - - -#3   Q 1223KKM''M m\ : *M<I I  # #)J KK q 159)ul3NdK;TBitQY7j"44j\9Mi N  # #Ity II/LsD=zdebugging.assert_rank_inc t||||S)aAssert that `x` has a rank in `ranks`. This Op checks that the rank of `x` is in `ranks`. If `x` has a different rank, `message`, as well as the shape of `x` are printed, and `InvalidArgumentError` is raised. Args: x: `Tensor`. ranks: `Iterable` of scalar `Tensor` objects. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank_in". Returns: Op raising `InvalidArgumentError` unless rank of `x` is in `ranks`. If static checks determine `x` has matching rank, a `no_op` is returned. This can be used with `tf.control_dependencies` inside of `tf.function`s to block followup computation until the check has executed. @compatibility(eager) returns None @end_compatibility Raises: InvalidArgumentError: `x` does not have rank in `ranks`, but the rank cannot be statically determined. ValueError: If static checks determine `x` has mismatched rank. rBr,r=rH)r$r0s r5assert_rank_in_v2r11s< !5' EEr7r$c ^tj|d|ft|zt|xsgz5t|tj stj |d}t|Dcgc]}tj |dc}}t|}tjst|tj rd}n |j}|+|d|zgt|zdtj|gz} t||tt ||} ddd|Scc}w#t"$rc}|j$d d k(rKt#d ||td |j$d D|j$d|j'fzd}~wwxYw#1swYSxYw)aVAssert `x` has rank in `ranks`. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.assert_rank_in(x, (2, 4))]): output = tf.reduce_sum(x) ``` Args: x: Numeric `Tensor`. ranks: Iterable of scalar `Tensor` objects. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of `x`. summarize: Print this many entries of each tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_rank_in". Returns: Op raising `InvalidArgumentError` unless rank of `x` is in `ranks`. If static checks determine `x` has matching rank, a `no_op` is returned. Raises: ValueError: If static checks determine `x` has mismatched rank. r$rBrrrNzTensor %s must have rank inrrrz=%sTensor %s must have rank in %s. Received rank %d, shape %sc3<K|]}|jywr-)itemr(s r5rz!assert_rank_in..s21affh2srr)rrrr.rrrrrrrHrr rFr.r!r%rrr) rBr,rArnr=rHrrrs r5r$r$Rs> ~~ qdU5\1E$*"4EEG$ a33 4   ,a N3((F;N OEg&G  "jM4N4N&O d VVd | 047 u+ iooa0d )!UO*:D)Mi)$L EO&   4 4 K2q 22q       /$L s=;F"0D. A>> a = tf.Variable(1.0) >>> tf.debugging.assert_type(a, tf_type= tf.float32) >>> b = tf.constant(21) >>> tf.debugging.assert_type(b, tf_type=tf.bool) Traceback (most recent call last): ... TypeError: ... >>> c = tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], ... dense_shape=[3, 4]) >>> tf.debugging.assert_type(c, tf_type= tf.int32) Args: tensor: A `Tensor`, `SparseTensor` or `tf.Variable` . tf_type: A tensorflow type (`dtypes.float32`, `tf.int64`, `dtypes.bool`, etc). message: A string to prefix to the default message. name: A name for this operation. Defaults to "assert_type" Raises: TypeError: If the tensor's data type doesn't match `tf_type`. r tf_typer=rHN)r'r=s r5assert_type_v2r?s@VWgDIr7r'c tj|}tj|d|g5t |t j stj|d}|j|k7r3tt|t|ddd|d|jtjdcdddS#1swYyxYw) aStatically asserts that the given `Tensor` is of the specified type. Args: tensor: A `Tensor` or `SparseTensor`. tf_type: A tensorflow type (`dtypes.float32`, `tf.int64`, `dtypes.bool`, etc). message: A string to prefix to the default message. name: A name to give this `Op`. Defaults to "assert_type" Raises: TypeError: If the tensors data type doesn't match `tf_type`. Returns: A `no_op` that does nothing. Type can be determined statically. r'r rrHz must be of type z; got "statically_determined_correct_typeN)ras_dtyperrr.rrrrGrrgetattrrrr=s r5r'r's& OOG $' ~~dMF84H fm88 9$$V(;f ||w  W % &wvvx'H&I g[v||.> @ AA  ! !"F GHHHs BCC ctj||jj}|du}|r|dk(ry|rR|dkDrM|jj }t |Dcgc]\}}| t |n|}}}|Stjtj|d}tj|dfdScc}}w)aGets the dimension sizes of a tensor `x`. If a size can be determined statically it is returned as an integer, otherwise as a tensor. If `x` is a scalar it is treated as rank 1 size 1. Args: x: A `Tensor`. Returns: Dimension sizes. Nr)rc.tjdgSNr)r constantrVr7r5rz"_dimension_sizes..4sY//4r7cSr-rV) dynamic_shapesr5rz"_dimension_sizes..4smr7) r rFrrre enumerateintrrr ) rBr rank_is_known static_shapeirlsizes has_rank_zerorIs @r5_dimension_sizesrQs//!$-   $d"-tqy tax;;=((*L!.  At%D =+;; E  L..!2A6- 46K MM  s0Cc"|s tdgS|SrF)r)symbolic_shapes r5_symbolic_dimension_sizesrT7s  !: r7c`|du} t|d}|xr|S#ttf$rd}YwxYw)NTF)rKrr)dimension_sizenot_nonecan_be_parsed_as_ints r5_has_known_valuerY?sI 4 '(!  *** i ! !s --c |dvS)N)N.rV)symbols r5_is_symbol_for_any_sizer]Is ; r7_TensorDimSizes)rBunspecified_dim actual_sizessymbolic_sizeszdebugging.assert_shapesc$t|||||y)aAssert tensor shapes and dimension size relationships between tensors. This Op checks that a collection of tensors shape relationships satisfies given constraints. Example: >>> n = 10 >>> q = 3 >>> d = 7 >>> x = tf.zeros([n,q]) >>> y = tf.ones([n,d]) >>> param = tf.Variable([1.0, 2.0, 3.0]) >>> scalar = 1.0 >>> tf.debugging.assert_shapes([ ... (x, ('N', 'Q')), ... (y, ('N', 'D')), ... (param, ('Q',)), ... (scalar, ()), ... ]) >>> tf.debugging.assert_shapes([ ... (x, ('N', 'D')), ... (y, ('N', 'D')) ... ]) Traceback (most recent call last): ... ValueError: ... If `x`, `y`, `param` or `scalar` does not have a shape that satisfies all specified constraints, `message`, as well as the first `summarize` entries of the first encountered violating tensor are printed, and `InvalidArgumentError` is raised. Size entries in the specified shapes are checked against other entries by their __hash__, except: - a size entry is interpreted as an explicit size if it can be parsed as an integer primitive. - a size entry is interpreted as *any* size if it is None or '.'. If the first entry of a shape is `...` (type `Ellipsis`) or '*' that indicates a variable number of outer dimensions of unspecified size, i.e. the constraint applies to the inner-most dimensions only. Scalar tensors and specified shapes of length zero (excluding the 'inner-most' prefix) are both treated as having a single dimension of size one. Args: shapes: dictionary with (`Tensor` to shape) items, or a list of (`Tensor`, shape) tuples. A shape must be an iterable. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of the violating tensor. summarize: Print this many entries of the tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_shapes". Raises: ValueError: If static checks determine any shape constraint is violated. )rArnr=rHN)r()shapesrArnr=rHs r5assert_shapes_v2rdRs~ 49gDJr7c $t|tr|j}t|}t j |d||g5|Dcgc]:\}}|3t|t jr|nt j||f<}}}tj$$fd} g} |D]\} } t| dxs t| d} | st|d| | d| t| }d}t|D].\}}|td fvr|d k7rtd || | |fzd }0| j!t#| |t%| t'|r|d dn|g}| D]}t)|j*}|dv}|j,r|r+t/|j0|||||}n;|rt3|j0d d g||||}nt5|j0|||||}|j!|g}i}| D]}t|j*D]\}}t7|r|j,r|t)|j*z }n|}||vs t9|rkt9|rt;|}d}n||\}}}d| ||fz}t j<|5|j>|}dddt9rat9|rVt;|t;|k7r=td||| |j0||||j0jAfztCjDt j|t j|} |}!|:||d| |j0z|d|dtGjH|j0g}!|j!tKjL| |!|t j<|5|j>|}"ddd"|j0|f||< dddt j<5tOjP}#ddd|#Scc}}w#1swYxYw#1swYrxYw#1swY]xYw#1swY#SxYw)a Assert tensor shapes and dimension size relationships between tensors. This Op checks that a collection of tensors shape relationships satisfies given constraints. Example: >>> n = 10 >>> q = 3 >>> d = 7 >>> x = tf.zeros([n,q]) >>> y = tf.ones([n,d]) >>> param = tf.Variable([1.0, 2.0, 3.0]) >>> scalar = 1.0 >>> tf.debugging.assert_shapes([ ... (x, ('N', 'Q')), ... (y, ('N', 'D')), ... (param, ('Q',)), ... (scalar, ()), ... ]) >>> tf.debugging.assert_shapes([ ... (x, ('N', 'D')), ... (y, ('N', 'D')) ... ]) Traceback (most recent call last): ... ValueError: ... Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.assert_shapes(shapes)]): output = tf.matmul(x, y, transpose_a=True) ``` If `x`, `y`, `param` or `scalar` does not have a shape that satisfies all specified constraints, `message`, as well as the first `summarize` entries of the first encountered violating tensor are printed, and `InvalidArgumentError` is raised. Size entries in the specified shapes are checked against other entries by their __hash__, except: - a size entry is interpreted as an explicit size if it can be parsed as an integer primitive. - a size entry is interpreted as *any* size if it is None or '.'. If the first entry of a shape is `...` (type `Ellipsis`) or '*' that indicates a variable number of outer dimensions of unspecified size, i.e. the constraint applies to the inner-most dimensions only. Scalar tensors and specified shapes of length zero (excluding the 'inner-most' prefix) are both treated as having a single dimension of size one. Args: shapes: A list of (`Tensor`, `shape`) tuples, wherein `shape` is the expected shape of `Tensor`. See the example code above. The `shape` must be an iterable. Each element of the iterable can be either a concrete integer value or a string that abstractly represents the dimension. For example, - `('N', 'Q')` specifies a 2D shape wherein the first and second dimensions of shape may or may not be equal. - `('N', 'N', 'Q')` specifies a 3D shape wherein the first and second dimensions are equal. - `(1, 'N')` specifies a 2D shape wherein the first dimension is exactly 1 and the second dimension can be any value. Note that the abstract dimension letters take effect across different tuple elements of the list. For example, `tf.debugging.assert_shapes([(x, ('N', 'A')), (y, ('N', 'B'))]` asserts that both `x` and `y` are rank-2 tensors and their first dimensions are equal (`N`). `shape` can also be a `tf.TensorShape`. data: The tensors to print out if the condition is False. Defaults to error message and first few entries of the violating tensor. summarize: Print this many entries of the tensor. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_shapes". Returns: Op raising `InvalidArgumentError` unless all shape constraints are satisfied. If static checks determine all constraints are satisfied, a `no_op` is returned. Raises: ValueError: If static checks determine any shape constraint is violated. r(Ncjst|tjr t|S|jSr-)r.rrrIrH)rBrs r5 tensor_namez"assert_shapes..tensor_names) jM,F,FG#A&& VVmr7r __getitem__zTensor z. Specified shape must be an iterable. An iterable has the attribute `__iter__` or `__getitem__`. Received specified shape: F*rz%sTensor %s specified shape index %d. Symbol `...` or `*` for a variable number of unspecified dimensions is only allowed as the first entryTr)rr)rBrrArnr=rH)rBr,rArnr=rHzSpecified explicitlyz#Specified by tensor %s dimension %dzL%s%s. Tensor %s dimension %s must have size %d. Received size %d, shape %szTensor %s dimensionzmust have sizerr))r.dictitemsrrrrrrrrrrrrJEllipsisrdr^rQrTr~rar_r#rBr$r"r]rYrKcontrol_dependenciesr`rrrr rFrrrgroup)%rcrArnr=rHmessage_prefixrBsshape_constraintsrgtensor_dim_sizesr rS is_iterablesymbolic_shape_tupletensors_specified_innermostrNr\rank_assertionsrOrrank_zero_or_one assertionsize_assertionssize_specifications size_symbol tensor_dimspecified_sizesize_check_messagespecified_by_yspecified_at_dim actual_sizer@data_rlshapes_assertionrs% @r5r(r(s&x \\^F"7+. ~~dOfd^<WI&,>!Qq} *!]-G-GH!//2A7>> 113 "3&N .* - 1 .- 0 [0.  BC C#>2$)! !56 +)!V (C (  6J{62A6 78 8'+# +  13CF3K'0'qr*6JL MNC&NPO!"( %% &d     (gg   #gga&   gg  Y'E"(HO!:I%e&:&:;9I.![ "; /   3u3344** - -1A+1N k * -N!7 $K0 =NN,<6^,.>?@ ''8 9,,Z8K 9 k */?/O;3~#66/!#5{5777K~{77$$&(()) nn##K0##N35)% \ 2% EGG(<? w>l 9 9: 2 2kWIWIt? s\Q6 ?Q H"Q6-Q =D,Q6)Q* 9 Q67RQ6Q' "Q6*Q3 /Q66Q?R c,tjdgtstdzt j tj d}d}tjdz fd}tj|||S)z#Gets the difference x[1:] - x[:-1].rcz+Expected x to be numeric, instead found: %src8tjgtS)Nr)rrboolrVr7r5rz7_get_results_for_monotonic_comparison..s..r>r7rcvtjdgdgztjdgS)Nrr)r strided_slice) compare_ops_lenrBsr5rz7_get_results_for_monotonic_comparison..s:a!qcEk2a!e,r7) r rkr*rrrrlrFr )rBris_shorter_than_two short_resultrrs`` @r5%_get_results_for_monotonic_comparisonrsB4 ! 1  AAE FF! innQ&7;>, //! q % $ & d ;;r7zdebugging.is_numeric_tensorr*c^t|tjxr|jtvS)a)Returns `True` if the elements of `tensor` are numbers. Specifically, returns `True` if the dtype of `tensor` is one of the following: * `tf.float16` * `tf.float32` * `tf.float64` * `tf.int8` * `tf.int16` * `tf.int32` * `tf.int64` * `tf.uint8` * `tf.uint16` * `tf.uint32` * `tf.uint64` * `tf.qint8` * `tf.qint16` * `tf.qint32` * `tf.quint8` * `tf.quint16` * `tf.complex64` * `tf.complex128` * `tf.bfloat16` Returns `False` if `tensor` is of a non-numeric type or if `tensor` is not a `tf.Tensor` object. )r.r/r0rG NUMERIC_TYPESrs r5r*r*s&@ FJ-- . P6<<=3PPr7math.is_non_decreasing)rdebugging.is_non_decreasingr)rr)ctj|d|g5t|tj}tj |cdddS#1swYyxYw)a!Returns `True` if `x` is non-decreasing. Elements of `x` are compared in row-major order. The tensor `[x[0],...]` is non-decreasing if for every adjacent pair we have `x[i] <= x[i+1]`. If `x` has less than two elements, it is trivially non-decreasing. See also: `is_strictly_increasing` >>> x1 = tf.constant([1.0, 1.0, 3.0]) >>> tf.math.is_non_decreasing(x1) >>> x2 = tf.constant([3.0, 1.0, 2.0]) >>> tf.math.is_non_decreasing(x2) Args: x: Numeric `Tensor`. name: A name for this operation (optional). Defaults to "is_non_decreasing" Returns: Boolean `Tensor`, equal to `True` iff `x` is non-decreasing. Raises: TypeError: if `x` is not a numeric tensor. r)N)rrrrrrrBrHrs r5r)r)sMF ~~d/!5% 0H4J4J KD   t $%%% /AAmath.is_strictly_increasing)r debugging.is_strictly_increasingr+rr+ctj|d|g5t|tj}tj |cdddS#1swYyxYw)aCReturns `True` if `x` is strictly increasing. Elements of `x` are compared in row-major order. The tensor `[x[0],...]` is strictly increasing if for every adjacent pair we have `x[i] < x[i+1]`. If `x` has less than two elements, it is trivially strictly increasing. See also: `is_non_decreasing` >>> x1 = tf.constant([1.0, 2.0, 3.0]) >>> tf.math.is_strictly_increasing(x1) >>> x2 = tf.constant([3.0, 1.0, 2.0]) >>> tf.math.is_strictly_increasing(x2) Args: x: Numeric `Tensor`. name: A name for this operation (optional). Defaults to "is_strictly_increasing" Returns: Boolean `Tensor`, equal to `True` iff `x` is strictly increasing. Raises: TypeError: if `x` is not a numeric tensor. r+N)rrrrrrrs r5r+r+sMH ~~d4qc:% 0H4D4D ED   t $%%%rc |}d}|D])}||jj}|s|}!||k7s'd}n|r|}d}|D]}||jj}|s&|}t|dr |jn t |}D||k7sJt t|dr |jn t |d|d|d|rd|znd d |S|S) aAsserts all items are of the same base type. Args: items: List of graph items (e.g., `Variable`, `Tensor`, `SparseTensor`, `Operation`, or `IndexedSlices`). Can include `None` elements, which will be ignored. expected_type: Expected type. If not specified, assert all items are of the same base type. Returns: Validated type, or none if neither expected_type nor items provided. Raises: ValueError: If any types do not match. FNTrHz, type=z, must be of the same type ()z as %srr[)rG base_dtyperrHr1r)rk expected_typeoriginal_expected_typemismatchr4 item_typeoriginal_item_strs r5_assert_same_base_typers ) (d **''i ! I % +M L JJ)) #-+24+@diic$i  i '"40diic$i?0Ax++rIKL L L  r7z!debugging.assert_same_float_dtyper%c~|r t||}|stj}|S|jst d|z|S)aValidate and return float type based on `tensors` and `dtype`. For ops such as matrix multiplication, inputs and weights must be of the same float type. This function validates that all `tensors` are the same type, validates that type is `dtype` (if supplied), and returns the type. Type must be a floating point type. If neither `tensors` nor `dtype` is supplied, the function will return `dtypes.float32`. Args: tensors: Tensors of input values. Can include `None` elements, which will be ignored. dtype: Expected type. Returns: Validated type. Raises: ValueError: if neither `tensors` nor `dtype` is supplied, or result is not float, or the common type of the inputs is not a floating point type. z%Expected floating point type, got %s.)rrfloat32 is_floatingr)tensorsrGs r5r%r%NsG4 "7E 2E  NNE ,    >> x = tf.constant([[1, 2, 3], ... [4, 5, 6]]) >>> x = tf.ensure_shape(x, [2, 3]) Use `None` for unknown dimensions: >>> x = tf.ensure_shape(x, [None, 3]) >>> x = tf.ensure_shape(x, [2, None]) If the tensor's shape is not compatible with the `shape` argument, an error is raised: >>> x = tf.ensure_shape(x, [5]) Traceback (most recent call last): ... tf.errors.InvalidArgumentError: Shape of tensor dummy_input [3] is not compatible with expected shape [5]. [Op:EnsureShape] During graph construction (typically tracing a `tf.function`), `tf.ensure_shape` updates the static-shape of the **result** tensor by merging the two shapes. See `tf.TensorShape.merge_with` for details. This is most useful when **you** know a shape that can't be determined statically by TensorFlow. The following trivial `tf.function` prints the input tensor's static-shape before and after `ensure_shape` is applied. >>> @tf.function ... def f(tensor): ... print("Static-shape before:", tensor.shape) ... tensor = tf.ensure_shape(tensor, [None, 3]) ... print("Static-shape after:", tensor.shape) ... return tensor This lets you see the effect of `tf.ensure_shape` when the function is traced: >>> cf = f.get_concrete_function(tf.TensorSpec([None, None])) Static-shape before: (None, None) Static-shape after: (None, 3) >>> cf(tf.zeros([3, 3])) # Passes >>> cf(tf.constant([1, 2, 3])) # fails Traceback (most recent call last): ... InvalidArgumentError: Shape of tensor x [3] is not compatible with expected shape [3,3]. The above example raises `tf.errors.InvalidArgumentError`, because `x`'s shape, `(3,)`, is not compatible with the `shape` argument, `(None, 3)` Inside a `tf.function` or `v1.Graph` context it checks both the buildtime and runtime shapes. This is stricter than `tf.Tensor.set_shape` which only checks the buildtime shape. Note: This differs from `tf.Tensor.set_shape` in that it sets the static shape of the resulting tensor and enforces it at runtime, raising an error if the tensor's runtime shape is incompatible with the specified shape. `tf.Tensor.set_shape` sets the static shape of the tensor without enforcing it at runtime, which may result in inconsistencies between the statically-known shape of tensors and the runtime value of tensors. For example, of loading images of a known size: >>> @tf.function ... def decode_image(png): ... image = tf.image.decode_png(png, channels=3) ... # the `print` executes during tracing. ... print("Initial shape: ", image.shape) ... image = tf.ensure_shape(image,[28, 28, 3]) ... print("Final shape: ", image.shape) ... return image When tracing a function, no ops are being executed, shapes may be unknown. See the [Concrete Functions Guide](https://www.tensorflow.org/guide/concrete_function) for details. >>> concrete_decode = decode_image.get_concrete_function( ... tf.TensorSpec([], dtype=tf.string)) Initial shape: (None, None, 3) Final shape: (28, 28, 3) >>> image = tf.random.uniform(maxval=255, shape=[28, 28, 3], dtype=tf.int32) >>> image = tf.cast(image,tf.uint8) >>> png = tf.image.encode_png(image) >>> image2 = concrete_decode(png) >>> print(image2.shape) (28, 28, 3) >>> image = tf.concat([image,image], axis=0) >>> print(image.shape) (56, 28, 3) >>> png = tf.image.encode_png(image) >>> image2 = concrete_decode(png) Traceback (most recent call last): ... tf.errors.InvalidArgumentError: Shape of tensor DecodePng [56,28,3] is not compatible with expected shape [28,28,3]. Caution: if you don't use the result of `tf.ensure_shape` the check may not run. >>> @tf.function ... def bad_decode_image(png): ... image = tf.image.decode_png(png, channels=3) ... # the `print` executes during tracing. ... print("Initial shape: ", image.shape) ... # BAD: forgot to use the returned tensor. ... tf.ensure_shape(image,[28, 28, 3]) ... print("Final shape: ", image.shape) ... return image >>> image = bad_decode_image(png) Initial shape: (None, None, 3) Final shape: (None, None, 3) >>> print(image.shape) (56, 28, 3) Args: x: A `Tensor`. shape: A `TensorShape` representing the shape of this tensor, a `TensorShapeProto`, a list, a tuple, or None. name: A name for this operation (optional). Defaults to "EnsureShape". Returns: A `Tensor`. Has the same type and contents as `x`. Raises: tf.errors.InvalidArgumentError: If `shape` is incompatible with the shape of `x`. r)r.r TensorShaper r)rBrFrHs r5rrs:T E<33 4  $ $U +E   5t 44r7 EnsureShapec~|Sr-rV)r<grads r5_ensure_shape_gradrB s  +r7)NNN)NNNN)NNNNN)NNNNNN)NNr-)vrR collectionsrhr|tensorflow.python.eagerrtensorflow.python.frameworkrrrrr r/r r tensorflow.python.opsr r rrrtensorflow.python.utilrrr tensorflow.python.util.tf_exportr frozensetfloat16rfloat64int8int16rint64uint8uint16uint32uint64qint8qint16qint32quint8quint16 complex64 complex128bfloat16r__all__r6rDrIrWr]r`rzrradd_dispatch_supportdeprecated_endpointsrrrrrrrrr®ister_binary_elementwise_assert_apirrrrrrrrrrrr rr!rr r"rr#r!r%r.r1r$r7rr?r'rQrTrYr] namedtupler^rdr(rr*r)r+rr%rr&rrRegisterGradientrrVr7r5rs  "+..+5<43+&52*).+6 NNFNNFNNFKK LL&,, fmmV]] MM6<< v}} NNF$$f&7&7   6 FA <~tnK\3l4HNV &*,DEG !!!":;P<G P6 &2. O/O> *,=>? !!!"345*%@&5@@" &2. O/O> *,=>? !!!"345*% @&5@ @  *r2 (3(B .0EFG !!!"786>*F+9HF" *r2 (3(B .0EFG !!!"786>*F+9HF" #^; 00 t^Q/Q01<Q '89 00 D(#8$1:8 (R0 00 t0!4&511&  ,.ABC 00 !!!"56D(#8<L$71D L  "r* 00 GK111+11h & 67 00 !!!-0CG ML118ML` "Mb9 00 sM1-P.1:P & 67 00 C"2#182  (R0 00 t0!4L511L  ,.ABC 00 !!!"56D(#M$71D M  %'7B? 00 s,a0#11@#  )+;<= 00 C";#1>;  +3 00 t3Q7)814)  /1GHI 00 !!!"89D(#BF"P$:1J P -J` "Mb9 A:A@ & 67 ;8;| +3 J4J@ /1GHI !!!"89;?=:J=@$1Jh %"- F.F> )+;<= !!!"23<@B4>BJ %"- 2.2& )+;<= !!!"23!G4>!GH "r* J+JB & 67 !!!-0H18H8M>+)+((>@  $, @D>J->JB ()* {+{~<& !%':;="!!"56Q7=Q>   !!!"?"57%7 %@ !  !!!"D":<%< %B,^ '+-FGI !!!";<=I < $, ;-;* (/:; !!!/23<B  > K5K5\m$%r7