android10/frameworks/ml/nn/common/operations/HashtableLookupTest.cpp

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "HashtableLookup.h"

#include "NeuralNetworksWrapper.h"
#include "gmock/gmock-matchers.h"
#include "gtest/gtest.h"

using ::testing::FloatNear;
using ::testing::Matcher;

namespace android {
namespace nn {
namespace wrapper {

namespace {

std::vector<Matcher<float>> ArrayFloatNear(const std::vector<float>& values,
                                           float max_abs_error=1.e-6) {
  std::vector<Matcher<float>> matchers;
  matchers.reserve(values.size());
  for (const float& v : values) {
    matchers.emplace_back(FloatNear(v, max_abs_error));
  }
  return matchers;
}

}  // namespace

using ::testing::ElementsAreArray;

#define FOR_ALL_INPUT_AND_WEIGHT_TENSORS(ACTION)     \
  ACTION(Lookup, int)                                \
  ACTION(Key, int)                                   \
  ACTION(Value, float)

// For all output and intermediate states
#define FOR_ALL_OUTPUT_TENSORS(ACTION) \
  ACTION(Output, float)                \
  ACTION(Hits, uint8_t)

class HashtableLookupOpModel {
 public:
    HashtableLookupOpModel(std::initializer_list<uint32_t> lookup_shape,
                           std::initializer_list<uint32_t> key_shape,
                           std::initializer_list<uint32_t> value_shape) {
    auto it_vs = value_shape.begin();
    rows_ = *it_vs++;
    features_ = *it_vs;

    std::vector<uint32_t> inputs;

    // Input and weights
    OperandType LookupTy(Type::TENSOR_INT32, lookup_shape);
    inputs.push_back(model_.addOperand(&LookupTy));

    OperandType KeyTy(Type::TENSOR_INT32, key_shape);
    inputs.push_back(model_.addOperand(&KeyTy));

    OperandType ValueTy(Type::TENSOR_FLOAT32, value_shape);
    inputs.push_back(model_.addOperand(&ValueTy));

    // Output and other intermediate state
    std::vector<uint32_t> outputs;

    std::vector<uint32_t> out_dim(lookup_shape.begin(), lookup_shape.end());
    out_dim.push_back(features_);

    OperandType OutputOpndTy(Type::TENSOR_FLOAT32, out_dim);
    outputs.push_back(model_.addOperand(&OutputOpndTy));

    OperandType HitsOpndTy(Type::TENSOR_QUANT8_ASYMM, lookup_shape, 1.f, 0);
    outputs.push_back(model_.addOperand(&HitsOpndTy));

    auto multiAll = [](const std::vector<uint32_t> &dims) -> uint32_t {
        uint32_t sz = 1;
        for (uint32_t d : dims) { sz *= d; }
        return sz;
    };

    Value_.insert(Value_.end(), multiAll(value_shape), 0.f);
    Output_.insert(Output_.end(), multiAll(out_dim), 0.f);
    Hits_.insert(Hits_.end(), multiAll(lookup_shape), 0);

    model_.addOperation(ANEURALNETWORKS_HASHTABLE_LOOKUP, inputs, outputs);
    model_.identifyInputsAndOutputs(inputs, outputs);

    model_.finish();
  }

  void Invoke() {
    ASSERT_TRUE(model_.isValid());

    Compilation compilation(&model_);
    compilation.finish();
    Execution execution(&compilation);

#define SetInputOrWeight(X, T)                                             \
  ASSERT_EQ(execution.setInput(HashtableLookup::k##X##Tensor, X##_.data(), \
                               sizeof(T) * X##_.size()),                   \
            Result::NO_ERROR);

    FOR_ALL_INPUT_AND_WEIGHT_TENSORS(SetInputOrWeight);

#undef SetInputOrWeight

#define SetOutput(X, T)                                                     \
  ASSERT_EQ(execution.setOutput(HashtableLookup::k##X##Tensor, X##_.data(), \
                               sizeof(T) * X##_.size()),                    \
            Result::NO_ERROR);

    FOR_ALL_OUTPUT_TENSORS(SetOutput);

#undef SetOutput

    ASSERT_EQ(execution.compute(), Result::NO_ERROR);
  }

#define DefineSetter(X, T)                       \
  void Set##X(const std::vector<T>& f) {         \
    X##_.insert(X##_.end(), f.begin(), f.end()); \
  }

  FOR_ALL_INPUT_AND_WEIGHT_TENSORS(DefineSetter);

#undef DefineSetter

  void SetHashtableValue(const std::function<float(uint32_t, uint32_t)>& function) {
    for (uint32_t i = 0; i < rows_; i++) {
      for (uint32_t j = 0; j < features_; j++) {
          Value_[i * features_ + j] = function(i, j);
      }
    }
  }

  const std::vector<float>& GetOutput() const { return Output_; }
  const std::vector<uint8_t>& GetHits() const { return Hits_; }

 private:
  Model model_;
  uint32_t rows_;
  uint32_t features_;

#define DefineTensor(X, T) std::vector<T> X##_;

  FOR_ALL_INPUT_AND_WEIGHT_TENSORS(DefineTensor);
  FOR_ALL_OUTPUT_TENSORS(DefineTensor);

#undef DefineTensor
};

TEST(HashtableLookupOpTest, BlackBoxTest) {
  HashtableLookupOpModel m({4}, {3}, {3, 2});

  m.SetLookup({1234, -292, -11, 0});
  m.SetKey({-11, 0, 1234});
  m.SetHashtableValue([](int i, int j) { return i + j / 10.0f; });

  m.Invoke();

  EXPECT_THAT(m.GetOutput(), ElementsAreArray(ArrayFloatNear({
                                 2.0, 2.1,  // 2-rd item
                                 0, 0,      // Not found
                                 0.0, 0.1,  // 0-th item
                                 1.0, 1.1,  // 1-st item
                             })));
  EXPECT_EQ(m.GetHits(), std::vector<uint8_t>({
                               1, 0, 1, 1,
                           }));

}

}  // namespace wrapper
}  // namespace nn
}  // namespace android