First Draft EyeLike CPU OP9

onnxruntime/core/providers/cpu/cpu_execution_provider.cc

@@ -189,6 +189,7 @@ class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 8, Sca
 class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, Scale);
 class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, If);
 class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, Loop);
+class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 9, EyeLike);
 
 // Opset 9
 class ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 9, ConstantLike);
@@ -373,6 +374,7 @@ void RegisterOnnxOperatorKernels(std::function<void(KernelCreateInfo&&)> fn) {
   fn(BuildKernel<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, Scale)>());
   fn(BuildKernel<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, If)>());
   fn(BuildKernel<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, Loop)>());
+  fn(BuildKernel<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 9, EyeLike)>());
 
   // Opset 9
   fn(BuildKernel<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 9, ConstantLike)>());

onnxruntime/core/providers/cpu/tensor/eye_like.cc

@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "core/providers/cpu/tensor/eye_like.h"
+#include "core/framework/tensorprotoutils.h"
+
+using namespace ::onnxruntime::common;
+
+namespace onnxruntime {
+
+ONNX_CPU_OPERATOR_KERNEL(
+    EyeLike,
+    9,
+    KernelDefBuilder().TypeConstraint("T1",
+                                      std::vector<MLDataType>{
+                                          DataTypeImpl::GetTensorType<float>(),
+                                          DataTypeImpl::GetTensorType<int64_t>(),
+                                          DataTypeImpl::GetTensorType<uint64_t>(),
+                                      })
+                        .TypeConstraint("T2",
+                                        std::vector<MLDataType>{
+                                            DataTypeImpl::GetTensorType<float>(),
+                                            DataTypeImpl::GetTensorType<uint64_t>(),
+                                            DataTypeImpl::GetTensorType<int64_t>(),
+                                        }),
+    EyeLike);
+
+Status EyeLike::Compute(OpKernelContext* context) const {
+  const Tensor* T1 = context->Input<Tensor>(0);
+  ONNXRUNTIME_ENFORCE(T1 != nullptr);  
+
+  auto output_tensor_dtype = has_dtype ? static_cast<onnx::TensorProto::DataType>(dtype_) : utils::GetTensorProtoType(*T1);
+  switch (output_tensor_dtype) {
+    case onnx::TensorProto_DataType_FLOAT:
+      return ComputeImpl<float>(context);
+    case onnx::TensorProto_DataType_INT64:
+      return ComputeImpl<int64_t>(context);
+    case onnx::TensorProto_DataType_UINT64:
+      return ComputeImpl<uint64_t>(context);
+    default:
+      ONNXRUNTIME_THROW("Unsupported 'dtype' value: ", output_tensor_dtype);
+  }
+}
+
+template <typename T>
+Status EyeLike::ComputeImpl(OpKernelContext* context) const {
+  const Tensor* T1 = context->Input<Tensor>(0);
+  const std::vector<int64_t>& input_dims = T1->Shape().GetDims();
+  if (input_dims.size() != 2) {
+    return Status(ONNXRUNTIME, INVALID_ARGUMENT, "EyeLike : Input tensor dimension is not 2");
+  }
+
+  // set output tensor shape same as input tensor and set all values to zero
+  auto* T2 = context->Output(0, input_dims);
+  auto* data = T2->MutableData<T>();
+  T zero_value = static_cast<T>(0);
+  auto out = gsl::make_span(data, T2->Shape().Size());
+  std::for_each(out.begin(), out.end(), [&zero_value](T& v) { v = zero_value; });
+
+  int64_t diag_start = 0;
+  int64_t diag_end = 0;
+  if (k_ >= 0) {
+    diag_start = k_;
+    diag_end = (input_dims[1] - k_) * (input_dims[1]);
+  } else {
+    diag_start = (-k_) * input_dims[1];
+    diag_end = diag_start + (input_dims[0] + k_) * input_dims[1];
+  }
+
+  T one_value = static_cast<T>(1); 
+  for (auto i = diag_start; i < diag_end; i += input_dims[1] + 1) {
+    data[i] = one_value;
+  }
+
+  return Status::OK();
+}
+
+}  // namespace onnxruntime

onnxruntime/core/providers/cpu/tensor/eye_like.h

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "core/common/common.h"
+#include "core/framework/op_kernel.h"
+
+namespace onnxruntime {
+
+class EyeLike final : public OpKernel {
+ public:
+  EyeLike(const OpKernelInfo& info) : OpKernel(info) {
+    if (!info.GetAttr("k", &k_).IsOK()) {
+      ONNXRUNTIME_THROW("Missing 'k' attribute value");
+    }
+
+    has_dtype = info.GetAttr("dtype", &dtype_).IsOK();
+  }
+
+  Status Compute(OpKernelContext* context) const override;
+
+ private:
+  template <typename T>
+  Status ComputeImpl(OpKernelContext* context) const;
+
+  bool has_dtype;
+  int64_t dtype_;
+  int64_t k_;
+};
+
+}  //namespace onnxruntime

onnxruntime/test/providers/cpu/tensor/eyelike_op_test.cc

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "gtest/gtest.h"
+#include "test/providers/provider_test_utils.h"
+
+namespace onnxruntime {
+namespace test {
+
+TEST(EyeLikeOpTest, EyeLikeDefault) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<float>("T1", {3, 2}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});  
+  test.AddOutput<float>("T2", {3, 2}, {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_DifferentDtype) {
+  OpTester test("EyeLike", 9);
+  test.AddAttribute("dtype", int64_t(7));
+  test.AddInput<float>("T1", {3, 3}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  test.AddOutput<int64_t>("T2", {3, 3}, {1, 0, 0, 0, 1, 0, 0, 0, 1});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_K_EgdeCase_1) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<int64_t>("T1", {3, 2}, {0, 0, 0, 0, 0, 0});
+  int64_t kVal = 3;
+  test.AddAttribute("k", kVal);
+  test.AddAttribute("dtype", int64_t(7));
+  test.AddOutput<int64_t>("T2", {3, 2}, {0, 0, 0, 0, 0, 0});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_K_EgdeCase_2) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<int64_t>("T1", {3, 2}, {0, 0, 0, 0, 0, 0});
+  int64_t kVal = -3;
+  test.AddAttribute("k", kVal);
+  test.AddOutput<int64_t>("T2", {3, 2}, {0, 0, 0, 0, 0, 0});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_UpperDiagonal) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<float>("T1", {3, 4}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  int64_t kVal = 2;
+  test.AddAttribute("k", kVal);
+  test.AddOutput<float>("T2", {3, 4}, {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_UpperrDiagonal2) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<float>("T1", {3, 2}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  int64_t kVal = 1;
+  test.AddAttribute("k", kVal);
+  test.AddOutput<float>("T2", {3, 2}, {0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_LowerDiagonal) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<float>("T1", {3, 2}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  int64_t kVal = -1;
+  test.AddAttribute("k", kVal);
+  test.AddAttribute("dtype", int64_t(1));
+  test.AddOutput<float>("T2", {3, 2}, {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f});
+  test.Run();
+}
+
+TEST(EyeLikeOpTest, EyeLike_LowerDiagonal2) {
+  OpTester test("EyeLike", 9);
+  test.AddInput<float>("T1", {3, 4}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
+  int64_t kVal = -2;
+  test.AddAttribute("k", kVal);
+  test.AddAttribute("dtype", int64_t(1));
+  test.AddOutput<float>("T2", {3, 4}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f});
+  test.Run();
+}
+
+}  // namespace test
+}  // namespace onnxruntime