[tmva][sofie] Replace template overload of RModel::AddInitializedTensor

This makes the overload that takes memory by raw pointer more consistent
with the other overload that takes a `std::shared_ptr<void>`.

This avoids also the need for some template instantiations on the SOFIE
Pythonizations side, saving some memory cost.

Author: guitargeek

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_tmva/_gnn.py

@@ -147,7 +147,8 @@ def add_weights(gin, weights, function_target):
         shape_as_list = i.shape.as_list()
         for j in shape_as_list:
             shape.push_back(j)
-        model_block.GetFunctionBlock().AddInitializedTensor['float'](i.name, shape, i.numpy())
+        model_block.GetFunctionBlock().AddInitializedTensor(i.name, SOFIE.ETensorType.FLOAT, shape, i.numpy())
+
 
 def add_aggregate_function(gin, reducer, relation):
     """

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

@@ -136,10 +136,7 @@ def move_operator(op):
         # in c++ that does the conversion from a regular pointer to unique one in c++
         # print('adding initialized tensor..',LayerName, TargetShape)
         shape_tensor_name = LayerName + "_shape"
-        shape_data = TargetShape.data
-        print(TargetShape, shape_data)
-        print(len(TargetShape))
-        rmodel.AddInitializedTensor["int64_t"](shape_tensor_name, [len(TargetShape)], shape_data)
+        rmodel.AddInitializedTensor(shape_tensor_name, SOFIE.ETensorType.UINT64, [len(TargetShape)], TargetShape)
 
     # These layers only have one operator - excluding the recurrent layers, in which the activation function(s)
     # are included in the recurrent operator
@@ -512,7 +509,7 @@ def Parse(filename, batch_size=1):  # If a model does not have a defined batch s
 
                 else:
                     fData = fWeightArray.flatten()
-                rmodel.AddInitializedTensor["float"](fWeightName, fWeightTensorShape, fData)
+                rmodel.AddInitializedTensor(fWeightName, SOFIE.ETensorType.FLOAT, fWeightTensorShape, fData)
             else:
                 raise TypeError("Type error: TMVA SOFIE does not yet support data layer type: " + fWeightDType)
 

tmva/sofie/inc/TMVA/RModel.hxx

@@ -76,6 +76,8 @@ public:
    void AddOperator(std::unique_ptr<ROperator> op, int order_execution = -1);
    void AddInitializedTensor(std::string tensor_name, ETensorType type, std::vector<std::size_t> shape,
                              std::shared_ptr<void> data);
+   void AddInitializedTensor(const std::string &tensor_name, ETensorType tensor_type,
+                             const std::vector<std::size_t> &shape, void *raw_data);
    void AddConstantTensor(std::string tensor_name, ETensorType type, std::vector<std::size_t> shape,
                              std::shared_ptr<void> data);
 
@@ -99,15 +101,6 @@ public:
       AddConstantTensor(name, GetTemplatedType<T>(T()), shape, data_ptr);
    }
 
-   template <typename T>
-   void AddInitializedTensor(const std::string & tensor_name, const std::vector<std::size_t> & shape, T *raw_data)
-   {
-      size_t size = ConvertShapeToLength(shape);
-      std::shared_ptr<void> data(malloc(size * sizeof(T)), free);
-      std::memcpy(data.get(), raw_data, size * sizeof(T));
-      AddInitializedTensor(tensor_name,  GetTemplatedType(T()), shape, data);
-   }
-
    void AddShapeTensor(const std::string & name, const std::vector<Dim> & shapeValues, bool scalar = false);
 
    void AddExtraCodeForDimShapes(const std::string & code) { fExtraCodeForDimShapes += code; }

tmva/sofie/src/RModel.cxx

@@ -229,6 +229,16 @@ void RModel::AddInitializedTensor(std::string tensor_name, ETensorType type, std
     fInitializedTensors[tensor_name] = new_tensor;
 }
 
+void RModel::AddInitializedTensor(const std::string &tensor_name, ETensorType tensor_type,
+                                  const std::vector<std::size_t> &shape, void *raw_data)
+{
+   size_t size = ConvertShapeToLength(shape);
+   auto itemsize = GetTypeSize(tensor_type);
+   std::shared_ptr<void> data(malloc(size * itemsize), free);
+   std::memcpy(data.get(), raw_data, size * itemsize);
+   AddInitializedTensor(tensor_name, tensor_type, shape, data);
+}
+
 void RModel::AddConstantTensor(std::string tensor_name, ETensorType type, std::vector<std::size_t> shape, std::shared_ptr<void> data) {
     tensor_name = UTILITY::Clean_name(tensor_name);
     //NB: own data