[TMVA][SOFIE] Use unsigned char instead of bool in return types

The `std::vector<bool>` is a special class that doesn't wrap contiguous
memory. It limits the usability of the return object (e.g. the memory
can't be adopted copy-free by a NumPy array). It prevents us
from using C-style arrays under the hood and differentiating through the
inference function.

Author: guitargeek

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

@@ -33,8 +33,6 @@ private:
    std::vector<std::shared_ptr<RModel>> fSubGraphs;    ///<!  sub-graph models (transient)
    RModel * fParentGraph = nullptr;
 
-   const std::string SP = "   ";
-
    // memory pool information for intermediate tensors
    MemoryPoolInfo fIntermediateMemoryInfo;    ///<!  intermediate memory info (transient)
    std::unordered_map<std::string_view, size_t> fIntermediateTensorFrequencyLookup;    ///<!  lookup table for intermediate tensor frequency (transient)

Diff for: tmva/sofie/src/RModel.cxx

@@ -9,6 +9,10 @@
 #include "TMVA/RModel.hxx"
 #include "TMVA/SOFIE_common.hxx"
 
+namespace {
+const std::string SP = "   ";
+}
+
 namespace TMVA {
 namespace Experimental {
 namespace SOFIE {
@@ -717,25 +721,18 @@ namespace {
 
 std::string createOutputTensor(RModel const &rmodel, std::string const &name, bool isIntermediateTensor)
 {
-   if(name.empty()) return "{}";
+   if (name.empty())
+      return "{}";
    ETensorType eOutputType = rmodel.GetTensorType(name);
+   // The std::vector<bool> is a special type that is not wrapping continuous memory.
+   // We don't want to use it as a return type.
    std::string outputType = ConvertTypeToString(eOutputType);
-   if (isIntermediateTensor) {
-
-      if (eOutputType == ETensorType::BOOL) {
-         return "fTensor_" + name;
-      } else {
-         // need to check is size is the same(don't want to return a vector with larger size)
-         // in that case better to copy
-         return "std::vector<" + ConvertTypeToString(eOutputType) + ">(tensor_" + name + ", tensor_" + name + " + " +
-                std::to_string(ConvertShapeToLength(rmodel.GetTensorShape(name))) + ")";
-      }
-   }
-   // include also dynamic tensors since the vectors can be allocated with a size larger than their output
-   // we need a special handling for bool type allocated as vector<bool>
-   auto outputLength = ConvertDynamicShapeToLength(rmodel.GetDynamicTensorShape(name));
-   if (rmodel.IsDynamicTensor(name) && eOutputType == ETensorType::BOOL) {
-      return "std::vector<bool>(fTensor_" + name + ".begin(), fTensor_" + name + ".begin() + " + outputLength + ")";
+   auto outputLength = isIntermediateTensor ? std::to_string(ConvertShapeToLength(rmodel.GetTensorShape(name)))
+                                            : ConvertDynamicShapeToLength(rmodel.GetDynamicTensorShape(name));
+   // need to check is size is the same(don't want to return a vector with
+   // larger size) in that case better to copy
+   if (eOutputType == ETensorType::BOOL) {
+      return "std::vector<unsigned char>(fTensor_" + name + ".begin(), fTensor_" + name + ".begin() + " + outputLength + ")";
    }
    return "std::vector<" + outputType + ">(tensor_" + name + ", tensor_" + name + " + " + outputLength + ")";
 }
@@ -755,7 +752,9 @@ void RModel::GenerateOutput() {
    bool sameOutputTypes = true;
    std::string inferReturnType; // type return by infer function
    ETensorType eOutputType = GetTensorType(*fOutputTensorNames.begin());
-   std::string outputType = ConvertTypeToString(eOutputType);
+   // The std::vector<bool> is a special type that is not wrapping continuous memory.
+   // We don't want to use it as a return type.
+   std::string outputType = eOutputType != ETensorType::BOOL ? ConvertTypeToString(eOutputType) : "unsigned char";
    fGC += "\n\n";
    if (outputSize == 1) {
       fGC += "std::vector<" + outputType + ">";

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

@@ -2515,7 +2515,7 @@ TEST(ONNX, Equal){
    });
 
    TMVA_SOFIE_Equal::Session s("Equal_FromONNX.dat");
-   std::vector<bool> output = s.infer(input1.data(),input2.data());
+   std::vector<unsigned char> output = s.infer(input1.data(),input2.data());
    // Checking output size
    EXPECT_EQ(output.size(), sizeof(Equal_ExpectedOutput::outputs) / sizeof(bool));
 
@@ -2540,7 +2540,7 @@ TEST(ONNX, LessOrEqual){
    });
 
    TMVA_SOFIE_LessOrEqual::Session s("LessOrEqual_FromONNX.dat");
-   std::vector<bool> output = s.infer(input1.data(),input2.data());
+   std::vector<unsigned char> output = s.infer(input1.data(),input2.data());
    // Checking output size
    EXPECT_EQ(output.size(), sizeof(LessOrEqual_ExpectedOutput::outputs) / sizeof(bool));
 
@@ -2565,7 +2565,7 @@ TEST(ONNX, GreaterOrEqual){
    });
 
    TMVA_SOFIE_GreaterOrEqual::Session s("GreaterOrEqual_FromONNX.dat");
-   std::vector<bool> output = s.infer(input1.data(),input2.data());
+   std::vector<unsigned char> output = s.infer(input1.data(),input2.data());
    // Checking output size
    EXPECT_EQ(output.size(), sizeof(GreaterOrEqual_ExpectedOutput::outputs) / sizeof(bool));
 
@@ -2590,7 +2590,7 @@ TEST(ONNX, Greater){
    });
 
    TMVA_SOFIE_Greater::Session s("Greater_FromONNX.dat");
-   std::vector<bool> output = s.infer(input1.data(),input2.data());
+   std::vector<unsigned char> output = s.infer(input1.data(),input2.data());
    // Checking output size
    EXPECT_EQ(output.size(), sizeof(Greater_ExpectedOutput::outputs) / sizeof(bool));
 
@@ -2615,7 +2615,7 @@ TEST(ONNX, Less){
    });
 
    TMVA_SOFIE_Less::Session s("Less_FromONNX.dat");
-   std::vector<bool> output = s.infer(input1.data(),input2.data());
+   std::vector<unsigned char> output = s.infer(input1.data(),input2.data());
    // Checking output size
    EXPECT_EQ(output.size(), sizeof(Less_ExpectedOutput::outputs) / sizeof(bool));
 
@@ -3213,4 +3213,4 @@ TEST(ONNX, ScatterElements)
    for (size_t i = 0; i < output.size(); ++i) {
       EXPECT_LE(std::abs(output[i] - correct_output[i]), DEFAULT_TOLERANCE);
    }
-}
+}