# Copyright 2016 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

# pylint: disable=g-short-docstring-punctuation

"""Asserts and Boolean Checks."""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import collections

import numpy as np

from tensorflow.python.eager import context

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import errors

from tensorflow.python.framework import ops

from tensorflow.python.framework import sparse_tensor

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import tensor_util

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import control_flow_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.util import compat

from tensorflow.python.util import deprecation

from tensorflow.python.util.tf_export import tf_export

NUMERIC_TYPES = frozenset(

[dtypes.float32, dtypes.float64, dtypes.int8, dtypes.int16, dtypes.int32,

dtypes.int64, dtypes.uint8, dtypes.qint8, dtypes.qint32, dtypes.quint8,

dtypes.complex64])

__all__ = [

'assert_negative',

'assert_positive',

'assert_proper_iterable',

'assert_non_negative',

'assert_non_positive',

'assert_equal',

'assert_none_equal',

'assert_near',

'assert_integer',

'assert_less',

'assert_less_equal',

'assert_greater',

'assert_greater_equal',

'assert_rank',

'assert_rank_at_least',

'assert_rank_in',

'assert_same_float_dtype',

'assert_scalar',

'assert_type',

'assert_shapes',

'is_non_decreasing',

'is_numeric_tensor',

'is_strictly_increasing',

]

def _maybe_constant_value_string(t):

if not isinstance(t, ops.Tensor):

return str(t)

const_t = tensor_util.constant_value(t)

if const_t is not None:

return str(const_t)

return t

def _assert_static(condition, data):

"""Raises a InvalidArgumentError with as much information as possible."""

if not condition:

data_static = [_maybe_constant_value_string(x) for x in data]

raise errors.InvalidArgumentError(node_def=None, op=None,

message='\n'.join(data_static))

def _shape_and_dtype_str(tensor):

"""Returns a string containing tensor's shape and dtype."""

return 'shape=%s dtype=%s' % (tensor.shape, tensor.dtype.name)

@tf_export(

'debugging.assert_proper_iterable',

v1=['debugging.assert_proper_iterable', 'assert_proper_iterable'])

@deprecation.deprecated_endpoints('assert_proper_iterable')

def assert_proper_iterable(values):

"""Static 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`.

"""

unintentional_iterables = (

(ops.Tensor, sparse_tensor.SparseTensor, np.ndarray)

+ compat.bytes_or_text_types

)

if isinstance(values, unintentional_iterables):

raise TypeError(

'Expected argument "values" to be a "proper" iterable. Found: %s' %

type(values))

if not hasattr(values, '__iter__'):

raise TypeError(

'Expected argument "values" to be iterable. Found: %s' % type(values))

@tf_export('debugging.assert_negative', v1=[])

def assert_negative_v2(x, message=None, summarize=None, name=None):

"""Assert 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.

"""

return assert_negative(x=x, message=message, summarize=summarize, name=name)

@tf_export(v1=['debugging.assert_negative', 'assert_negative'])

@deprecation.deprecated_endpoints('assert_negative')

def assert_negative(x, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x < 0` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_negative(x)]):

output = tf.reduce_sum(x)

```

Negative means, for every element `x[i]` of `x`, we have `x[i] < 0`.

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 "assert_negative".

Returns:

Op raising `InvalidArgumentError` unless `x` is all negative.

"""

message = message or ''

with ops.name_scope(name, 'assert_negative', [x, data]):

x = ops.convert_to_tensor(x, name='x')

if data is None:

if context.executing_eagerly():

name = _shape_and_dtype_str(x)

else:

name = x.name

data = [

message,

'Condition x < 0 did not hold element-wise:',

'x (%s) = ' % name, x]

zero = ops.convert_to_tensor(0, dtype=x.dtype)

return assert_less(x, zero, data=data, summarize=summarize)

@tf_export('debugging.assert_positive', v1=[])

def assert_positive_v2(x, message=None, summarize=None, name=None):

"""Assert 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.

"""

return assert_positive(x=x, summarize=summarize, message=message, name=name)

@tf_export(v1=['debugging.assert_positive', 'assert_positive'])

@deprecation.deprecated_endpoints('assert_positive')

def assert_positive(x, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x > 0` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_positive(x)]):

output = tf.reduce_sum(x)

```

Positive means, for every element `x[i]` of `x`, we have `x[i] > 0`.

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 "assert_positive".

Returns:

Op raising `InvalidArgumentError` unless `x` is all positive.

"""

message = message or ''

with ops.name_scope(name, 'assert_positive', [x, data]):

x = ops.convert_to_tensor(x, name='x')

if data is None:

if context.executing_eagerly():

name = _shape_and_dtype_str(x)

else:

name = x.name

data = [

message, 'Condition x > 0 did not hold element-wise:',

'x (%s) = ' % name, x]

zero = ops.convert_to_tensor(0, dtype=x.dtype)

return assert_less(zero, x, data=data, summarize=summarize)

@tf_export('debugging.assert_non_negative', v1=[])

def assert_non_negative_v2(x, message=None, summarize=None, name=None):

"""Assert 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.

"""

return assert_non_negative(x=x, summarize=summarize, message=message,

name=name)

@tf_export(v1=['debugging.assert_non_negative', 'assert_non_negative'])

@deprecation.deprecated_endpoints('assert_non_negative')

def assert_non_negative(x, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x >= 0` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_non_negative(x)]):

output = tf.reduce_sum(x)

```

Non-negative means, for every element `x[i]` of `x`, we have `x[i] >= 0`.

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 "assert_non_negative".

Returns:

Op raising `InvalidArgumentError` unless `x` is all non-negative.

"""

message = message or ''

with ops.name_scope(name, 'assert_non_negative', [x, data]):

x = ops.convert_to_tensor(x, name='x')

if data is None:

if context.executing_eagerly():

name = _shape_and_dtype_str(x)

else:

name = x.name

data = [

message,

'Condition x >= 0 did not hold element-wise:',

'x (%s) = ' % name, x]

zero = ops.convert_to_tensor(0, dtype=x.dtype)

return assert_less_equal(zero, x, data=data, summarize=summarize)

@tf_export('debugging.assert_non_positive', v1=[])

def assert_non_positive_v2(x, message=None, summarize=None, name=None):

"""Assert 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.

"""

return assert_non_positive(x=x, summarize=summarize, message=message,

name=name)

@tf_export(v1=['debugging.assert_non_positive', 'assert_non_positive'])

@deprecation.deprecated_endpoints('assert_non_positive')

def assert_non_positive(x, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x <= 0` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_non_positive(x)]):

output = tf.reduce_sum(x)

```

Non-positive means, for every element `x[i]` of `x`, we have `x[i] <= 0`.

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 "assert_non_positive".

Returns:

Op raising `InvalidArgumentError` unless `x` is all non-positive.

"""

message = message or ''

with ops.name_scope(name, 'assert_non_positive', [x, data]):

x = ops.convert_to_tensor(x, name='x')

if data is None:

if context.executing_eagerly():

name = _shape_and_dtype_str(x)

else:

name = x.name

data = [

message,

'Condition x <= 0 did not hold element-wise:'

'x (%s) = ' % name, x]

zero = ops.convert_to_tensor(0, dtype=x.dtype)

return assert_less_equal(x, zero, data=data, summarize=summarize)

@tf_export('debugging.assert_equal', 'assert_equal', v1=[])

def assert_equal_v2(x, y, message=None, summarize=None, name=None):

"""Assert the condition `x == y` holds element-wise.

This Op checks that `x[i] == 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` and `y` are not equal, `message`, as well as the first `summarize`

entries of `x` and `y` are printed, and `InvalidArgumentError` is raised.

Args:

x: Numeric `Tensor`.

y: Numeric `Tensor`, same dtype as and broadcastable to `x`.

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_equal".

Returns:

Op that raises `InvalidArgumentError` if `x == 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.

"""

return assert_equal(x=x, y=y, summarize=summarize, message=message, name=name)

@tf_export(v1=['debugging.assert_equal', 'assert_equal'])

def assert_equal(x, y, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x == y` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_equal(x, y)]):

output = tf.reduce_sum(x)

```

This condition holds if for every pair of (possibly broadcast) elements

`x[i]`, `y[i]`, we have `x[i] == y[i]`.

If both `x` and `y` are empty, this is trivially satisfied.

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 "assert_equal".

Returns:

Op that raises `InvalidArgumentError` if `x == y` is False.

@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.

"""

message = message or ''

with ops.name_scope(name, 'assert_equal', [x, y, data]):

x = ops.convert_to_tensor(x, name='x')

y = ops.convert_to_tensor(y, name='y')

# Short-circuit if x and y are the same tensor.

if x is y:

return None if context.executing_eagerly() else control_flow_ops.no_op()

if context.executing_eagerly():

eq = math_ops.equal(x, y)

condition = math_ops.reduce_all(eq)

if not condition:

# Prepare a message with first elements of x and y.

summary_msg = ''

# Default to printing 3 elements like control_flow_ops.Assert (used

# by graph mode) does.

summarize = 3 if summarize is None else summarize

if summarize:

# reshape((-1,)) is the fastest way to get a flat array view.

x_np = x.numpy().reshape((-1,))

y_np = y.numpy().reshape((-1,))

x_sum = min(x_np.size, summarize)

y_sum = min(y_np.size, summarize)

summary_msg = ('First %d elements of x:\n%s\n'

'First %d elements of y:\n%s\n' %

(x_sum, x_np[:x_sum],

y_sum, y_np[:y_sum]))

index_and_values_str = ''

if x.shape == y.shape and x.shape.as_list():

# If the shapes of x and y are the same (and not scalars),

# Get the values that actually differed and their indices.

# If shapes are different this information is more confusing

# than useful.

mask = math_ops.logical_not(eq)

indices = array_ops.where(mask)

indices_np = indices.numpy()

x_vals = array_ops.boolean_mask(x, mask)

y_vals = array_ops.boolean_mask(y, mask)

summarize = min(summarize, indices_np.shape[0])

index_and_values_str = (

'Indices of first %s different values:\n%s\n'

'Corresponding x values:\n%s\n'

'Corresponding y values:\n%s\n' %

(summarize, indices_np[:summarize],

x_vals.numpy().reshape((-1,))[:summarize],

y_vals.numpy().reshape((-1,))[:summarize]))

raise errors.InvalidArgumentError(

node_def=None, op=None,

message=('%s\nCondition x == y did not hold.\n%s%s' %

(message or '', index_and_values_str, summary_msg)))

return

if data is None:

data = [

message,

'Condition x == y did not hold element-wise:',

'x (%s) = ' % x.name, x,

'y (%s) = ' % y.name, y

]

condition = math_ops.reduce_all(math_ops.equal(x, y))

x_static = tensor_util.constant_value(x)

y_static = tensor_util.constant_value(y)

if x_static is not None and y_static is not None:

condition_static = np.all(np.equal(x_static, y_static))

_assert_static(condition_static, data)

return control_flow_ops.Assert(condition, data, summarize=summarize)

@tf_export('debugging.assert_none_equal', v1=[])

def assert_none_equal_v2(x, y, summarize=None, message=None, name=None):

"""Assert the condition `x != y` holds for all elements.

This Op checks that `x[i] != 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 equal, `message`, as well as the first

`summarize` entries of `x` and `y` are printed, and `InvalidArgumentError`

is raised.

Args:

x: Numeric `Tensor`.

y: Numeric `Tensor`, same dtype as and broadcastable to `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_none_equal".

Returns:

Op that raises `InvalidArgumentError` if `x != y` is ever 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 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.

"""

return assert_none_equal(x=x, y=y, summarize=summarize, message=message,

name=name)

@tf_export(v1=['debugging.assert_none_equal', 'assert_none_equal'])

@deprecation.deprecated_endpoints('assert_none_equal')

def assert_none_equal(

x, y, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x != y` holds for all elements.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_none_equal(x, y)]):

output = tf.reduce_sum(x)

```

This condition holds if for every pair of (possibly broadcast) elements

`x[i]`, `y[i]`, we have `x[i] != y[i]`.

If both `x` and `y` are empty, this is trivially satisfied.

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 "assert_none_equal".

Returns:

Op that raises `InvalidArgumentError` if `x != y` is ever False.

"""

message = message or ''

with ops.name_scope(name, 'assert_none_equal', [x, y, data]):

x = ops.convert_to_tensor(x, name='x')

y = ops.convert_to_tensor(y, name='y')

if context.executing_eagerly():

x_name = _shape_and_dtype_str(x)

y_name = _shape_and_dtype_str(y)

else:

x_name = x.name

y_name = y.name

if data is None:

data = [

message,

'Condition x != y did not hold for every single element:',

'x (%s) = ' % x_name, x,

'y (%s) = ' % y_name, y

]

condition = math_ops.reduce_all(math_ops.not_equal(x, y))

return control_flow_ops.Assert(condition, data, summarize=summarize)

@tf_export('debugging.assert_near', v1=[])

def assert_near_v2(x, y, rtol=None, atol=None, message=None, summarize=None,

name=None):

"""Assert 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.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

"""

return assert_near(x=x, y=y, rtol=rtol, atol=atol, summarize=summarize,

message=message, name=name)

@tf_export(v1=['debugging.assert_near', 'assert_near'])

@deprecation.deprecated_endpoints('assert_near')

def assert_near(

x, y, rtol=None, atol=None, data=None, summarize=None, message=None,

name=None):

"""Assert 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.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

"""

message = message or ''

with ops.name_scope(name, 'assert_near', [x, y, rtol, atol, data]):

x = ops.convert_to_tensor(x, name='x')

y = ops.convert_to_tensor(y, name='y', dtype=x.dtype)

eps = np.finfo(x.dtype.as_numpy_dtype).eps

rtol = 10 * eps if rtol is None else rtol

atol = 10 * eps if atol is None else atol

rtol = ops.convert_to_tensor(rtol, name='rtol', dtype=x.dtype)

atol = ops.convert_to_tensor(atol, name='atol', dtype=x.dtype)

if context.executing_eagerly():

x_name = _shape_and_dtype_str(x)

y_name = _shape_and_dtype_str(y)

else:

x_name = x.name

y_name = y.name

if data is None:

data = [

message,

'x and y not equal to tolerance rtol = %s, atol = %s' % (rtol, atol),

'x (%s) = ' % x_name, x, 'y (%s) = ' % y_name, y

]

tol = atol + rtol * math_ops.abs(y)

diff = math_ops.abs(x - y)

condition = math_ops.reduce_all(math_ops.less(diff, tol))

return control_flow_ops.Assert(condition, data, summarize=summarize)

@tf_export('debugging.assert_less', 'assert_less', v1=[])

def assert_less_v2(x, y, message=None, summarize=None, name=None):

"""Assert the condition `x < y` holds element-wise.

This Op checks that `x[i] < 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` is not less than `y` element-wise, `message`, as well as the first

`summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is

raised.

Args:

x: Numeric `Tensor`.

y: Numeric `Tensor`, same dtype as and broadcastable to `x`.

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_less".

Returns:

Op that raises `InvalidArgumentError` if `x < 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.

"""

return assert_less(x=x, y=y, summarize=summarize, message=message, name=name)

@tf_export(v1=['debugging.assert_less', 'assert_less'])

def assert_less(x, y, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x < y` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_less(x, y)]):

output = tf.reduce_sum(x)

```

This condition holds if for every pair of (possibly broadcast) elements

`x[i]`, `y[i]`, we have `x[i] < y[i]`.

If both `x` and `y` are empty, this is trivially satisfied.

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 "assert_less".

Returns:

Op that raises `InvalidArgumentError` if `x < y` is False.

"""

message = message or ''

with ops.name_scope(name, 'assert_less', [x, y, data]):

x = ops.convert_to_tensor(x, name='x')

y = ops.convert_to_tensor(y, name='y')

if context.executing_eagerly():

x_name = _shape_and_dtype_str(x)

y_name = _shape_and_dtype_str(y)

else:

x_name = x.name

y_name = y.name

if data is None:

data = [

message,

'Condition x < y did not hold element-wise:',

'x (%s) = ' % x_name, x, 'y (%s) = ' % y_name, y

]

condition = math_ops.reduce_all(math_ops.less(x, y))

return control_flow_ops.Assert(condition, data, summarize=summarize)

@tf_export('debugging.assert_less_equal', v1=[])

def assert_less_equal_v2(x, y, message=None, summarize=None, name=None):

"""Assert the condition `x <= y` holds element-wise.

This Op checks that `x[i] <= 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` is not less or equal than `y` element-wise, `message`, as well as the

first `summarize` entries of `x` and `y` are printed, and

`InvalidArgumentError` is raised.

Args:

x: Numeric `Tensor`.

y: Numeric `Tensor`, same dtype as and broadcastable to `x`.

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_less_equal".

Returns:

Op that raises `InvalidArgumentError` if `x <= 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.

"""

return assert_less_equal(x=x, y=y,

summarize=summarize, message=message, name=name)

@tf_export(v1=['debugging.assert_less_equal', 'assert_less_equal'])

@deprecation.deprecated_endpoints('assert_less_equal')

def assert_less_equal(x, y, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x <= y` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_less_equal(x, y)]):

output = tf.reduce_sum(x)

```

This condition holds if for every pair of (possibly broadcast) elements

`x[i]`, `y[i]`, we have `x[i] <= y[i]`.

If both `x` and `y` are empty, this is trivially satisfied.

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 "assert_less_equal"

Returns:

Op that raises `InvalidArgumentError` if `x <= y` is False.

"""

message = message or ''

with ops.name_scope(name, 'assert_less_equal', [x, y, data]):

x = ops.convert_to_tensor(x, name='x')

y = ops.convert_to_tensor(y, name='y')

if context.executing_eagerly():

x_name = _shape_and_dtype_str(x)

y_name = _shape_and_dtype_str(y)

else:

x_name = x.name

y_name = y.name

if data is None:

data = [

message,

'Condition x <= y did not hold element-wise:'

'x (%s) = ' % x_name, x, 'y (%s) = ' % y_name, y

]

condition = math_ops.reduce_all(math_ops.less_equal(x, y))

return control_flow_ops.Assert(condition, data, summarize=summarize)

@tf_export('debugging.assert_greater', 'assert_greater', v1=[])

def assert_greater_v2(x, y, message=None, summarize=None, name=None):

"""Assert the condition `x > y` holds element-wise.

This Op checks that `x[i] > 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` is not greater than `y` element-wise, `message`, as well as the first

`summarize` entries of `x` and `y` are printed, and `InvalidArgumentError` is

raised.

Args:

x: Numeric `Tensor`.

y: Numeric `Tensor`, same dtype as and broadcastable to `x`.

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_greater".

Returns:

Op that raises `InvalidArgumentError` if `x > 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.

"""

return assert_greater(x=x, y=y, summarize=summarize, message=message,

name=name)

@tf_export(v1=['debugging.assert_greater', 'assert_greater'])

def assert_greater(x, y, data=None, summarize=None, message=None, name=None):

"""Assert the condition `x > y` holds element-wise.

Example of adding a dependency to an operation:

```python

with tf.control_dependencies([tf.compat.v1.assert_greater(x, y)]):

output = tf.reduce_sum(x)

```