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]])