[tmva][sofie] not operator changes

Author: sanjibansg

tmva/sofie/inc/TMVA/ROperator_BasicUnary.hxx

@@ -13,6 +13,7 @@ enum class EBasicUnaryOperator {
    kReciprocal,
    kSqrt,
    kNeg,
+   kNot,
    kExp,
    kLog,
    kSin,
@@ -43,6 +44,12 @@ struct UnaryOpTraits<T, EBasicUnaryOperator::kNeg> {
    static std::string Op(const std::string &X) { return "-" + X; }
 };
 
+template <typename T>
+struct UnaryOpTraits<T, EBasicUnaryOperator::kNot> {
+   static std::string Name() { return "Not"; }
+   static std::string Op(const std::string &X) { return "!" + X; }
+};
+
 template <typename T>
 struct UnaryOpTraits<T, EBasicUnaryOperator::kExp> {
    static std::string Name() { return "Exp"; }
@@ -122,7 +129,14 @@ public:
       out << SP << "\n//---- Operator" << UnaryOpTraits<T, Op>::Name() << " " << OpName << "\n";
       size_t length = ConvertShapeToLength(fShapeX);
       out << SP << "for (size_t i = 0; i < " << length << "; i++) {\n";
-      out << SP << SP << "tensor_" << fNY << "[i] = " << UnaryOpTraits<T, Op>::Op("tensor_" + fNX + "[i]") << ";\n";
+      
+      // since NOT is operated on a boolean vector, for which we do not use a pointer
+      if (Op == EBasicUnaryOperator::kNot){
+         out << SP << SP << "fTensor_" << fNY << "[i] = " << UnaryOpTraits<T, Op>::Op("fTensor_" + fNX + "[i]") << ";\n"; 
+      } else {
+         out << SP << SP << "tensor_" << fNY << "[i] = " << UnaryOpTraits<T, Op>::Op("tensor_" + fNX + "[i]") << ";\n";
+      }
+      
       out << SP << "}\n";
       return out.str();
    }

tmva/sofie/test/TestCustomModelsFromONNX.cxx

@@ -529,22 +529,20 @@ 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});
+      std::vector<bool> input({false, true, false, false, true, true});
 
       TMVA_SOFIE_Not::Session s("Not_FromONNX.dat");
-      std::vector<float> output = s.infer(input.data());
+      std::vector<bool> output = s.infer(input.data());
 
       // Checking output size
-      EXPECT_EQ(output.size(), sizeof(Not_ExpectedOutput::outputs) / sizeof(float));
+      EXPECT_EQ(output.size(), sizeof(Not_ExpectedOutput::outputs) / sizeof(bool));
 
-      float *correct = Not_ExpectedOutput::outputs;
+      bool *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);
+         EXPECT_EQ(output[i], correct[i]);
       }
    }
 

tmva/sofie/test/input_models/Not.onnx

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

-b
-output
-
-

-B
+onnx-equal-not-example:�

+%
+input1
+input2equal_output"Equal
+
+equal_outputoutput"NotEqualNotGraphZ
+input1
+

+

+Z
+input2
+

+

+b
+output
+	
+

+B

tmva/sofie/test/input_models/references/Not.ref.hxx

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

tmva/sofie_parsers/src/ParseBasicUnary.cxx

@@ -20,13 +20,26 @@ std::unique_ptr<ROperator> ParseBasicUnary(RModelParser_ONNX &parser, const onnx
                                   " but its type is not yet registered");
    }
 
+   if constexpr (Op == EBasicUnaryOperator::kNot) {
+      if (input_type != ETensorType::BOOL) {
+          throw std::runtime_error("TMVA::SOFIE - Unary NOT operator expects input type BOOL, got type " +
+                                   std::to_string(static_cast<int>(input_type)));
+      }
+  }
+
    std::unique_ptr<ROperator> op;
    std::string output_name = nodeproto.output(0);
-
+   
    switch (input_type) {
    case ETensorType::FLOAT:
       op.reset(new ROperator_BasicUnary<float, Op>(input_name, output_name));
       break;
+    case ETensorType::BOOL:
+        if constexpr (Op == EBasicUnaryOperator::kNot) {
+            op.reset(new ROperator_BasicUnary<bool, Op>(input_name, output_name));
+            break;
+        }
+        [[fallthrough]];
    default:
       throw std::runtime_error("TMVA::SOFIE - Unsupported - Binary Operator does not yet support input type " +
                                std::to_string(static_cast<int>(input_type)));
@@ -55,6 +68,11 @@ ParserFuncSignature ParseNeg = [](RModelParser_ONNX &parser, const onnx::NodePro
    return ParseBasicUnary<EBasicUnaryOperator::kNeg>(parser, nodeproto);
 };
 
+// Parse Not
+ParserFuncSignature ParseNot = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
+   return ParseBasicUnary<EBasicUnaryOperator::kNot>(parser, nodeproto);
+};
+
 // Parse Exp
 ParserFuncSignature ParseExp = [](RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto) {
    return ParseBasicUnary<EBasicUnaryOperator::kExp>(parser, nodeproto);

tmva/sofie_parsers/src/RModelParser_ONNX.cxx

@@ -20,6 +20,7 @@ namespace SOFIE {
 extern ParserFuncSignature ParseSqrt;
 extern ParserFuncSignature ParseReciprocal;
 extern ParserFuncSignature ParseNeg;
+extern ParserFuncSignature ParseNot;
 extern ParserFuncSignature ParseExp;
 extern ParserFuncSignature ParseLog;
 extern ParserFuncSignature ParseSin;
@@ -161,7 +162,7 @@ RModelParser_ONNX::RModelParser_ONNX() noexcept : fOperatorsMapImpl(std::make_un
    RegisterOperator("Sqrt", ParseSqrt);
    RegisterOperator("Reciprocal", ParseReciprocal);
    RegisterOperator("Neg", ParseNeg);
-   RegisterOperator("Not", ParseNeg);
+   RegisterOperator("Not", ParseNot);
    RegisterOperator("Exp", ParseExp);
    RegisterOperator("Log", ParseLog);
    RegisterOperator("Sin", ParseSin);