caffe2/operators/elementwise_op_test.h

#ifndef CAFFE2_OPERATORS_ELEMENTWISE_OP_TEST_H_
#define CAFFE2_OPERATORS_ELEMENTWISE_OP_TEST_H_

#include "caffe2/operators/elementwise_ops.h"

#include <iostream>
#include <string>
#include <vector>

#include <gtest/gtest.h>

template <typename Context, typename T>
void CopyVector(const int N, const T* x, T* y);

template <typename Context, typename I_Type, typename O_Type>
void FillTensor(
    caffe2::Workspace* ws,
    const std::string& name,
    const std::vector<int64_t>& shape,
    const std::vector<I_Type>& values) {
  auto* blob = ws->CreateBlob(name);
  auto* tensor = BlobGetMutableTensor(blob, Context::GetDeviceType());
  tensor->Resize(shape);
  auto* mutable_data = tensor->template mutable_data<O_Type>();
  const O_Type* data = reinterpret_cast<const O_Type*>(values.data());
  CopyVector<Context, O_Type>(values.size(), data, mutable_data);
}

template <typename Context>
caffe2::OperatorDef CreateOperatorDef() {
  caffe2::OperatorDef def;
  return def;
}

template <typename Context>
caffe2::OperatorDef DefineOperator(const std::string& op_type) {
  caffe2::OperatorDef def = CreateOperatorDef<Context>();
  def.set_name("test");
  def.set_type(op_type);
  def.add_input("X");
  def.add_input("Y");
  def.add_output("Z");
  return def;
}

template <typename Context>
void elementwiseAnd() {
  const int N = 4;
  const int M = 2;
  caffe2::Workspace ws;
  auto def = DefineOperator<Context>("And");
  { // equal size
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {N}, {true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), N);
    std::vector<bool> result{true, false, false, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
  { // broadcast
    auto* arg = def.add_arg();
    arg->set_name("broadcast");
    arg->set_i(1);
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {M, N}, {true, false, true, false, true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), M * N);
    std::vector<bool> result{
        true, false, false, false, true, false, false, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
}

template <typename Context>
void elementwiseOr() {
  const int N = 4;
  const int M = 2;
  caffe2::Workspace ws;
  auto def = DefineOperator<Context>("Or");
  { // equal size
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {N}, {true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), N);
    std::vector<bool> result{true, true, true, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
  { // broadcast
    auto* arg = def.add_arg();
    arg->set_name("broadcast");
    arg->set_i(1);
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {M, N}, {true, false, true, false, true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), M * N);
    std::vector<bool> result{true, true, true, false, true, true, true, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
}

template <typename Context>
void elementwiseXor() {
  const int N = 4;
  const int M = 2;
  caffe2::Workspace ws;
  auto def = DefineOperator<Context>("Xor");
  { // equal size
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {N}, {true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), N);
    std::vector<bool> result{false, true, true, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
  { // broadcast
    auto* arg = def.add_arg();
    arg->set_name("broadcast");
    arg->set_i(1);
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {M, N}, {true, false, true, false, true, false, true, false});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, true, false, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), M * N);
    std::vector<bool> result{
        false, true, true, false, false, true, true, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
}

template <typename Context>
void elementwiseNot() {
  const int N = 2;
  caffe2::Workspace ws;
  caffe2::OperatorDef def = CreateOperatorDef<Context>();
  def.set_name("test");
  def.set_type("Not");
  def.add_input("X");
  def.add_output("Y");
  FillTensor<Context, uint8_t, bool>(&ws, "X", {N}, {true, false});
  std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
  EXPECT_NE(nullptr, op.get());
  EXPECT_TRUE(op->Run());
  auto* blob = ws.GetBlob("Y");
  EXPECT_NE(nullptr, blob);
  caffe2::Tensor Y(blob->Get<caffe2::Tensor>(), caffe2::CPU);
  EXPECT_EQ(Y.numel(), N);
  std::vector<bool> result{false, true};
  for (size_t i = 0; i < Y.numel(); ++i) {
    EXPECT_EQ(Y.template data<bool>()[i], result[i]);
  }
}

template <typename Context>
void elementwiseEQ() {
  const int N = 4;
  const int M = 2;
  caffe2::Workspace ws;
  auto def = DefineOperator<Context>("EQ");
  { // equal size
    FillTensor<Context, int32_t, int32_t>(&ws, "X", {N}, {1, 100, 5, -10});
    FillTensor<Context, int32_t, int32_t>(&ws, "Y", {N}, {0, 100, 4, -10});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), N);
    std::vector<bool> result{false, true, false, true};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
  { // boolean
    FillTensor<Context, uint8_t, bool>(
        &ws, "X", {N}, {true, false, false, true});
    FillTensor<Context, uint8_t, bool>(
        &ws, "Y", {N}, {true, false, true, false});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), N);
    std::vector<bool> result{true, true, false, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
  { // broadcast
    auto* arg = def.add_arg();
    arg->set_name("broadcast");
    arg->set_i(1);
    FillTensor<Context, int32_t, int32_t>(
        &ws, "X", {M, N}, {1, 100, 5, -10, 3, 6, -1000, 33});
    FillTensor<Context, int32_t, int32_t>(&ws, "Y", {N}, {1, 6, -1000, -10});
    std::unique_ptr<caffe2::OperatorBase> op(caffe2::CreateOperator(def, &ws));
    EXPECT_NE(nullptr, op.get());
    EXPECT_TRUE(op->Run());
    auto* blob = ws.GetBlob("Z");
    EXPECT_NE(nullptr, blob);
    caffe2::Tensor Z(blob->Get<caffe2::Tensor>(), caffe2::CPU);
    EXPECT_EQ(Z.numel(), M * N);
    std::vector<bool> result{
        true, false, false, true, false, true, true, false};
    for (size_t i = 0; i < Z.numel(); ++i) {
      EXPECT_EQ(Z.template data<bool>()[i], result[i]);
    }
  }
}

#endif // CAFFE2_OPERATORS_ELEMENTWISE_OP_TEST_H_