experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make sparse_to_dense_op_py_test v2 friendly

Browse Source 
* Change op runtime error string to match with graph construction.
* Remove session scopes
* Fix invalid argument tests to be eager friendly by constructing and
  evaluating in the same line.

PiperOrigin-RevId: 320693166
Change-Id: I42ee0c4a4e141074863a366aef55f9960f0ea806
This commit is contained in:
Gaurav Jain 2020-07-10 16:00:43 -07:00 committed by TensorFlower Gardener
parent f085449f2b
commit 1956f5ad87
3 changed files with 63 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tensorflow/core/kernels/sparse_to_dense_op.cc
View File

@ -63,7 +63,7 @@ class SparseToDense : public OpKernel {
const Tensor& output_shape = c->input(1);
OP_REQUIRES(
c, TensorShapeUtils::IsVector(output_shape.shape()),
errors::InvalidArgument("output_shape should be a vector, got shape ",
errors::InvalidArgument("output_shape must be rank 1, got shape ",
output_shape.shape().DebugString()));
OP_REQUIRES(c, output_shape.NumElements() == num_dims,
errors::InvalidArgument(

2
tensorflow/python/kernel_tests/scalar_test.py
View File

@ -136,7 +136,7 @@ class ScalarTest(test.TestCase):
def testSparseToDense(self):
self.check(sparse_ops.sparse_to_dense, (1, 4, 7),
'output_shape should be a vector', [0, 7, 0, 0])
'output_shape must be rank 1', [0, 7, 0, 0])
def testTile(self):
self.check(array_ops.tile, ([7], 2), 'Expected multiples to be 1-D', [7, 7])

183
tensorflow/python/kernel_tests/sparse_to_dense_op_py_test.py
View File

@ -21,179 +21,119 @@ from __future__ import print_function
import numpy as np
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import test_util
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import sparse_ops
from tensorflow.python.platform import test
def _SparseToDense(sparse_indices,
output_size,
sparse_values,
default_value,
validate_indices=True):
return sparse_ops.sparse_to_dense(
sparse_indices,
output_size,
sparse_values,
default_value=default_value,
validate_indices=validate_indices)
class SparseToDenseTest(test.TestCase):
@test_util.run_deprecated_v1
def testInt(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([1, 3], [5], 1, 0).eval()
tf_ans = sparse_ops.sparse_to_dense([1, 3], [5], 1, 0)
np_ans = np.array([0, 1, 0, 1, 0]).astype(np.int32)
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testFloat(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([1, 3], [5], 1.0, 0.0).eval()
tf_ans = sparse_ops.sparse_to_dense([1, 3], [5], 1.0, 0.0)
np_ans = np.array([0, 1, 0, 1, 0]).astype(np.float32)
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testString(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([1, 3], [5], "a", "b").eval()
tf_ans = sparse_ops.sparse_to_dense([1, 3], [5], "a", "b")
np_ans = np.array(["b", "a", "b", "a", "b"]).astype(np.string_)
self.assertAllEqual(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testSetValue(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([1, 3], [5], [1, 2], -1).eval()
tf_ans = sparse_ops.sparse_to_dense([1, 3], [5], [1, 2], -1)
np_ans = np.array([-1, 1, -1, 2, -1]).astype(np.int32)
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testSetSingleValue(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([1, 3], [5], 1, -1).eval()
tf_ans = sparse_ops.sparse_to_dense([1, 3], [5], 1, -1)
np_ans = np.array([-1, 1, -1, 1, -1]).astype(np.int32)
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def test2d(self):
# pylint: disable=bad-whitespace
with self.session(use_gpu=False):
tf_ans = _SparseToDense([[1, 3], [2, 0]], [3, 4], 1, -1).eval()
tf_ans = sparse_ops.sparse_to_dense([[1, 3], [2, 0]], [3, 4], 1, -1)
np_ans = np.array([[-1, -1, -1, -1],
[-1, -1, -1, 1],
[ 1, -1, -1, -1]]).astype(np.int32)
[-1, -1, -1, 1],
[1, -1, -1, -1]]).astype(np.int32)
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testZeroDefault(self):
with self.cached_session():
x = sparse_ops.sparse_to_dense(2, [4], 7).eval()
self.assertAllEqual(x, [0, 0, 7, 0])
x = sparse_ops.sparse_to_dense(2, [4], 7)
self.assertAllEqual(x, [0, 0, 7, 0])
@test_util.run_deprecated_v1
def test3d(self):
with self.session(use_gpu=False):
tf_ans = _SparseToDense([[1, 3, 0], [2, 0, 1]], [3, 4, 2], 1, -1).eval()
tf_ans = sparse_ops.sparse_to_dense([[1, 3, 0], [2, 0, 1]], [3, 4, 2], 1,
-1)
np_ans = np.ones((3, 4, 2), dtype=np.int32) * -1
np_ans[1, 3, 0] = 1
np_ans[2, 0, 1] = 1
self.assertAllClose(np_ans, tf_ans)
@test_util.run_deprecated_v1
def testBadShape(self):
with self.cached_session():
with self.assertRaisesWithPredicateMatch(ValueError, "must be rank 1"):
_SparseToDense([1, 3], [[5], [3]], 1, -1)
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
"must be rank 1"):
sparse_ops.sparse_to_dense([1, 3], [[5], [3]], 1, -1)
@test_util.run_deprecated_v1
def testBadValue(self):
with self.cached_session():
dense = _SparseToDense([1, 3], [5], [[5], [3]], -1)
with self.assertRaisesOpError(
r"sparse_values has incorrect shape \[2,1\], "
r"should be \[\] or \[2\]"):
self.evaluate(dense)
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
r"sparse_values has incorrect shape \[2,1\], "
r"should be \[\] or \[2\]"):
self.evaluate(sparse_ops.sparse_to_dense([1, 3], [5], [[5], [3]], -1))
@test_util.run_deprecated_v1
def testBadNumValues(self):
with self.cached_session():
dense = _SparseToDense([1, 3], [5], [1, 2, 3], -1)
with self.assertRaisesOpError(
r"sparse_values has incorrect shape \[3\], should be \[\] or \[2\]"):
self.evaluate(dense)
with self.assertRaisesRegex(
(ValueError, errors.InvalidArgumentError),
r"sparse_values has incorrect shape \[3\], should be \[\] or \[2\]"):
self.evaluate(sparse_ops.sparse_to_dense([1, 3], [5], [1, 2, 3], -1))
@test_util.run_deprecated_v1
def testBadDefault(self):
with self.cached_session():
dense = _SparseToDense([1, 3], [5], [1, 2], [0])
with self.assertRaisesOpError("default_value should be a scalar"):
self.evaluate(dense)
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
"default_value should be a scalar"):
self.evaluate(sparse_ops.sparse_to_dense([1, 3], [5], [1, 2], [0]))
@test_util.run_deprecated_v1
def testOutOfBoundsIndicesWithWithoutValidation(self):
with self.cached_session():
dense = _SparseToDense(
sparse_indices=[[1], [10]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0)
with self.assertRaisesOpError(
r"indices\[1\] = \[10\] is out of bounds: need 0 <= index < \[5\]"):
self.evaluate(dense)
# Disable checks, the allocation should still fail.
with self.assertRaisesOpError("out of bounds"):
dense_without_validation = _SparseToDense(
sparse_indices=[[1], [10]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0,
validate_indices=False)
self.evaluate(dense_without_validation)
with self.assertRaisesRegex(
(ValueError, errors.InvalidArgumentError),
r"indices\[1\] = \[10\] is out of bounds: need 0 <= index < \[5\]"):
self.evaluate(
sparse_ops.sparse_to_dense([[1], [10]], [5], [1.0, 1.0], 0.0))
# Disable checks, the allocation should still fail.
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
"out of bounds"):
self.evaluate(
sparse_ops.sparse_to_dense([[1], [10]], [5], [-1.0, 1.0],
0.0,
validate_indices=False))
@test_util.run_deprecated_v1
def testRepeatingIndicesWithWithoutValidation(self):
with self.cached_session():
dense = _SparseToDense(
sparse_indices=[[1], [1]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0)
with self.assertRaisesOpError(r"indices\[1\] = \[1\] is repeated"):
self.evaluate(dense)
# Disable checks
dense_without_validation = _SparseToDense(
sparse_indices=[[1], [1]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0,
validate_indices=False)
self.evaluate(dense_without_validation)
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
r"indices\[1\] = \[1\] is repeated"):
self.evaluate(
sparse_ops.sparse_to_dense([[1], [1]], [5], [-1.0, 1.0], 0.0))
# Disable checks
self.evaluate(
sparse_ops.sparse_to_dense([[1], [1]], [5], [-1.0, 1.0],
0.0,
validate_indices=False))
@test_util.run_deprecated_v1
def testUnsortedIndicesWithWithoutValidation(self):
with self.cached_session():
dense = _SparseToDense(
sparse_indices=[[2], [1]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0)
with self.assertRaisesOpError(r"indices\[1\] = \[1\] is out of order"):
self.evaluate(dense)
# Disable checks
dense_without_validation = _SparseToDense(
sparse_indices=[[2], [1]],
output_size=[5],
sparse_values=[-1.0, 1.0],
default_value=0.0,
validate_indices=False)
self.evaluate(dense_without_validation)
with self.assertRaisesRegex((ValueError, errors.InvalidArgumentError),
r"indices\[1\] = \[1\] is out of order"):
self.evaluate(
sparse_ops.sparse_to_dense([[2], [1]], [5], [-1.0, 1.0], 0.0))
# Disable checks
self.evaluate(
sparse_ops.sparse_to_dense([[2], [1]], [5], [-1.0, 1.0],
0.0,
validate_indices=False))
@test_util.run_deprecated_v1
def testShapeInferenceKnownShape(self):
with self.session(use_gpu=False):
with ops.Graph().as_default():
indices = array_ops.placeholder(dtypes.int64)
shape = [4, 5, 6]
@ -204,13 +144,12 @@ class SparseToDenseTest(test.TestCase):
output = sparse_ops.sparse_to_dense(indices, shape, 1, 0)
self.assertEqual(output.get_shape().as_list(), [None, None, None])
@test_util.run_deprecated_v1
def testShapeInferenceUnknownShape(self):
with self.session(use_gpu=False):
with ops.Graph().as_default():
indices = array_ops.placeholder(dtypes.int64)
shape = array_ops.placeholder(dtypes.int64)
output = sparse_ops.sparse_to_dense(indices, shape, 1, 0)
self.assertEqual(output.get_shape().ndims, None)
self.assertIsNone(output.get_shape().ndims)
if __name__ == "__main__":