add TensorPartialUpdate with add/modify/remove

6 files changed, 353 insertions, 0 deletions

diff --git a/eval/src/tests/tensor/partial_add/CMakeLists.txt b/eval/src/tests/tensor/partial_add/CMakeLists.txt
new file mode 100644
index 00000000000..f0d07a8e9cf
--- /dev/null
+++ b/eval/src/tests/tensor/partial_add/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+vespa_add_executable(eval_partial_add_test_app TEST
+    SOURCES
+    partial_add_test.cpp
+    DEPENDS
+    vespaeval
+    GTest::GTest
+)
+vespa_add_test(NAME eval_partial_add_test_app COMMAND eval_partial_add_test_app)
diff --git a/eval/src/tests/tensor/partial_add/partial_add_test.cpp b/eval/src/tests/tensor/partial_add/partial_add_test.cpp
new file mode 100644
index 00000000000..f31df131345
--- /dev/null
+++ b/eval/src/tests/tensor/partial_add/partial_add_test.cpp
@@ -0,0 +1,98 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/test/tensor_model.hpp>
+#include <vespa/eval/eval/value_codec.h>
+#include <vespa/eval/tensor/cell_values.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
+#include <vespa/eval/tensor/partial_update.h>
+#include <vespa/eval/tensor/sparse/sparse_tensor.h>
+#include <vespa/eval/tensor/tensor.h>
+#include <vespa/vespalib/util/stringfmt.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <optional>
+
+using namespace vespalib;
+using namespace vespalib::eval;
+using namespace vespalib::eval::test;
+
+using vespalib::make_string_short::fmt;
+
+std::vector<Layout> add_layouts = {
+    {x({"a"})},                           {x({"b"})},
+    {x({"a","b"})},                       {x({"a","c"})},
+    float_cells({x({"a","b"})}),          {x({"a","c"})},
+    {x({"a","b"})},                       float_cells({x({"a","c"})}),
+    float_cells({x({"a","b"})}),          float_cells({x({"a","c"})}),
+    {x({"a","b","c"}),y({"d","e"})},      {x({"b","f"}),y({"d","g"})},             
+    {x(3),y({"a","b"})},                  {x(3),y({"b","c"})}
+};
+
+TensorSpec reference_add(const TensorSpec &a, const TensorSpec &b) {
+    TensorSpec result(a.type());
+    for (const auto &cell: b.cells()) {
+        result.add(cell.first, cell.second);
+    }
+    auto end_iter = b.cells().end();
+    for (const auto &cell: a.cells()) {
+        auto iter = b.cells().find(cell.first);
+        if (iter == end_iter) {
+            result.add(cell.first, cell.second);
+        }
+    }
+    return result;
+}
+
+TensorSpec perform_partial_add(const TensorSpec &a, const TensorSpec &b) {
+    const auto &factory = SimpleValueBuilderFactory::get();
+    auto lhs = value_from_spec(a, factory);
+    auto rhs = value_from_spec(b, factory);
+    auto up = tensor::TensorPartialUpdate::add(*lhs, *rhs, factory);
+    if (up) {
+        return spec_from_value(*up);
+    } else {
+        return TensorSpec(a.type());
+    }
+}
+
+TensorSpec perform_old_add(const TensorSpec &a, const TensorSpec &b) {
+    const auto &engine = tensor::DefaultTensorEngine::ref();
+    auto lhs = engine.from_spec(a);
+    auto rhs = engine.from_spec(b);
+    auto lhs_tensor = dynamic_cast<tensor::Tensor *>(lhs.get());
+    EXPECT_TRUE(lhs_tensor);
+    auto rhs_tensor = dynamic_cast<tensor::Tensor *>(rhs.get());
+    EXPECT_TRUE(rhs_tensor);
+    auto up = lhs_tensor->add(*rhs_tensor);
+    EXPECT_TRUE(up);
+    return engine.to_spec(*up);
+}
+
+
+TEST(PartialAddTest, partial_add_works_for_simple_values) {
+    ASSERT_TRUE((add_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < add_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(add_layouts[i], N());
+        TensorSpec rhs = spec(add_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        auto expect = reference_add(lhs, rhs);
+        auto actual = perform_partial_add(lhs, rhs);
+        EXPECT_EQ(actual, expect);
+    }
+}
+
+TEST(PartialAddTest, partial_add_works_like_old_add) {
+    ASSERT_TRUE((add_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < add_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(add_layouts[i], N());
+        TensorSpec rhs = spec(add_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        auto expect = perform_old_add(lhs, rhs);
+        auto actual = perform_partial_add(lhs, rhs);
+        EXPECT_EQ(actual, expect);
+        printf("%s add %s -> %s\n", lhs.to_string().c_str(), rhs.to_string().c_str(), actual.to_string().c_str());
+
+    }
+}
+
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/eval/src/tests/tensor/partial_modify/CMakeLists.txt b/eval/src/tests/tensor/partial_modify/CMakeLists.txt
new file mode 100644
index 00000000000..42a08acaae6
--- /dev/null
+++ b/eval/src/tests/tensor/partial_modify/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+vespa_add_executable(eval_partial_modify_test_app TEST
+    SOURCES
+    partial_modify_test.cpp
+    DEPENDS
+    vespaeval
+    GTest::GTest
+)
+vespa_add_test(NAME eval_partial_modify_test_app COMMAND eval_partial_modify_test_app)
diff --git a/eval/src/tests/tensor/partial_modify/partial_modify_test.cpp b/eval/src/tests/tensor/partial_modify/partial_modify_test.cpp
new file mode 100644
index 00000000000..a35c7597194
--- /dev/null
+++ b/eval/src/tests/tensor/partial_modify/partial_modify_test.cpp
@@ -0,0 +1,122 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/test/tensor_model.hpp>
+#include <vespa/eval/eval/value_codec.h>
+#include <vespa/eval/tensor/cell_values.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
+#include <vespa/eval/tensor/partial_update.h>
+#include <vespa/eval/tensor/sparse/sparse_tensor.h>
+#include <vespa/eval/tensor/tensor.h>
+#include <vespa/vespalib/util/stringfmt.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <optional>
+
+using namespace vespalib;
+using namespace vespalib::eval;
+using namespace vespalib::eval::test;
+
+using vespalib::make_string_short::fmt;
+
+std::vector<Layout> modify_layouts = {
+    {x({"a"})},                           {x({"a"})},
+    {x({"a",""})},                        {x({"b","c","d","e"})},
+    {x(5)},                               {x({"1","2","foo","17"})},
+    {x({"a","b","c"}),y({"d","e"})},      {x({"b"}),y({"d"})},             
+    {x({"a","b","c"})},                   {x({"b","c","d"})},
+    {x(3),y(2)},                          {x({"0","1"}),y({"0","1"})},
+    {x({"a","","b"})},                    {x({""})}
+};
+
+TensorSpec::Address sparsify(const TensorSpec::Address &input) {
+    TensorSpec::Address output;
+    for (const auto & kv : input) {
+        if (kv.second.is_indexed()) {
+            auto val = fmt("%zu", kv.second.index);
+            output.emplace(kv.first, val);
+        } else {
+            output.emplace(kv.first, kv.second);
+        }
+    }
+    return output;
+}
+
+TensorSpec reference_modify(const TensorSpec &a, const TensorSpec &b, join_fun_t fun) {
+    TensorSpec result(a.type());
+    auto end_iter = b.cells().end();
+    for (const auto &cell: a.cells()) {
+        double v = cell.second;
+        auto sparse_addr = sparsify(cell.first);
+        auto iter = b.cells().find(sparse_addr);
+        if (iter == end_iter) {
+            result.add(cell.first, v);
+        } else {
+            result.add(cell.first, fun(v, iter->second));
+        }
+    }
+    return result;
+}
+
+TensorSpec perform_partial_modify(const TensorSpec &a, const TensorSpec &b, join_fun_t fun) {
+    const auto &factory = SimpleValueBuilderFactory::get();
+    auto lhs = value_from_spec(a, factory);
+    auto rhs = value_from_spec(b, factory);
+    auto up = tensor::TensorPartialUpdate::modify(*lhs, fun, *rhs, factory);
+    if (up) {
+        return spec_from_value(*up);
+    } else {
+        return TensorSpec(a.type());
+    }
+}
+
+TensorSpec perform_old_modify(const TensorSpec &a, const TensorSpec &b, join_fun_t fun) {
+    const auto &engine = tensor::DefaultTensorEngine::ref();
+    auto lhs = engine.from_spec(a);
+    auto rhs = engine.from_spec(b);
+    auto lhs_tensor = dynamic_cast<tensor::Tensor *>(lhs.get());
+    EXPECT_TRUE(lhs_tensor);
+    auto rhs_sparse = dynamic_cast<tensor::SparseTensor *>(rhs.get());
+    EXPECT_TRUE(rhs_sparse);
+    tensor::CellValues cell_values(*rhs_sparse);
+    auto up = lhs_tensor->modify(fun, cell_values);
+    EXPECT_TRUE(up);
+    return engine.to_spec(*up);
+}
+
+
+TEST(PartialModifyTest, partial_modify_works_for_simple_values) {
+    ASSERT_TRUE((modify_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < modify_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(modify_layouts[i], N());
+        TensorSpec rhs = spec(modify_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        for (auto fun: {operation::Add::f, operation::Mul::f, operation::Sub::f}) {
+            auto expect = reference_modify(lhs, rhs, fun);
+            auto actual = perform_partial_modify(lhs, rhs, fun);
+            EXPECT_EQ(actual, expect);
+        }
+        auto fun = [](double, double keep) { return keep; };
+        auto expect = reference_modify(lhs, rhs, fun);
+        auto actual = perform_partial_modify(lhs, rhs, fun);
+        EXPECT_EQ(actual, expect);
+    }
+}
+
+TEST(PartialModifyTest, partial_modify_works_like_old_modify) {
+    ASSERT_TRUE((modify_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < modify_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(modify_layouts[i], N());
+        TensorSpec rhs = spec(modify_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        for (auto fun: {operation::Add::f, operation::Mul::f, operation::Sub::f}) {
+            auto expect = perform_old_modify(lhs, rhs, fun);
+            auto actual = perform_partial_modify(lhs, rhs, fun);
+            EXPECT_EQ(actual, expect);
+            if (fun == operation::Max::f) {
+                printf("%s modify(sub) %s -> %s\n", lhs.to_string().c_str(), rhs.to_string().c_str(), actual.to_string().c_str());
+            }
+        }
+    }
+}
+
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/eval/src/tests/tensor/partial_remove/CMakeLists.txt b/eval/src/tests/tensor/partial_remove/CMakeLists.txt
new file mode 100644
index 00000000000..1680324f574
--- /dev/null
+++ b/eval/src/tests/tensor/partial_remove/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+vespa_add_executable(eval_partial_remove_test_app TEST
+    SOURCES
+    partial_remove_test.cpp
+    DEPENDS
+    vespaeval
+    GTest::GTest
+)
+vespa_add_test(NAME eval_partial_remove_test_app COMMAND eval_partial_remove_test_app)
diff --git a/eval/src/tests/tensor/partial_remove/partial_remove_test.cpp b/eval/src/tests/tensor/partial_remove/partial_remove_test.cpp
new file mode 100644
index 00000000000..7fb46790415
--- /dev/null
+++ b/eval/src/tests/tensor/partial_remove/partial_remove_test.cpp
@@ -0,0 +1,106 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/test/tensor_model.hpp>
+#include <vespa/eval/eval/value_codec.h>
+#include <vespa/eval/tensor/cell_values.h>
+#include <vespa/eval/tensor/default_tensor_engine.h>
+#include <vespa/eval/tensor/partial_update.h>
+#include <vespa/eval/tensor/sparse/sparse_tensor.h>
+#include <vespa/eval/tensor/tensor.h>
+#include <vespa/vespalib/util/stringfmt.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <optional>
+
+using namespace vespalib;
+using namespace vespalib::eval;
+using namespace vespalib::eval::test;
+
+using vespalib::make_string_short::fmt;
+
+std::vector<Layout> remove_layouts = {
+    {x({"a"})},                           {x({"b"})},
+    {x({"a","b"})},                       {x({"a","c"})},
+    float_cells({x({"a","b"})}),          {x({"a","c"})},
+    {x({"a","b"})},                       float_cells({x({"a","c"})}),
+    float_cells({x({"a","b"})}),          float_cells({x({"a","c"})}),
+    {x({"a","b","c"}),y({"d","e"})},      {x({"b","f"}),y({"d","g"})},             
+    {x(3),y({"a","b"})},                  {y({"b","c"})}
+};
+
+TensorSpec::Address only_sparse(const TensorSpec::Address &input) {
+    TensorSpec::Address output;
+    for (const auto & kv : input) {
+        if (kv.second.is_mapped()) {
+            output.emplace(kv.first, kv.second);
+        }
+    }
+    return output;
+}
+
+TensorSpec reference_remove(const TensorSpec &a, const TensorSpec &b) {
+    TensorSpec result(a.type());
+    auto end_iter = b.cells().end();
+    for (const auto &cell: a.cells()) {
+        auto iter = b.cells().find(only_sparse(cell.first));
+        if (iter == end_iter) {
+            result.add(cell.first, cell.second);
+        }
+    }
+    return result;
+}
+
+TensorSpec perform_partial_remove(const TensorSpec &a, const TensorSpec &b) {
+    const auto &factory = SimpleValueBuilderFactory::get();
+    auto lhs = value_from_spec(a, factory);
+    auto rhs = value_from_spec(b, factory);
+    auto up = tensor::TensorPartialUpdate::remove(*lhs, *rhs, factory);
+    if (up) {
+        return spec_from_value(*up);
+    } else {
+        return TensorSpec(a.type());
+    }
+}
+
+TensorSpec perform_old_remove(const TensorSpec &a, const TensorSpec &b) {
+    const auto &engine = tensor::DefaultTensorEngine::ref();
+    auto lhs = engine.from_spec(a);
+    auto rhs = engine.from_spec(b);
+    auto lhs_tensor = dynamic_cast<tensor::Tensor *>(lhs.get());
+    EXPECT_TRUE(lhs_tensor);
+    auto rhs_sparse = dynamic_cast<tensor::SparseTensor *>(rhs.get());
+    EXPECT_TRUE(rhs_sparse);
+    tensor::CellValues cell_values(*rhs_sparse);
+    auto up = lhs_tensor->remove(cell_values);
+    EXPECT_TRUE(up);
+    return engine.to_spec(*up);
+}
+
+
+TEST(PartialAddTest, partial_remove_works_for_simple_values) {
+    ASSERT_TRUE((remove_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < remove_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(remove_layouts[i], N());
+        TensorSpec rhs = spec(remove_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        auto expect = reference_remove(lhs, rhs);
+        auto actual = perform_partial_remove(lhs, rhs);
+        EXPECT_EQ(actual, expect);
+    }
+}
+
+TEST(PartialAddTest, partial_remove_works_like_old_remove) {
+    ASSERT_TRUE((remove_layouts.size() % 2) == 0);
+    for (size_t i = 0; i < remove_layouts.size(); i += 2) {
+        TensorSpec lhs = spec(remove_layouts[i], N());
+        TensorSpec rhs = spec(remove_layouts[i + 1], Div16(N()));
+        SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
+        auto expect = perform_old_remove(lhs, rhs);
+        auto actual = perform_partial_remove(lhs, rhs);
+        EXPECT_EQ(actual, expect);
+        // printf("%s remove %s -> %s\n", lhs.to_string().c_str(), rhs.to_string().c_str(), actual.to_string().c_str());
+
+    }
+}
+
+GTEST_MAIN_RUN_ALL_TESTS()