[tmva][sofie] fix round operation and add tests

Author: sanjibansg

Diff for: tmva/sofie/inc/TMVA/ROperator_BasicUnary.hxx

@@ -9,7 +9,17 @@ namespace TMVA {
 namespace Experimental {
 namespace SOFIE {
 
-enum class EBasicUnaryOperator { kReciprocal, kSqrt , kNeg, kExp, kLog, kSin, kCos, kAbs };
+enum class EBasicUnaryOperator {
+   kReciprocal,
+   kSqrt,
+   kNeg,
+   kExp,
+   kLog,
+   kSin,
+   kCos,
+   kAbs,
+   kRound
+};
 
 template <typename T, EBasicUnaryOperator Op>
 struct UnaryOpTraits {
@@ -66,7 +76,10 @@ struct UnaryOpTraits<T, EBasicUnaryOperator::kAbs> {
 template <typename T>
 struct UnaryOpTraits<T, EBasicUnaryOperator::kRound> {
    static std::string Name() { return "Round"; }
-   static std::string Op(const std::string &X) { return "std::round(" + X + ")"; }
+   static std::string Op(const std::string &X)
+   {
+      return "(std::fabs(" + X + "- std::trunc(" + X + ")) == 0.5) ? std::trunc(" + X + ") : std::round(" + X + ");";
+   }
 };
 
 template <typename T, EBasicUnaryOperator Op>
@@ -115,7 +128,8 @@ public:
    }
 
    std::vector<std::string> GetStdLibs() override {
-      if (Op == EBasicUnaryOperator::kSqrt || Op == EBasicUnaryOperator::kExp || Op == EBasicUnaryOperator::kLog) {
+      if (Op == EBasicUnaryOperator::kSqrt || Op == EBasicUnaryOperator::kExp || Op == EBasicUnaryOperator::kLog ||
+          Op == EBasicUnaryOperator::kRound) {
          return { std::string("cmath") };
       } else {
          return {};

Diff for: tmva/sofie/test/TestCustomModelsFromONNX.cxx

@@ -27,6 +27,9 @@
 #include "Cast_FromONNX.hxx"
 #include "input_models/references/Cast.ref.hxx"
 
+#include "CastLike_FromONNX.hxx"
+#include "input_models/references/CastLike.ref.hxx"
+
 #include "ReduceMean_FromONNX.hxx"
 #include "input_models/references/ReduceMean.ref.hxx"
 
@@ -271,6 +274,9 @@
 #include "Log_FromONNX.hxx"
 #include "input_models/references/Log.ref.hxx"
 
+#include "Round_FromONNX.hxx"
+#include "input_models/references/Round.ref.hxx"
+
 #include "Elu_FromONNX.hxx"
 #include "input_models/references/Elu.ref.hxx"
 
@@ -323,6 +329,9 @@
 
 #include "ScatterElements_FromONNX.hxx"
 
+#include "Not_FromONNX.hxx"
+#include "input_models/references/Not.ref.hxx"
+
 #include "gtest/gtest.h"
 
 constexpr float DEFAULT_TOLERANCE = 1e-3f;
@@ -518,6 +527,27 @@ TEST(ONNX, Neg)
       }
    }
 
+   TEST(ONNX, Not)
+   {
+      constexpr float TOLERANCE = DEFAULT_TOLERANCE;
+
+      // Preparing the standard input
+      std::vector<float> input({-0.7077, 1.0645, -0.8607, 0.2085, 4.5335, -3.4592});
+
+      TMVA_SOFIE_Not::Session s("Not_FromONNX.dat");
+      std::vector<float> output = s.infer(input.data());
+
+      // Checking output size
+      EXPECT_EQ(output.size(), sizeof(Not_ExpectedOutput::outputs) / sizeof(float));
+
+      float *correct = Not_ExpectedOutput::outputs;
+
+      // Checking every output value, one by one
+      for (size_t i = 0; i < output.size(); ++i) {
+         EXPECT_LE(std::abs(output[i] - correct[i]), TOLERANCE);
+      }
+   }
+
 TEST(ONNX, Elu)
    {
       constexpr float TOLERANCE = DEFAULT_TOLERANCE;
@@ -690,6 +720,28 @@ TEST(ONNX, Cast)
    }
 }
 
+TEST(ONNX, CastLike)
+{
+   constexpr float TOLERANCE = DEFAULT_TOLERANCE;
+
+   // Preparing the standard  input
+   std::vector<int64_t> input_1({3, 23, -8, 1});
+
+   TMVA_SOFIE_CastLike::Session s("CastLike_FromONNX.dat");
+
+   auto output = s.infer(input_1.data());
+
+   // Checking output size
+   EXPECT_EQ(output.size(), sizeof(CastLike_ExpectedOutput::outputs) / sizeof(float));
+
+   float *correct = CastLike_ExpectedOutput::outputs;
+
+   // Checking every output value, one by one
+   for (size_t i = 0; i < output.size(); ++i) {
+      EXPECT_LE(std::abs(output[i] - correct[i]), TOLERANCE);
+   }
+}
+
 TEST(ONNX, Linear64)
 {
    constexpr float TOLERANCE = DEFAULT_TOLERANCE;
@@ -808,6 +860,28 @@ TEST(ONNX, Log)
    }
 }
 
+TEST(ONNX, Round)
+{
+   constexpr float TOLERANCE = DEFAULT_TOLERANCE;
+
+   // Preparing the random input
+   std::vector<float> input({1.3, -4.5, 7.9, -2.6});
+
+   TMVA_SOFIE_Round::Session s("Round_FromONNX.dat");
+
+   std::vector<float> output = s.infer(input.data());
+
+   // Checking output size
+   EXPECT_EQ(output.size(), sizeof(Round_ExpectedOutput::outputs) / sizeof(float));
+
+   float *correct = Round_ExpectedOutput::outputs;
+
+   // Checking every output value, one by one
+   for (size_t i = 0; i < output.size(); ++i) {
+      EXPECT_LE(std::abs(output[i] - correct[i]), TOLERANCE);
+   }
+}
+
 TEST(ONNX, LinearWithLeakyRelu)
 {
    constexpr float TOLERANCE = 1;

Diff for: tmva/sofie/test/input_models/CastLike.onnx

@@ -0,0 +1,15 @@
+
+onnx-example:�

+Dinput2"Constant*0
+value*$
"�̼@33A��L�ff>�Bconst_tensor�

+"
+input1
+input2output"CastLikeCastLikeGraphZ
+input1
+
+
+b
+output
+
+

+B

Diff for: tmva/sofie/test/input_models/Not.onnx

@@ -0,0 +1,12 @@
+
+onnx-example:M
+
+input1output"NotNotGraphZ
+input1
+
+

+b
+output
+
+

+B

Diff for: tmva/sofie/test/input_models/Round.onnx

@@ -0,0 +1,13 @@
+
+onnx-example:O
+
+inputoutput"Round
+RoundGraphZ
+input
+
+

+b
+output
+
+

+B

Diff for: tmva/sofie/test/input_models/references/CastLike.ref.hxx

@@ -0,0 +1,3 @@
+namespace CastLike_ExpectedOutput {
+	float outputs[] = {3.0, 23.0, -8.0, 1.0};
+} // namespace CastLike_ExpectedOutput

Diff for: tmva/sofie/test/input_models/references/Not.ref.hxx

@@ -0,0 +1,3 @@
+namespace Not_ExpectedOutput {
+	float outputs[] = {0.7077, -1.0645, 0.8607, -0.2085, -4.5335, 3.4592};
+} // namespace Not_ExpectedOutput

Diff for: tmva/sofie/test/input_models/references/Round.ref.hxx

@@ -0,0 +1,3 @@
+namespace Round_ExpectedOutput {
+	float outputs[] = {1, -4, 8, -3};
+} // namespace Round_ExpectedOutput

Diff for: tmva/sofie_parsers/src/ParseBasicUnary.cxx

@@ -81,7 +81,7 @@ ParserFuncSignature ParseAbs = [](RModelParser_ONNX &parser, const onnx::NodePro
 };
 
 // Parse Round
-ParserFuncSignature ParseAbs = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
+ParserFuncSignature ParseRound = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
    return ParseBasicUnary<EBasicUnaryOperator::kRound>(parser, nodeproto);
 };
 

Diff for: tmva/sofie_parsers/src/ParseCast.cxx

@@ -46,20 +46,18 @@ ParserFuncSignature ParseCastLike = [](RModelParser_ONNX &parser, const onnx::No
    }
 
    std::unique_ptr<ROperator> op;
-   std::string target_type = parser.GetTensorType(target_type_tensor_name);
+   std::string target_type = ConvertTypeToString(parser.GetTensorType(target_type_tensor_name));
    std::string output_name = nodeproto.output(0);
    op.reset(new ROperator_Cast(target_type, input_name, output_name));
 
    if (!parser.IsRegisteredTensorType(output_name)) {
-      ETensorType output_type = ConvertStringToType(attr_type);
+      ETensorType output_type = ConvertStringToType(target_type);
       parser.RegisterTensorType(output_name, output_type);
    }
 
    return op;
 };
 
- 
-
 } // namespace SOFIE
 } // namespace Experimental
 } // namespace TMVA