[tmva][sofie] Add tests for Not, IsInf and IsNaN operators

Remove also some commented code in the NonZero operator

Author: lmoneta

tmva/sofie/inc/TMVA/ROperator_NonZero.hxx

@@ -92,15 +92,6 @@ public:
          fShapeY.resize(2);
          fShapeY[0] = fShapeX.size();
 
-         // identify as -1 since we will declare maximum as size of input
-         // auto inputLength = ConvertDimShapeToLength(fShapeX);
-         // // case X is Dim, becomes complicated to know the maximum. Shuld be allocated dynamically
-         // size_t inputLength = 0;
-         // if (!model.IsDynamicTensor(fNX)) {
-         //    inputLength = ConvertShapeToLength(ConvertShapeToInt(fShapeX));
-         // else
-         //    inputLength = static_cast<size_t>(-1);   // flag -1 to define shape correctly
-
          // flag -1 to define the shape variable in the constructor code and not in the constructor signature
          fShapeY[1] = Dim{std::string("v_NonZero_") + fNX, static_cast<size_t>(-1) };
 

tmva/sofie/test/TestCustomModelsFromONNX.cxx

@@ -2973,5 +2973,36 @@ TEST(ONNX, NonZero_Constant)
       EXPECT_EQ(output[i] , correct_output[i]);
    }
 }
+TEST(ONNX, IsInf)
+{
+   // expected input
+   std::vector<float> input = { 1, static_cast<float>(1./0.), 2.};
+   std::vector<uint8_t> correct_output = { 0,1,0 };
+
+   // not cannot use input.size() in string because input symbol  will not be visible when running inference
+   ASSERT_INCLUDE_AND_RUN_SESSION_ARGS(std::vector<uint8_t>, "IsInf",std::string("\"\", ") + std::to_string(input.size()), input.size(),input);
+
+   // Checking output size
+   EXPECT_EQ(output.size(), correct_output.size());
+   // Checking output
+   for (size_t i = 0; i < output.size(); ++i) {
+      EXPECT_EQ(output[i] , correct_output[i]);
+   }
+}
 
+TEST(ONNX, NotIsNaN)
+{
+   // expected input
+   std::vector<float> input = { 1, static_cast<float>(0./0.), 2.};
+   std::vector<uint8_t> correct_output = { 1,0,1 };
+
+   ASSERT_INCLUDE_AND_RUN_SESSION_ARGS(std::vector<uint8_t>, "NotIsNaN",std::string("\"\", ") + std::to_string(input.size()), input.size(),input);
+
+   // Checking output size
+   EXPECT_EQ(output.size(), correct_output.size());
+   // Checking output
+   for (size_t i = 0; i < output.size(); ++i) {
+      EXPECT_EQ(output[i] , correct_output[i]);
+   }
+}
 

tmva/sofie/test/input_models/IsInf.onnx

@@ -0,0 +1,11 @@
+onnx-example:S
+
+inputoutput"IsInfTestZ
+input
+
	
+

+
Nb
+output
+		
+

+
NB

tmva/sofie/test/input_models/NotIsNaN.onnx

@@ -0,0 +1,13 @@
+onnx-example:t
+
+inputtemp_result"IsNaN
+
+temp_resultoutput"NotTestZ
+input
+
	
+

+
Nb
+output
+		
+

+
NB

tmva/sofie/test/test_helpers.h

@@ -45,9 +45,11 @@ bool includeModel(std::string const &modelName)
 template <class T>
 std::string toInterpreter(T const &ptr, std::string const &className, bool toRawPointer = false)
 {
-   if constexpr (std::is_same_v<T, int>) {
+   // for the integer arguments (shape values)
+   if constexpr (std::is_same_v<T, int> || std::is_same_v<T, size_t>) {
       return std::to_string(ptr);
    }
+   // for the data arguments
    std::string out =
       TString::Format("reinterpret_cast<%s*>(0x%zx)", className.c_str(), reinterpret_cast<std::size_t>(&ptr)).Data();
    if (toRawPointer) {
@@ -94,6 +96,8 @@ runModel(std::string outputTypeName, std::string const &modelName, std::string s
       auto type_name = []<typename T>() {
          if constexpr (std::is_same_v<T, int>)
             return "int";
+         else if constexpr (std::is_same_v<T, size_t>)
+            return "size_t";
          else if constexpr (std::is_same_v<T, std::vector<float>>)
             return "std::vector<float>";
          else if constexpr (std::is_same_v<T, std::vector<int>>)

tmva/sofie_parsers/src/ParseBasicIs.cxx

@@ -9,12 +9,9 @@ namespace SOFIE {
 template <EBasicIsOperator Op>
 std::unique_ptr<ROperator> ParseBasicIs(RModelParser_ONNX &parser, const onnx::NodeProto &nodeproto)
 {
-   ETensorType input_type = ETensorType::UNDEFINED;
 
    std::string input_name = nodeproto.input(0);
-   if (parser.IsRegisteredTensorType(input_name)) {
-      input_type = parser.GetTensorType(input_name);
-   } else {
+   if (!parser.IsRegisteredTensorType(input_name)) {
       throw
          std::runtime_error("TMVA::SOFIE ONNX Parser " + IsOpTraits<Op>::Name() + " op has input tensor " + input_name +
                                   " but its type is not yet registered");