[tmva][sofie] Implement binary operator creation in C++

Re-implement the binary operator creation in the Keras parser code path
in C++, so the Python side Keras parser implementation doesn't have to
deal with SOFIE implementation details like the `EBasicBinaryOperator`
or which binary operator types are supported.

This also fixes a logic error where a binary operator with any name was
falling back to multiplication.

Author: guitargeek

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_tmva/_sofie/_parser/_keras/layers/binary.py

@@ -1,23 +1,5 @@
 def MakeKerasBinary(layer):
     from ROOT.TMVA.Experimental import SOFIE
 
-    input = layer["layerInput"]
-    output = layer["layerOutput"]
-    fLayerType = layer["layerType"]
-    fLayerDType = layer["layerDType"]
-    fX1 = input[0]
-    fX2 = input[1]
-    fY = output[0]
-    op = None
-    if SOFIE.ConvertStringToType(fLayerDType) == SOFIE.ETensorType.FLOAT:
-        if fLayerType == "Add":
-            op = SOFIE.ROperator_BasicBinary(float, SOFIE.EBasicBinaryOperator.Add)(fX1, fX2, fY)
-        elif fLayerType == "Subtract":
-            op = SOFIE.ROperator_BasicBinary(float, SOFIE.EBasicBinaryOperator.Sub)(fX1, fX2, fY)
-        else:
-            op = SOFIE.ROperator_BasicBinary(float, SOFIE.EBasicBinaryOperator.Mul)(fX1, fX2, fY)
-    else:
-        raise RuntimeError(
-            "TMVA::SOFIE - Unsupported - Operator BasicBinary does not yet support input type " + fLayerDType
-        )
-    return op
+    inpt = layer["layerInput"]
+    return SOFIE.createBasicBinary(layer["layerDType"], layer["layerType"], inpt[0], inpt[1], layer["layerOutput"][0])

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_tmva/_sofie/_parser/_keras/parser.py

@@ -99,6 +99,11 @@ def move_operator(op):
         """
         import ROOT
 
+        # If the object is already held by a smart pointer, just move it.
+        smartptr = op.__smartptr__()
+        if smartptr:
+            return type(smartptr)(ROOT.std.move(smartptr))
+
         ROOT.SetOwnership(op, False)
         return ROOT.std.unique_ptr[type(op)](op)
 

tmva/sofie/inc/TMVA/ROperator_BasicBinary.hxx

@@ -455,6 +455,24 @@ public:
    }
 };
 
+inline std::unique_ptr<ROperator> createBasicBinary(std::string layerDType, std::string layerType, std::string nameA,
+                                                    std::string nameB, std::string nameY)
+{
+   if (ConvertStringToType(layerDType) != ETensorType::FLOAT) {
+      throw std::runtime_error(
+         ("TMVA::SOFIE - Unsupported - Operator BasicBinary does not yet support input type " + layerDType).c_str());
+   }
+   if (layerType == "Add")
+      return std::make_unique<ROperator_BasicBinary<float, EBasicBinaryOperator::Add>>(nameA, nameB, nameY);
+   if (layerType == "Subtract")
+      return std::make_unique<ROperator_BasicBinary<float, EBasicBinaryOperator::Sub>>(nameA, nameB, nameY);
+   if (layerType == "Multiply")
+      return std::make_unique<ROperator_BasicBinary<float, EBasicBinaryOperator::Mul>>(nameA, nameB, nameY);
+
+   throw std::runtime_error(
+      ("TMVA::SOFIE - Unsupported - Operator BasicBinary does not yet support layer type " + layerType).c_str());
+}
+
 } // namespace SOFIE
 } // namespace Experimental
 } // namespace TMVA