o ?eDM@sdZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZeejejejejej ej!ej"ej#ej$ej%ej&ej'ej(ej)ej*ej+ej,ej-ej.gZ/gdZ0ddZ1ddZ2ddZ3ddZ4ddZ5dd Z6d!d"Z7d#d$Z8d%d&Z9ed'd'd(gd)ej:e;d(d*d(Zed2gd)ej:dd3d4Z?ed2d5gd)ej:e;d5e4d6d7dd8d5Z@ed9gd)ej:dd:d;ZAed9ddd?d<ZBed@gd)ej:ddAdBZCed@dCgd)ej:e;dCe4dDdEddFdCZDedGdHgd)ejEej:e6dIdHdJddKdLZFedGdHgd)ejEej:e5dIdMddNdHZGedOgd)ejEej:e6dPdQdRddSdTZHedOdQgd)ejEej:e;dQe5dPdU ddVdQZIedWgd)ejEej:  ddXdYZJedWdZgd)ejEej:e;dZ  dd[dZZKed\d]gd)ejEej:e6d^d]dJdd_d`ZLed\d]gd)ejEej:e5d^daddbd]ZMedcgd)ejEej:e6dddedJddfdgZNedcdegd)ejEej:e;dee5dddhddideZOedjdkgd)ejEej:e6dldkdmddndoZPedjdkgd)ejEej:e5dldpddqdkZQedrgd)ejEej:e6dsdtdmddudvZRedrdtgd)ejEej:e;dte5dsdw  ddxdtZSdydzZTed{d|gd)ej:dd}d~ZUed{d|gd)ej:ddd|ZVedgd)ej:dddZWeddgd)ej:e;d dddZXddZYddZZddZ[edgd)ej:dddZ\eddgd)ej:e;d dddZ]edgd)ej:dddZ^eddgd)ej:e;ddddZ_edgd)ej:dddZ`eddgd)ej:e;ddddZaddZbddZcddZdddZeefdgdZgedgd)ej:  dddZhedgd)ej:dddZiddZjedddgd)e;dddZkedgdd)ej:e;dddddZledgdd)ej:e;dddddZmdddZnedddgd)ej:e;ddddZoedgd)ej:dddZpeddgd)ej:e;ddddZqddÄZredăej:dddĄZse tdơddȄZudS)zAsserts and Boolean Checks.N)context)dtypes)errors)ops) sparse_tensortensor) tensor_shape) tensor_util) array_ops)cond)control_flow_assert)control_flow_ops)math_ops)compat) deprecation)dispatch) tf_export)assert_negativeassert_positiveassert_proper_iterableassert_non_negativeassert_non_positive assert_equalassert_none_equal assert_nearassert_integer assert_lessassert_less_equalassert_greaterassert_greater_equal assert_rankassert_rank_at_leastassert_rank_inassert_same_float_dtype assert_scalar assert_type assert_shapesis_non_decreasingis_numeric_tensoris_strictly_increasingcCs2t|tjs t|St|}|durt|S|SN) isinstance tensor_libTensorstrr constant_value)tZconst_tr2`/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/check_ops.py_maybe_constant_value_stringJs  r4cCs,|sdd|D}tjddd|ddS)zCRaises a InvalidArgumentError with as much information as possible.cSg|]}t|qSr2)r4.0xr2r2r3 Vz"_assert_static..N Znode_defopmessage)rInvalidArgumentErrorjoin) conditiondataZ data_staticr2r2r3_assert_staticSs rCcCsd|j|jjfS)z5Returns a string containing tensor's shape and dtype.zshape=%s dtype=%s)shapedtypenamerr2r2r3_shape_and_dtype_str[srGcfdd}|S)abCommon docstring for assert_* ops that evaluate a unary predicate over every element of a tensor. Args: sym: Mathematical symbol for the check performed on each element, i.e. "> 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`. cs$|j}}dj||d|_|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__)funcrKZ cap_sym_namerIrJr2r3 _decoratorls  "z%_unary_assert_doc.._decoratorr2)rIrJrRr2rQr3_unary_assert_doc`s 0rScrH)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`. cs|j}dj|d|_|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 rIrKtest_var)rLrNrO)rPrKrIrUr2r3rRs  XZz&_binary_assert_doc.._decoratorr2)rIrUrRr2rVr3_binary_assert_docs grWcsfdd}|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`. csdjd|_|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. rT)rNrO)rPrKrIrUr2r3rR#s  02z)_binary_assert_doc_v2.._decoratorr2)rIrKrUrRr2rXr3_binary_assert_doc_v2s >rYcCsXg}|d||dkr|j|jkrp|jrpt|}t|}|}t||} t||} t ||jd} |d| ||d| |d||  dd| |d||  dd| | d} | d} t | j |}t | j |}|d||| d||d ||| 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:) appendrDas_listrZ logical_notr wherenumpyZ boolean_maskminreshapesize)rIr8y summarizetest_oprBmaskindicesZ indices_npZx_valsZy_valsZnum_valsZx_npZy_npZx_sumZy_sumr2r2r3_make_assert_msg_datads2        rhcCsnt|tjr3|}t|rt|S|d}dd|d|D}t||j kr/| dt|St|S)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 rZcSr5r2)r/r6r2r2r3r9r:z!_pretty_print..Nz...) r,r-r.r_npZisscalarr/ralenrbr\)Z data_itemrdZarrZflatlstr2r2r3 _pretty_prints    rlc  st| ||||gtj|dd}tj|dd}trh|||} t| } | r2 WddSdur9dndkr?d|durKt|||| }|durV|gt|}t j ddd fd d |Dd |dur{d |d |j |d|j |g}|dur|gt|}t|||} t |} t |} | dur| durt|| | }t||tj| |dWdS1swYdS)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(). r8rFrcNrgeAr;c3s|]}t|VqdSr+)rl)r7drdr2r3 sz!_binary_assert..r<z+Condition x %s y did not hold element-wise: x (%s) = y (%s) = rp)r name_scopeconvert_to_tensorrexecuting_eagerlyr reduce_allrhlistrr?r@rFr r0riallrCr Assert)rIrKZop_funcZ static_funcr8rcrBrdr>rFrerAZx_staticZy_staticZcondition_staticr2rpr3_binary_assertsJ       $r{z debugging.assert_proper_iterabler)v1cCsNtjtjtjftj}t||rt dt |t |ds%t dt |dS)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-r.r SparseTensorriZndarrayrZbytes_or_text_typesr, TypeErrortypehasattr)valuesZunintentional_iterablesr2r2r3rs   zdebugging.assert_negativecCt||||dS)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. r8r>rdrF)rrr2r2r3assert_negative_v2rrz< 0negativecCst|}t|d||g7tj|dd}|dur-tr"t|}n|j}|dd||g}tjd|jd}t ||||dWdS1sGwYdS) Nrr8rmz*Condition x < 0 did not hold element-wise:rrrrErBrd _message_prefixrrtrurrvrGrFrErr8rBrdr>rFzeror2r2r3r@ $zdebugging.assert_positivecCt||||dS)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. r8rdr>rF)rrr2r2r3assert_positive_v2Urrrz> 0ZpositivecCt|}t|d||g7tj|dd}|dur-tr"t|}n|j}|dd||g}tjd|jd}t ||||dWdS1sGwYdS) Nrr8rmz*Condition x > 0 did not hold element-wise:rrrrrrrr2r2r3rvs $zdebugging.assert_non_negativecCr)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)rrr2r2r3assert_non_negative_v2rrz>= 0z non-negativecCr) Nrr8rmz+Condition x >= 0 did not hold element-wise:rrrrr rrrtrurrvrGrFrErrr2r2r3rrzdebugging.assert_non_positivecCr)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)rrr2r2r3assert_non_positive_v2rrrz<= 0z non-positivecCst|}t|d||g6tj|dd}|dur,tr"t|}n|j}|d||g}tjd|jd}t ||||dWdS1sFwYdS)Nrr8rmz4Condition x <= 0 did not hold element-wise:x (%s) = rrrrrr2r2r3rs  $zdebugging.assert_equalr==rncCt|||||dSNr8rcrdr>rF)rr8rcr>rdrFr2r2r3assert_equal_v2rz[1, 2]c Cs|t|d|||g||ur trdntWdSWdn1s*wYtddtjt j|||||| S)Nrr) rrtrrvrno_opr{requalrir8rcrBrdr>rFr2r2r3rszdebugging.assert_none_equal!=rcCst|||||dSr)rrr2r2r3assert_none_equal_v2 rz[2, 1]c Ctddtjtj|||||| S)Nrr)r{r not_equalrirr2r2r3r zdebugging.assert_nearc Cst|||||||dS)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 )r8rcrtolatolrdr>rF)r)r8rcrrr>rdrFr2r2r3assert_near_v2#s 3rrc Cs\t|}t|d|||||gtj|dd}tj|d|jd}|j}|jr*|j}t|j j } |dur9d| n|}|durCd| n|}tj|d|d}tj|d |d}t rbt |} t |} n|j} |j} |dur||d ||fd | |d | |g}||t|} t||} tt| | }tj|||d WdS1swYdS)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 rr8rmrc)rFrEN rrz3x and y not equal to tolerance rtol = %s, atol = %srrrsrp)rrrtrurEZ is_complexZ real_dtyperiZfinfoZas_numpy_dtypeepsrrvrGrFrabsrwlessr rz)r8rcrrrBrdr>rFrErZx_nameZy_nameZtoldiffrAr2r2r3rZs62  $zdebugging.assert_lessr cCrr)rrr2r2r3assert_greater_v2rrz[0, 1]c Cr)Nrr)r{rZgreaterrirr2r2r3rs zdebugging.assert_greater_equal>=r cCrr)r rr2r2r3assert_greater_equal_v2rrz[1, 0]c Cr)Nrr )r{r greater_equalrirr2r2r3r rc Cst|tjt|}|dur2|jdkrtd|j}|dur2|||s,td||t j ddS|t ||}|durPd|g} t |d| d} t | g|}tj|||d 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. NrRank must be a scalar.Static rank condition failedstatic_checks_determined_all_okrm&Rank must be a scalar. Received rank: rBrp)r&rint32r r0ndim ValueError get_shapendimsrrr rankr!with_dependenciesr rz) r8rstatic_conditiondynamic_conditionrBrd rank_static x_rank_staticrA this_data rank_checkr2r2r3_assert_rank_conditions$      rzdebugging.assert_rankr!cCr)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. r8rr>rF)r!rr2r2r3assert_rank_v2(rc Cs4t|d||ft|p gt|tjstj|dd}tj|dd}t|}dd}tj }t s9t|tjrlzassert_rank..NzTensor %s must have rankReceived shape: rrz:%sTensor %s must have rank %d. Received rank %d, shape %s)rrttupler,rr~rurrrrrvrFr rDrrargsr r8rrBrdr>rFrr assert_oper2r2r3r!JsD    !!zdebugging.assert_rank_at_leastcCr)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"rr2r2r3assert_rank_at_least_v2rrr"c Cst|d||ft|p gotj|dd}tj|dd}t|}dd}tj}tr0d}n|j }|durC|d ||d t |g}z t ||||||}Wn't yu} z| jd d krpt d ||| jd| jd|fd} ~ wwWd|S1swY|S)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"r8rmrcSs||kSr+r2rr2r2r3rrz&assert_rank_at_least..rNz!Tensor %s must have rank at leastrrrzC%sTensor %s must have rank at least %d. Received rank %d, shape %srr)rrtrrurrrrrvrFr rDrrrrrr2r2r3r"sF  !!cCs||vSr+r2)r given_ranksr2r2r3_static_rank_inrcCsPt|dkr tdSt|d|}|ddD] }t|t||}q|S)NrFr)rjrrurr logical_or)rrresultrr2r2r3_dynamic_rank_ins   rc Cs|D]}t|tjqtdd|D}tdd|DsE|D] }|jdkr*tdq|j} | durE|| |s?td| |t j d d S|t ||} t ||D]\}}|durld |g} t|d| d } t | g| } qRtj| ||d S)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. cSsg|]}t|qSr2)r r0r7rr2r2r3r9sz+_assert_ranks_condition..css|]}|duVqdSr+r2)r7rr2r2r3rqsz*_assert_ranks_condition..rrNrrrmrrrp)r&rrranyrrrrrrr rzipr!rr rz) r8ranksrrrBrdrZ ranks_staticrrrArrr2r2r3_assert_ranks_conditions.    rzdebugging.assert_rank_incCr)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. r8rr>rF)r#rr2r2r3assert_rank_in_v21rrr#c Cs.t|d|ft|t|pg{t|tjs tj|dd}tdd|D}t|}t s7t|tjr:d}n|j }|durR|d|gt |d t |g}z t||tt||}Wn'ty}z|jd d krtd |||jd |jd|fd}~wwWd|S1swY|S)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#r8rmcSsg|] }tj|ddqS)rrm)rrurr2r2r3r9usz"assert_rank_in..rNzTensor %s must have rank inrrrz=%sTensor %s must have rank in %s. Received rank %d, shape %srr)rrtrr,rr~rurrrvrFrxr rDrrrrrr)r8rrBrdr>rFrrr2r2r3r#RsJ   zdebugging.assert_integercCt|||ddS)aAssert that `x` is of integer dtype. If `x` has a non-integer type, `message`, as well as the dtype of `x` are printed, and `InvalidArgumentError` is raised. This can always be checked statically, so this method returns nothing. Args: x: A `Tensor`. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_integer". Raises: TypeError: If `x.dtype` is not a non-quantized integer type. r8r>rFN)rrr2r2r3assert_integer_v2srrcCst|d|g0tj|dd}|jjs,trd}n|j}dt|||jf}t |t dWdS1s;wYdS)aDAssert that `x` is of integer dtype. Example of adding a dependency to an operation: ```python with tf.control_dependencies([tf.compat.v1.assert_integer(x)]): output = tf.reduce_sum(x) ``` Args: x: `Tensor` whose basetype is integer and is not quantized. message: A string to prefix to the default message. name: A name for this operation (optional). Defaults to "assert_integer". Raises: TypeError: If `x.dtype` is anything other than non-quantized integer. Returns: A `no_op` that does nothing. Type can be determined statically. rr8rmrz9%sExpected "x" to be integer type. Found: %s of dtype %sZ!statically_determined_was_integerN) rrtrurE is_integerrrvrFrrrr)r8r>rFerr_msgr2r2r3rs$zdebugging.assert_typecCst||||ddS)adAsserts that the given `Tensor` is of the specified type. This can always be checked statically, so this method returns nothing. Example: >>> 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`. rZtf_typer>rFN)r&rr2r2r3assert_type_v2s rr&cCst|}t|d|g4t|tjstj|dd}|j|kr5t t |t |ddd|d|jt dWdS1sDwYdS) 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&rrmrFz must be of type z; got Z"statically_determined_correct_typeN)rZas_dtyperrtr,rr~rurErrgetattrrrrr2r2r3r&s   $cst||j}|du}|r|dkrdS|r/|dkr/|}fddt|D}|Stt|d}t|ddfddS) 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)rcs(g|]\}}|durt|n|qSr+)int)r7irbZ dynamic_shaper2r3r9&sz$_dimension_sizes..cSs tdgSNr)r Zconstantr2r2r2r3r-s z"_dimension_sizes..csSr+r2r2rr2r3r-s) r rDrrr] enumeraterrr )r8rZ rank_is_knownZ static_shapesizesZ has_rank_zeror2rr3_dimension_sizess      rcCs|stdgS|Sr)r)symbolic_shaper2r2r3_symbolic_dimension_sizes0s rc Cs<|du}zt|d}Wn ttfyd}Ynw|o|S)NTF)rrr)Zdimension_sizeZnot_noneZcan_be_parsed_as_intr2r2r3_has_known_value8srcCs|dvS)N)N.r2)symbolr2r2r3_is_symbol_for_any_sizeBrr_TensorDimSizes)r8unspecified_dim actual_sizessymbolic_sizeszdebugging.assert_shapescCst|||||ddS)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. )rBrdr>rFN)r')shapesrBrdr>rFr2r2r3assert_shapes_v2Ks?  rc" st|tr |}t|}t|d||gdd|D}tfdd}g}|D]X\} } t| dp:t| d} | sHt d||| | ft | } d } t | D]\}}|t d fvr]qR|d krlt d ||| |fd } qR| t| | t| t| r| ddn| q-g}|D]=}t|j}|dv}|jr|rqt|j|||||d}n|rt|jd dg||||d}n t|j|||||d}| |qg}i}|D]}t |jD]\}}t|rq|jr|t|j}n|}||vst|rt|rt|}d}n||\}}}d|||f}t| |j|}Wdn 1s$wYt|rPt|rPt|t|krOt d||||j||||jfqtt |t |}|}|durv||d||j|d|dt!"|jg}| t#j$|||dqt| |j|} Wdn 1swY| |j|f||<qqWdn 1swYt|t%&|}!Wd|!S1swY|!S)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'cSs6g|]\}}|durt|tjr|nt||fqSr+)r,rr~rru)r7r8sr2r2r3r9s   z!assert_shapes..csst|tjr t|S|jSr+)r,rr~rGrFr8rvr2r3 tensor_namesz"assert_shapes..tensor_namer} __getitem__z%sTensor %s. Specified shape must be an iterable. An iterable has the attribute `__iter__` or `__getitem__`. Received specified shape: %sF*rz%sTensor %s specified shape index %d. Symbol `...` or `*` for a variable number of unspecified dimensions is only allowed as the first entryTrN)rr)r8rrBrdr>rF)r8rrBrdr>rFzSpecified 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 sizerrp)'r,dictitemsrrrtrrvrrrrEllipsisr\rrrrjrrr"r8r#r!rrrZcontrol_dependenciesrrrrrur rDr rzrgroup)"rrBrdr>rFZmessage_prefixZshape_constraintsr Ztensor_dim_sizesrr is_iterableZsymbolic_shape_tupleZtensors_specified_innermostrrZrank_assertionsrrZrank_zero_or_oneZ assertionZsize_assertionsZsize_specificationsZ size_symbolZ tensor_dimZspecified_sizeZsize_check_messageZspecified_by_yZspecified_at_dimZ actual_sizerAZdata_rbZshapes_assertionr2r r3r's \                    r'csjtdgtstdttd}fdd}tdfdd}t|||S)z#Gets the difference x[1:] - x[:-1].r[z+Expected x to be numeric, instead found: %srcstjgjdS)Nr)rrurEr2r r2r3rsz4_get_diff_for_monotonic_comparison..rcs&tdgdgtdgS)Nrr)r Z strided_slicer2Zs_lenr8r2r3rs&) r rar)rrrrbrDr )r8Zis_shorter_than_twoZ short_resultrr2rr3"_get_diff_for_monotonic_comparisons  rzdebugging.is_numeric_tensorr)cCst|tjo |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-r.rE NUMERIC_TYPESrr2r2r3r)s math.is_non_decreasing)rdebugging.is_non_decreasingr(rr(cC^t|d|gt|}tjd|jd}tt||WdS1s(wYdS)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(rrN)rrtrrurErrwrr8rFrrr2r2r3r(s #$math.is_strictly_increasing)r debugging.is_strictly_increasingr*rr*cCr)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*rrN)rrtrrurErrwrrr2r2r3r*s $$cCs|}d}|D]}|dur|jj}|s|}q||krd}qq|re|}d}|D]<}|durb|jj}|sA|}t|dr<|jnt|}q&||krbtdt|drO|jnt||||r]d|fdfq&|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. FNTrFz-%s, type=%s, must be of the same type (%s)%s.z as %sr)rEZ base_dtyperrFr/r)r expected_typeZoriginal_expected_typeZmismatchitemZ item_typeZoriginal_item_strr2r2r3_assert_same_base_types> rz!debugging.assert_same_float_dtyper$cCs2|rt||}|stj}|S|jstd||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.)rrfloat32Z is_floatingr)ZtensorsrEr2r2r3r$Fs  zdebugging.assert_scalarcCr)aAsserts that the given `tensor` is a scalar. This function raises `ValueError` unless it can be certain that the given `tensor` is a scalar. `ValueError` is also raised if the shape of `tensor` is unknown. This is always checked statically, so this method returns nothing. Args: tensor: A `Tensor`. message: A string to prefix to the default message. name: A name for this operation. Defaults to "assert_scalar" Raises: ValueError: If the tensor is not scalar (rank 0), or if its shape is unknown. rr>rFN)r%r!r2r2r3assert_scalar_v2isr"r%cCst|d|g4}tj||d}|}t|}|jdkr3tr)td||ftd||j |f|WdS1s?wYdS)a5Asserts that the given `tensor` is a scalar (i.e. zero-dimensional). This function raises `ValueError` unless it can be certain that the given `tensor` is a scalar. `ValueError` is also raised if the shape of `tensor` is unknown. Args: tensor: A `Tensor`. name: A name for this operation. Defaults to "assert_scalar" message: A string to prefix to the default message. Returns: The input tensor (potentially converted to a `Tensor`). Raises: ValueError: If the tensor is not scalar (rank 0), or if its shape is unknown. r%rmrz'%sExpected scalar shape, saw shape: %s.z.%sExpected scalar shape for %s, saw shape: %s.N) rrtrurrrrrvrrF)rrFr>rtrDr2r2r3r%s  $cCs|rd|SdS)Nz%s. rr2)r>r2r2r3rsr ensure_shapecCs&t|tjs t|}tj|||dS)aUpdates the shape of a tensor and checks at runtime that the shape holds. When executed, this operation asserts that the input tensor `x`'s shape is compatible with the `shape` argument. See `tf.TensorShape.is_compatible_with` for details. >>> 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`. rm)r,r Z TensorShaper r#)r8rDrFr2r2r3r#s Z EnsureShapecCs~|Sr+r2)r=Zgradr2r2r3_ensure_shape_grad: sr$)NNN)NNNN)NNNNN)NNNNNN)NNr+)vrO collectionsr_riZtensorflow.python.eagerrZtensorflow.python.frameworkrrrrrr-r r Ztensorflow.python.opsr r r rrZtensorflow.python.utilrrrZ tensorflow.python.util.tf_exportr frozensetZfloat16r Zfloat64Zint8Zint16rZint64Zuint8Zuint16Zuint32Zuint64Zqint8Zqint16Zqint32Zquint8Zquint16Z complex64Z complex128Zbfloat16r__all__r4rCrGrSrWrYrhrlr{Zadd_dispatch_supportZdeprecated_endpointsrrrrrrrrrZ®ister_binary_elementwise_assert_apirrrrrrrrrrrrrr rrr!rr"rrrrr#rrrr&rrrr namedtuplerrr'rr)r(r*rr$r"r%rr#ZRegisterGradientr$r2r2r2r3s                  ?wN6K      !  !        4 P            0  > @ 4  >  $ !   A ! "/  !