[tmva][sofie] Drop NumPy C API dependency from SOFIE parsers

The PyTorch parser and the parser unit tests included
`<numpy/arrayobject.h>` and linked against `Python3::NumPy` purely to
read tensor shapes and data pointers
(`PyArray_NDIM`/`PyArray_DIM`/`PyArray_DATA`). This coupled SOFIE to a
specific NumPy ABI at build/link time, even though NumPy is only ever
needed at runtime to produce the arrays on the Python side.

This commit repaces these uses with the generic CPython API.

(cherry picked from commit f799703)

Author: guitargeek

cmake/modules/SearchInstalledSoftware.cmake

@@ -413,7 +413,7 @@ if(pyroot AND NOT (tpython OR tmva-pymva))
 elseif(tpython OR tmva-pymva)
   list(APPEND python_components Development)
 endif()
-if(tmva-pymva OR tmva-sofie)
+if(tmva-pymva)
   list(APPEND python_components NumPy)
 endif()
 find_package(Python3 3.10 COMPONENTS ${python_components})
@@ -1378,7 +1378,7 @@ if(tmva)
       endif()
     endif()
   endif()
-  if(tmva-pymva OR tmva-sofie)
+  if(tmva-pymva)
     if(fail-on-missing AND (NOT Python3_NumPy_FOUND OR NOT Python3_Development_FOUND))
       message(SEND_ERROR "TMVA: numpy python package or Python development package not found and tmva-pymva component required"
                           " (python executable: ${Python3_EXECUTABLE})")

tmva/sofie/test/CMakeLists.txt

@@ -146,7 +146,6 @@ if (tpython AND ROOT_TORCH_FOUND AND ROOT_ONNX_FOUND AND BLAS_FOUND AND NOT brok
         LIBRARIES
         ROOTTMVASofie
         TMVA
-        Python3::NumPy
         Python3::Python
         BLAS::BLAS
         INCLUDE_DIRS
@@ -165,7 +164,6 @@ if (tpython AND ROOT_KERAS_FOUND AND BLAS_FOUND)
    ROOT_ADD_GTEST(TestRModelParserKeras TestRModelParserKeras.C
        LIBRARIES
        ROOTTMVASofie
-       Python3::NumPy
        Python3::Python
        BLAS::BLAS
        INCLUDE_DIRS

tmva/sofie/test/TestRModelParserKeras.C

@@ -1,9 +1,8 @@
 #include <Python.h>
-#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#include <numpy/arrayobject.h>
 
 #include "gtest/gtest.h"
 #include <cmath>
+#include <vector>
 
 #include "TSystem.h"
 #include "TMVA/RSofieReader.hxx"
@@ -21,6 +20,20 @@ const char *PyStringAsString(PyObject *string)
    return cstring;
 }
 
+// Read a NumPy array bound in the Python namespace into a std::vector<float>.
+// The array is flattened to a Python list and read through the generic CPython
+// API, so this avoids any dependency on the NumPy C API (arrayobject.h).
+std::vector<float> GetTensorValues(PyObject *globalNS, PyObject *localNS, const char *name)
+{
+   std::string code = std::string("outputFlat=") + name + ".flatten().tolist()";
+   PyRun_String(code.c_str(), Py_single_input, globalNS, localNS);
+   PyObject *list = PyDict_GetItemString(localNS, "outputFlat");
+   std::vector<float> values(PyList_Size(list));
+   for (std::size_t i = 0; i < values.size(); ++i)
+      values[i] = (float)PyFloat_AsDouble(PyList_GetItem(list, i));
+   return values;
+}
+
 } // namespace
 
 void GenerateModels() {
@@ -78,15 +91,12 @@ TEST(RModelParser_Keras, SEQUENTIAL)
                                     "0.63637339, 0.94483464, 0.11032887, 0.22424818,"
                                     "0.50972592, 0.04671024, 0.39230661, 0.80500943]).reshape(4,8)",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputSequentialSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputSequential=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputSequentialSize=pOutputSequential.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputSequential.size(), pOutputSequentialSize);
 
-    PyArrayObject* pSequentialValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputSequential=(float*)PyArray_DATA(pSequentialValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputSequential.size(); ++i) {
       EXPECT_LE(std::abs(outputSequential[i] - pOutputSequential[i]), TOLERANCE);
@@ -124,15 +134,12 @@ TEST(RModelParser_Keras, FUNCTIONAL)
     PyRun_String("input=numpy.array([0.60828574, 0.50069386, 0.75186709, 0.14968806, 0.7692464 ,0.77027585, 0.75095316, 0.96651197,"
                                     "0.38536308, 0.95565917, 0.62796356, 0.13818375, 0.65484891,0.89220363, 0.23879365, 0.00635323]).reshape(2,8)",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputFunctionalSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputFunctional=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputFunctionalSize=pOutputFunctional.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputFunctional.size(), pOutputFunctionalSize);
 
-    PyArrayObject* pFunctionalValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputFunctional=(float*)PyArray_DATA(pFunctionalValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputFunctional.size(); ++i) {
       EXPECT_LE(std::abs(outputFunctional[i] - pOutputFunctional[i]), TOLERANCE);
@@ -169,15 +176,12 @@ TEST(RModelParser_Keras, BATCH_NORM)
     PyRun_String("input=numpy.array([0.22308163, 0.95274901, 0.44712538, 0.84640867,"
                                     "0.69947928, 0.29743695, 0.81379782, 0.39650574]).reshape(2,4)",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputBatchNormSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputBatchNorm=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputBatchNormSize=pOutputBatchNorm.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputBatchNorm.size(), pOutputBatchNormSize);
 
-    PyArrayObject* pBatchNormValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputBatchNorm=(float*)PyArray_DATA(pBatchNormValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputBatchNorm.size(); ++i) {
       EXPECT_LE(std::abs(outputBatchNorm[i] - pOutputBatchNorm[i]), TOLERANCE);
@@ -218,15 +222,12 @@ TEST(DISABLED_RModelParser_Keras, CONV_VALID)
     PyRun_String("model=load_model('KerasModelConv2D_Valid.keras')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.ones((1,4,4,1))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputConv2DValidSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputConv2DValid=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputConv2DValidSize=pOutputConv2DValid.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputConv2D_Valid.size(), pOutputConv2DValidSize);
 
-    PyArrayObject* pConv2DValidValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputConv2DValid=(float*)PyArray_DATA(pConv2DValidValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputConv2D_Valid.size(); ++i) {
       EXPECT_LE(std::abs(outputConv2D_Valid[i] - pOutputConv2DValid[i]), TOLERANCE);
@@ -268,15 +269,12 @@ TEST(DISABLED_RModelParser_Keras, CONV_SAME)
     PyRun_String("model=load_model('KerasModelConv2D_Same.keras')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.ones((1,4,4,1))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputConv2DSameSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputConv2DSame=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputConv2DSameSize=pOutputConv2DSame.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputConv2D_Same.size(), pOutputConv2DSameSize);
 
-    PyArrayObject* pConv2DSameValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputConv2DSame=(float*)PyArray_DATA(pConv2DSameValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputConv2D_Same.size(); ++i) {
       EXPECT_LE(std::abs(outputConv2D_Same[i] - pOutputConv2DSame[i]), TOLERANCE);
@@ -314,15 +312,12 @@ TEST(RModelParser_Keras, RESHAPE)
     PyRun_String("model=load_model('KerasModelReshape.keras')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.ones((1,4,4,1))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputReshapeSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputReshape=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputReshapeSize=pOutputReshape.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputReshape.size(), pOutputReshapeSize);
 
-    PyArrayObject* pReshapeValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputReshape=(float*)PyArray_DATA(pReshapeValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputReshape.size(); ++i) {
       EXPECT_LE(std::abs(outputReshape[i] - pOutputReshape[i]), TOLERANCE);
@@ -359,14 +354,12 @@ TEST(RModelParser_Keras, CONCATENATE)
     PyRun_String("input_1=numpy.ones((1,2))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input_2=numpy.ones((1,2))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model([input_1,input_2]).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    long pOutputConcatenateSize=PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputConcatenate=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    long pOutputConcatenateSize=(long)pOutputConcatenate.size();
 
     //Testing the actual and expected output tensor sizes (can fail if an error eccoured and returns a -1 from Python)
     EXPECT_EQ((long) outputConcatenate.size(), pOutputConcatenateSize);
 
-    PyArrayObject* pConcatenateValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputConcatenate=(float*)PyArray_DATA(pConcatenateValues);
 
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputConcatenate.size(); ++i) {
@@ -405,14 +398,12 @@ TEST(RModelParser_Keras, BINARY_OP)
     PyRun_String("input1=numpy.array([[1,2],[3,4]],dtype='float32')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input2=numpy.array([[5,6],[7,8]],dtype='float32')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model([input1,input2]).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    long pOutputBinaryOpSize=PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputBinaryOp=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    long pOutputBinaryOpSize=(long)pOutputBinaryOp.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ((long) outputBinaryOp.size(), pOutputBinaryOpSize);
 
-    PyArrayObject* pBinaryOpValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputBinaryOp=(float*)PyArray_DATA(pBinaryOpValues);
 
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputBinaryOp.size(); ++i) {
@@ -448,15 +439,12 @@ TEST(RModelParser_Keras, ACTIVATIONS)
     PyRun_String("model=load_model('KerasModelActivations.keras')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.ones((1,8))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputActivationsSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputActivations=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputActivationsSize=pOutputActivations.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputActivations.size(), pOutputActivationsSize);
 
-    PyArrayObject* pActivationsValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputActivations=(float*)PyArray_DATA(pActivationsValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputActivations.size(); ++i) {
       EXPECT_LE(std::abs(outputActivations[i] - pOutputActivations[i]), TOLERANCE);
@@ -491,15 +479,12 @@ TEST(RModelParser_Keras, SWISH)
     PyRun_String("model=load_model('KerasModelSwish.keras')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.ones((1,8))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutput=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputSize=pOutput.size();
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(output.size(), pOutputSize);
 
-    PyArrayObject* pValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutput=(float*)PyArray_DATA(pValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < output.size(); ++i) {
         EXPECT_LE(std::abs(output[i] - pOutput[i]), TOLERANCE);
@@ -537,8 +522,8 @@ TEST(RModel, CUSTOM_OP)
     PyRun_String("model.add(Lambda(lambda x: x * 2))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=numpy.array([1,1,1,1,1,1,1,1]).reshape(1,8)",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).numpy()",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputCustomOpSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    std::vector<float> pOutputCustomOp=GetTensorValues(fGlobalNS,fLocalNS,"output");
+    std::size_t pOutputCustomOpSize=pOutputCustomOp.size();
 
     // get input name for custom (it is output of one before last)
     PyRun_String("outputName = model.get_layer(index=len(model.layers)-2).output.name",Py_single_input,fGlobalNS,fLocalNS);
@@ -557,9 +542,6 @@ TEST(RModel, CUSTOM_OP)
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputCustomOp.size(), pOutputCustomOpSize);
 
-    PyArrayObject* pCustomOpValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputCustomOp=(float*)PyArray_DATA(pCustomOpValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputCustomOp.size(); ++i) {
         EXPECT_LE(std::abs(outputCustomOp[i] - pOutputCustomOp[i]), TOLERANCE);

tmva/sofie/test/TestRModelParserPyTorch.C

@@ -4,8 +4,6 @@
 
 #include <Python.h>
 #include "TSystem.h"
-#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#include <numpy/arrayobject.h>
 
 #include "gtest/gtest.h"
 #include <cmath>
@@ -60,18 +58,17 @@ TEST(RModelParser_PyTorch, SEQUENTIAL_MODEL)
                                                         "-0.7750, -1.6701,"
                                                         " 0.8171, -0.2858]),(2,4))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).detach().numpy().reshape(2,6)",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputSequentialSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    PyRun_String("outputFlat=output.flatten().tolist()",Py_single_input,fGlobalNS,fLocalNS);
+    PyObject* pSequentialValues=PyDict_GetItemString(fLocalNS,"outputFlat");
+    std::size_t pOutputSequentialSize=(std::size_t)PyList_Size(pSequentialValues);
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputSequential.size(), pOutputSequentialSize);
 
-    PyArrayObject* pSequentialValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputSequential=(float*)PyArray_DATA(pSequentialValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputSequential.size(); ++i) {
-      EXPECT_LE(std::abs(outputSequential[i] - pOutputSequential[i]), TOLERANCE);
+      float pOutputSequential=(float)PyFloat_AsDouble(PyList_GetItem(pSequentialValues, i));
+      EXPECT_LE(std::abs(outputSequential[i] - pOutputSequential), TOLERANCE);
     }
 
 }
@@ -114,18 +111,17 @@ TEST(RModelParser_PyTorch, MODULE_MODEL)
                                                        "-1.8818,  0.4736,"
                                                        " 1.1102,  1.8694]),(2,6))",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).detach().numpy().reshape(2,12)",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputModuleSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    PyRun_String("outputFlat=output.flatten().tolist()",Py_single_input,fGlobalNS,fLocalNS);
+    PyObject* pModuleValues=PyDict_GetItemString(fLocalNS,"outputFlat");
+    std::size_t pOutputModuleSize=(std::size_t)PyList_Size(pModuleValues);
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputModule.size(), pOutputModuleSize);
 
-    PyArrayObject* pModuleValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputModule=(float*)PyArray_DATA(pModuleValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputModule.size(); ++i) {
-      EXPECT_LE(std::abs(outputModule[i] - pOutputModule[i]), TOLERANCE);
+      float pOutputModule=(float)PyFloat_AsDouble(PyList_GetItem(pModuleValues, i));
+      EXPECT_LE(std::abs(outputModule[i] - pOutputModule), TOLERANCE);
     }
 }
 
@@ -158,17 +154,16 @@ TEST(RModelParser_PyTorch, CONVOLUTION_MODEL)
     PyRun_String("model=torch.jit.load('PyTorchModelConvolution.pt')",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("input=torch.arange(1,751,dtype=torch.float).reshape(5,6,5,5)",Py_single_input,fGlobalNS,fLocalNS);
     PyRun_String("output=model(input).detach().numpy().reshape(5,5,2,2)",Py_single_input,fGlobalNS,fLocalNS);
-    PyRun_String("outputSize=output.size",Py_single_input,fGlobalNS,fLocalNS);
-    std::size_t pOutputConvSize=(std::size_t)PyLong_AsLong(PyDict_GetItemString(fLocalNS,"outputSize"));
+    PyRun_String("outputFlat=output.flatten().tolist()",Py_single_input,fGlobalNS,fLocalNS);
+    PyObject* pConvValues=PyDict_GetItemString(fLocalNS,"outputFlat");
+    std::size_t pOutputConvSize=(std::size_t)PyList_Size(pConvValues);
 
     //Testing the actual and expected output tensor sizes
     EXPECT_EQ(outputConv.size(), pOutputConvSize);
 
-    PyArrayObject* pConvValues=(PyArrayObject*)PyDict_GetItemString(fLocalNS,"output");
-    float* pOutputConv=(float*)PyArray_DATA(pConvValues);
-
     //Testing the actual and expected output tensor values
     for (size_t i = 0; i < outputConv.size(); ++i) {
-      EXPECT_LE(std::abs(outputConv[i] - pOutputConv[i]), TOLERANCE);
+      float pOutputConv=(float)PyFloat_AsDouble(PyList_GetItem(pConvValues, i));
+      EXPECT_LE(std::abs(outputConv[i] - pOutputConv), TOLERANCE);
     }
 }

tmva/sofie_parsers/CMakeLists.txt

@@ -94,7 +94,6 @@ ROOT_LINKER_LIBRARY(ROOTTMVASofiePyParsers
     src/RModelParser_Keras.cxx
     src/RModelParser_PyTorch.cxx
   LIBRARIES
-    Python3::NumPy
     Python3::Python
     ROOTTMVASofie
 )