ADD: Inequality based asserts and tests.

* is_strictly_increasing(x)
* is_non_decreasing(x)
* assert_positive(x)
* assert_non_negative(x)
* assert_negative(x)
* assert_non_positive(x)
* assert_less(x, y)
* assert_less_equal(x, y)
Change: 118992401

Author: A. Unique TensorFlower

tensorflow/contrib/framework/__init__.py

@@ -14,9 +14,17 @@
 # ==============================================================================
 """Framework utilities.
 
+@@assert_negative
+@@assert_positive
+@@assert_non_negative
+@@assert_non_positive
+@@assert_less
+@@assert_less_equal
 @@assert_same_float_dtype
-@@is_numeric_tensor
 @@assert_scalar_int
+@@is_numeric_tensor
+@@is_non_decreasing
+@@is_strictly_increasing
 @@local_variable
 @@reduce_sum_n
 @@with_shape

tensorflow/contrib/framework/python/framework/tensor_util.py

@@ -15,9 +15,17 @@
 
 """Tensor utility functions.
 
+@@assert_negative
+@@assert_positive
+@@assert_non_negative
+@@assert_non_positive
+@@assert_less
+@@assert_less_equal
 @@assert_same_float_dtype
-@@is_numeric_tensor
 @@assert_scalar_int
+@@is_numeric_tensor
+@@is_non_decreasing
+@@is_strictly_increasing
 @@local_variable
 @@reduce_sum_n
 @@with_shape
@@ -30,13 +38,18 @@
 from tensorflow.python.framework import dtypes
 from tensorflow.python.framework import ops
 from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_ops
 from tensorflow.python.ops import logging_ops
 from tensorflow.python.ops import math_ops
 from tensorflow.python.ops import variables
 
 __all__ = [
     'assert_same_float_dtype', 'is_numeric_tensor', 'assert_scalar_int',
-    'local_variable', 'reduce_sum_n', 'with_shape', 'with_same_shape']
+    'local_variable', 'reduce_sum_n', 'with_shape', 'with_same_shape',
+    'assert_positive', 'assert_negative', 'assert_non_positive',
+    'assert_non_negative', 'assert_less', 'assert_less_equal',
+    'is_strictly_increasing', 'is_non_decreasing',
+]
 
 
 NUMERIC_TYPES = frozenset([dtypes.float32, dtypes.float64, dtypes.int8,
@@ -45,8 +58,229 @@
                            dtypes.quint8, dtypes.complex64])
 
 
-def is_numeric_tensor(tensor):
-  return isinstance(tensor, ops.Tensor) and tensor.dtype in NUMERIC_TYPES
+def assert_negative(x, data=None, summarize=None, name=None):
+  """Assert the condition `x < 0` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).  Defaults to "assert_negative".
+
+  Returns:
+    Op raising `InvalidArgumentError` unless `x` is all negative.
+  """
+  with ops.op_scope([x, data], name, 'assert_negative'):
+    x = ops.convert_to_tensor(x, name='x')
+    if data is None:
+      data = ['Condition x < 0 did not hold element-wise: x = ', x.name, x]
+    zero = ops.convert_to_tensor(0, dtype=x.dtype)
+    return assert_less(x, zero, data=data, summarize=summarize)
+
+
+def assert_positive(x, data=None, summarize=None, name=None):
+  """Assert the condition `x > 0` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).  Defaults to "assert_negative".
+
+  Returns:
+    Op raising `InvalidArgumentError` unless `x` is all positive.
+  """
+  with ops.op_scope([x, data], name, 'assert_positive'):
+    x = ops.convert_to_tensor(x, name='x')
+    if data is None:
+      data = ['Condition x > 0 did not hold element-wise: x = ', x.name, x]
+    zero = ops.convert_to_tensor(0, dtype=x.dtype)
+    return assert_less(zero, x, data=data, summarize=summarize)
+
+
+def assert_non_negative(x, data=None, summarize=None, name=None):
+  """Assert the condition `x >= 0` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).
+      Defaults to "assert_non_negative".
+
+  Returns:
+    Op raising `InvalidArgumentError` unless `x` is all non-negative.
+  """
+  with ops.op_scope([x, data], name, 'assert_non_negative'):
+    x = ops.convert_to_tensor(x, name='x')
+    if data is None:
+      data = ['Condition x >= 0 did not hold element-wise: x = ', x.name, x]
+    zero = ops.convert_to_tensor(0, dtype=x.dtype)
+    return assert_less_equal(zero, x, data=data, summarize=summarize)
+
+
+def assert_non_positive(x, data=None, summarize=None, name=None):
+  """Assert the condition `x <= 0` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).
+      Defaults to "assert_non_positive".
+
+  Returns:
+    Op raising `InvalidArgumentError` unless `x` is all non-positive.
+  """
+  with ops.op_scope([x, data], name, 'assert_non_positive'):
+    x = ops.convert_to_tensor(x, name='x')
+    if data is None:
+      data = ['Condition x <= 0 did not hold element-wise: x = ', x.name, x]
+    zero = ops.convert_to_tensor(0, dtype=x.dtype)
+    return assert_less_equal(x, zero, data=data, summarize=summarize)
+
+
+def assert_less(x, y, data=None, summarize=None, name=None):
+  """Assert the condition `x < y` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).  Defaults to "assert_less".
+
+  Returns:
+    Op that raises `InvalidArgumentError` if `x < y` is False.
+  """
+  with ops.op_scope([x, y, data], name, 'assert_less'):
+    x = ops.convert_to_tensor(x, name='x')
+    y = ops.convert_to_tensor(y, name='y')
+    if data is None:
+      data = [
+          'Condition x < y did not hold element-wise: x = ',
+          x.name, x, 'y = ', y.name, y]
+    condition = math_ops.reduce_all(math_ops.less(x, y))
+    return logging_ops.Assert(condition, data, summarize=summarize)
+
+
+def assert_less_equal(x, y, data=None, summarize=None, name=None):
+  """Assert the condition `x <= y` holds element-wise.
+
+  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.
+    name: A name for this operation (optional).  Defaults to "assert_less_equal"
+
+  Returns:
+    Op that raises `InvalidArgumentError` if `x <= y` is False.
+  """
+  with ops.op_scope([x, y, data], name, 'assert_less_equal'):
+    x = ops.convert_to_tensor(x, name='x')
+    y = ops.convert_to_tensor(y, name='y')
+    if data is None:
+      data = [
+          'Condition x <= y did not hold element-wise: x = ',
+          x.name, x, 'y = ', y.name, y]
+    condition = math_ops.reduce_all(math_ops.less_equal(x, y))
+    return logging_ops.Assert(condition, data, summarize=summarize)
+
+
+def _get_diff_for_monotonic_comparison(x):
+  """Gets the difference x[1:] - x[:-1]."""
+  x = array_ops.reshape(x, [-1])
+  if not is_numeric_tensor(x):
+    raise ValueError('Expected x to be numeric, instead found: %s' % x)
+
+  # If x has less than 2 elements, there is nothing to compare.  So return [].
+  is_shorter_than_two = math_ops.less(array_ops.size(x), 2)
+  short_result = lambda: ops.convert_to_tensor([], dtype=x.dtype)
+
+  # With 2 or more elements, return x[1:] - x[:-1]
+  s_len = array_ops.shape(x) - 1
+  diff = lambda: array_ops.slice(x, [1], s_len) - array_ops.slice(x, [0], s_len)
+  return control_flow_ops.cond(is_shorter_than_two, short_result, diff)
+
+
+def is_non_decreasing(x, name=None):
+  """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`
+
+  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:
+    ValueError: if `x` is not a numeric tensor.
+  """
+  with ops.op_scope([x], name, 'is_non_decreasing'):
+    diff = _get_diff_for_monotonic_comparison(x)
+    # When len(x) = 1, diff = [], less_equal = [], and reduce_all([]) = True.
+    zero = ops.convert_to_tensor(0, dtype=diff.dtype)
+    return math_ops.reduce_all(math_ops.less_equal(zero, diff))
+
+
+def is_strictly_increasing(x, name=None):
+  """Returns `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`
+
+  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:
+    ValueError: if `x` is not a numeric tensor.
+  """
+  with ops.op_scope([x], name, 'is_strictly_increasing'):
+    diff = _get_diff_for_monotonic_comparison(x)
+    # When len(x) = 1, diff = [], less = [], and reduce_all([]) = True.
+    zero = ops.convert_to_tensor(0, dtype=diff.dtype)
+    return math_ops.reduce_all(math_ops.less(zero, diff))
 
 
 def _assert_same_base_type(items, expected_type=None):
@@ -126,6 +360,10 @@ def assert_scalar_int(tensor):
   return tensor
 
 
+def is_numeric_tensor(tensor):
+  return isinstance(tensor, ops.Tensor) and tensor.dtype in NUMERIC_TYPES
+
+
 # TODO(ptucker): Move to tf.variables?
 def local_variable(initial_value, validate_shape=True, name=None):
   """Create variable and add it to `GraphKeys.LOCAL_VARIABLES` collection.