def test_calculate_tree_root_direct(self):
"""Calculates the value of a tree with no sources."""
for options in options_to_test:
tree = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
[new_expr] = calculate.calculate_prensors([tree], options=options)
self.assertAllEqual(new_expr.node.size, 3)
def test_get_sparse_tensor(self):
expression = prensor_test_util.create_simple_prensor()
sparse_tensor = prensor._get_sparse_tensor(expression,
path.create_path("foo"))
self.assertAllEqual(sparse_tensor.indices, [[0], [1], [2]])
self.assertAllEqual(sparse_tensor.dense_shape, [3])
self.assertAllEqual(sparse_tensor.values, [9, 8, 7])
def test_prensor_to_sparse_tensor(self):
for options in _OPTIONS_TO_TEST:
pren = prensor_test_util.create_simple_prensor()
sparse_tensor = pren.get_sparse_tensor(path.create_path("foo"),
options=options)
self.assertAllEqual(sparse_tensor.indices, [[0], [1], [2]])
self.assertAllEqual(sparse_tensor.dense_shape, [3])
self.assertAllEqual(sparse_tensor.values, [9, 8, 7])
def test_calculate_root_indirect(self):
"""Calculates the value of a node with one source."""
for options in options_to_test:
tree = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
tree_2 = expression_add.add_paths(tree, {})
[root_value] = calculate.calculate_values([tree_2], options=options)
self.assertAllEqual(root_value.size, 3)
def test_calculate_tree_root_direct(self):
"""Calculates the value of a tree with no sources."""
for options in options_to_test:
with self.session(use_gpu=False) as sess:
tree = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
[new_expr] = calculate.calculate_prensors([tree],
options=options)
size_result = sess.run(new_expr.node.size)
self.assertAllEqual(size_result, 3)
def _test_runner(options):
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_sparse_tensor(expr, path.Path([]),
[path.Path(["foo"])],
lambda x: x * 2, True,
tf.int32, "foo_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(path.Path(["foo_doubled"])),
options=options)
self.evaluate(leaf_node.parent_index)
self.evaluate(leaf_node.values)
def test_map_values_anonymous(self):
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root, p = map_values.map_values_anonymous(expr, path.Path(["foo"]),
lambda x: x * 2,
tf.int64)
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(p))
self.assertAllEqual(leaf_node.parent_index, [0, 1, 2])
self.assertAllEqual(leaf_node.values, [18, 16, 14])
def test_map_field_values_test(self):
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = expr.map_field_values("foo", lambda x: x * 2, tf.int64,
"foo_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(path.Path(["foo_doubled"])))
self.assertAllEqual(leaf_node.parent_index, [0, 1, 2])
self.assertAllEqual(leaf_node.values, [18, 16, 14])
def test_map_sparse_tensor(self):
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_sparse_tensor(expr, path.Path([]),
[path.Path(["foo"])],
lambda x: x * 2, False,
tf.int32, "foo_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(path.Path(["foo_doubled"])))
self.assertAllEqual(leaf_node.parent_index, [0, 1, 2])
self.assertAllEqual(leaf_node.values, [18, 16, 14])
def _test_runner(options):
with self.session(use_gpu=False) as sess:
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_sparse_tensor(
expr, path.Path([]), [path.Path(["foorepeated"])],
lambda x: x * 2, False, tf.int32, "foorepeated_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(
path.Path(["foorepeated_doubled"])),
options=options)
sess.run([leaf_node.parent_index, leaf_node.values])
def test_root_methods(self):
"""Test all the basic operations on the root of a prensor expression."""
expression = prensor_test_util.create_simple_prensor()
expr = create_expression.create_expression_from_prensor(expression)
self.assertTrue(expr.is_repeated)
self.assertIsNone(expr.type)
self.assertFalse(expr.is_leaf)
self.assertEqual(expr.get_source_expressions(), [])
self.assertFalse(expr.calculation_is_identity())
self.assertTrue(expr.calculation_equal(expr))
root_node = expression_test_util.calculate_value_slowly(expr)
self.assertEqual(root_node.size.dtype, tf.int64)
self.assertEqual(expr.known_field_names(), frozenset(["foo",
"foorepeated"]))
def test_get_sparse_tensors_simple_dense(self):
"""Tests get_sparse_tensors on a deep expression."""
for options in _OPTIONS_TO_TEST:
expression = prensor_test_util.create_simple_prensor()
sparse_tensor_map = prensor._get_sparse_tensors(
expression, options)
string_tensor_map = {
str(k): tf.sparse.to_dense(v)
for k, v in sparse_tensor_map.items()
}
self.assertAllEqual(string_tensor_map["foo"], [9, 8, 7])
self.assertAllEqual(string_tensor_map["foorepeated"],
[[9, 0], [8, 7], [6, 0]])
def test_map_sparse_tensor_is_repeated(self):
for options in options_to_test:
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_sparse_tensor(
expr, path.Path([]), [path.Path(["foorepeated"])],
lambda x: x * 2, True, tf.int32, "foorepeated_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(
path.Path(["foorepeated_doubled"])),
options=options)
self.assertAllEqual(leaf_node.parent_index, [0, 1, 1, 2])
self.assertAllEqual(leaf_node.values, [18, 16, 14, 12])
def test_foorepeated_node(self):
"""Test all the basic operations an repeated leaf of an expression."""
expression = prensor_test_util.create_simple_prensor()
expr = create_expression.create_expression_from_prensor(expression)
foorepeated_expr = expr.get_child_or_error("foorepeated")
self.assertTrue(foorepeated_expr.is_repeated)
self.assertEqual(foorepeated_expr.type, tf.int32)
self.assertTrue(foorepeated_expr.is_leaf)
self.assertEqual(foorepeated_expr.get_source_expressions(), [])
self.assertFalse(foorepeated_expr.calculation_is_identity())
self.assertTrue(foorepeated_expr.calculation_equal(foorepeated_expr))
self.assertFalse(foorepeated_expr.calculation_equal(expr))
leaf_node = expression_test_util.calculate_value_slowly(foorepeated_expr)
self.assertEqual(leaf_node.values.dtype, tf.int32)
self.assertEqual(foorepeated_expr.known_field_names(), frozenset())
def test_map_ragged_tensor_repeated(self):
for options in options_to_test:
with self.session(use_gpu=False) as sess:
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_ragged_tensor(
expr, path.Path([]), [path.Path(["foorepeated"])],
lambda x: x * 2, False, tf.int32, "foorepeated_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(
path.Path(["foorepeated_doubled"])),
options=options)
[parent_index,
values] = sess.run([leaf_node.parent_index, leaf_node.values])
self.assertAllEqual(parent_index, [0, 1, 1, 2])
self.assertAllEqual(values, [18, 16, 14, 12])
def test_skip_eager_map_ragged_tensor_repeated(self):
# This fails in eager, with an inconsistency in the ragged tensor.
if tf.executing_eagerly():
return
for options in options_to_test:
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_prensor.map_ragged_tensor(
expr, path.Path([]), [path.Path(["foorepeated"])],
lambda x: x * 2, False, tf.int32, "foorepeated_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(
path.Path(["foorepeated_doubled"])),
options=options)
self.assertAllEqual(leaf_node.parent_index, [0, 1, 1, 2])
self.assertAllEqual(leaf_node.values, [18, 16, 14, 12])
def test_get_sparse_tensors_simple_dense(self):
"""Tests get_sparse_tensors on a deep expression."""
for options in options_to_test:
with self.session(use_gpu=False) as sess:
expression = prensor_test_util.create_simple_prensor()
sparse_tensor_map = prensor_util.get_sparse_tensors(
expression, options)
string_tensor_map = {
str(k): tf.sparse_tensor_to_dense(v)
for k, v in sparse_tensor_map.items()
}
string_np_map = sess.run(string_tensor_map)
self.assertAllEqual(string_np_map["foo"], [9, 8, 7])
self.assertAllEqual(string_np_map["foorepeated"],
[[9, 0], [8, 7], [6, 0]])
def test_map_values(self):
with self.session(use_gpu=False) as sess:
expr = create_expression.create_expression_from_prensor(
prensor_test_util.create_simple_prensor())
new_root = map_values.map_values(expr, path.Path(["foo"]),
lambda x: x * 2, tf.int64,
"foo_doubled")
leaf_node = expression_test_util.calculate_value_slowly(
new_root.get_descendant_or_error(path.Path(["foo_doubled"])))
[parent_index,
values] = sess.run([leaf_node.parent_index, leaf_node.values])
self.assertAllEqual(parent_index, [0, 1, 2])
self.assertAllEqual(values, [18, 16, 14])
def test_get_sparse_tensors_simple(self):
"""Tests get_sparse_tensors on a deep expression."""
for options in _OPTIONS_TO_TEST:
expression = prensor_test_util.create_simple_prensor()
sparse_tensor_map = prensor._get_sparse_tensors(
expression, options)
string_tensor_map = {
str(k): v
for k, v in sparse_tensor_map.items()
}
self.assertAllEqual(string_tensor_map["foo"].indices,
[[0], [1], [2]])
self.assertAllEqual(string_tensor_map["foo"].dense_shape, [3])
self.assertAllEqual(string_tensor_map["foo"].values, [9, 8, 7])
self.assertAllEqual(string_tensor_map["foorepeated"].indices,
[[0, 0], [1, 0], [1, 1], [2, 0]])
self.assertAllEqual(string_tensor_map["foorepeated"].values,
[9, 8, 7, 6])
self.assertAllEqual(string_tensor_map["foorepeated"].dense_shape,
[3, 2])
def test_get_sparse_tensors_simple(self):
"""Tests get_sparse_tensors on a deep expression."""
for options in options_to_test:
with self.session(use_gpu=False) as sess:
expression = prensor_test_util.create_simple_prensor()
sparse_tensor_map = prensor_util.get_sparse_tensors(
expression, options)
string_tensor_map = {
str(k): v
for k, v in sparse_tensor_map.items()
}
string_np_map = sess.run(string_tensor_map)
self.assertAllEqual(string_np_map["foo"].indices,
[[0], [1], [2]])
self.assertAllEqual(string_np_map["foo"].dense_shape, [3])
self.assertAllEqual(string_np_map["foo"].values, [9, 8, 7])
self.assertAllEqual(string_np_map["foorepeated"].indices,
[[0, 0], [1, 0], [1, 1], [2, 0]])
self.assertAllEqual(string_np_map["foorepeated"].values,
[9, 8, 7, 6])
self.assertAllEqual(string_np_map["foorepeated"].dense_shape,
[3, 2])
def test_simple_prensor(self):
pren = prensor_test_util.create_simple_prensor()
st = prensor_to_structured_tensor.prensor_to_structured_tensor(pren)
self.assertAllEqual(st.field_value("foo"), [[9], [8], [7]])
self.assertAllEqual(st.field_value("foorepeated"), [[9], [8, 7], [6]])
