Merge pull request #23597 from dmatveev:dm/gapi_onnx_py_integration

dmatveev · web-flow · commit fc5d412ba738 · 2023-05-30T17:52:17.000+03:00
G-API: Integration branch for ONNX & Python-related changes #23597 # Changes overview ## 1. Expose ONNX backend's Normalization and Mean-value parameters in Python * Since Python G-API bindings rely on `Generic` infer to express Inference, the `Generic` specialization of `onnx::Params` was extended with new methods to control normalization (`/255`) and mean-value; these methods were exposed in the Python bindings * Found some questionable parts in the existing API which I'd like to review/discuss (see comments) UPD: 1. Thanks to @TolyaTalamanov normalization inconsistencies have been identified with `squeezenet1.0-9` ONNX model itself; tests using these model were updated to DISABLE normalization and NOT using mean/value. 2. Questionable parts were removed and tests still pass. ### Details (taken from @TolyaTalamanov's comment): `squeezenet1.0.*onnx` - doesn't require scaling to [0,1] and mean/std because the weights of the first convolution already scaled. ONNX documentation is broken. So the correct approach to use this models is: 1. ONNX: apply preprocessing from the documentation: https://github.com/onnx/models/blob/main/vision/classification/imagenet_preprocess.py#L8-L44 but without normalization step: ``` # DON'T DO IT: # mean_vec = np.array([0.485, 0.456, 0.406]) # stddev_vec = np.array([0.229, 0.224, 0.225]) # norm_img_data = np.zeros(img_data.shape).astype('float32') # for i in range(img_data.shape[0]): # norm_img_data[i,:,:] = (img_data[i,:,:]/255 - mean_vec[i]) / stddev_vec[i] # # add batch channel # norm_img_data = norm_img_data.reshape(1, 3, 224, 224).astype('float32') # return norm_img_data # INSTEAD return img_data.reshape(1, 3, 224, 224) ``` 2. G-API: Convert image from BGR to RGB and then pass to `apply` as-is with configuring parameters: ``` net = cv.gapi.onnx.params('squeezenet', model_filename) net.cfgNormalize('data_0', False) ``` **Note**: Results might be difference because `G-API` doesn't apply central crop but just do resize to model resolution. --- `squeezenet1.1.*onnx` - requires scaling to [0,1] and mean/std - onnx documentation is correct. 1. ONNX: apply preprocessing from the documentation: https://github.com/onnx/models/blob/main/vision/classification/imagenet_preprocess.py#L8-L44 2. G-API: Convert image from BGR to RGB and then pass to `apply` as-is with configuring parameters: ``` net = cv.gapi.onnx.params('squeezenet', model_filename) net.cfgNormalize('data_0', True) // default net.cfgMeanStd('data_0', [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ``` **Note**: Results might be difference because `G-API` doesn't apply central crop but just do resize to model resolution. ## 2. Expose Fluid & kernel package-related functionality in Python * `cv::gapi::combine()` * `cv::GKernelPackage::size()` (mainly for testing purposes) * `cv::gapi::imgproc::fluid::kernels()` Added a test for the above. ## 3. Fixed issues with Python stateful kernel handling Fixed error message when `outMeta()` of custom python operation fails. ## 4. Fixed various issues in Python tests 1. `test_gapi_streaming.py` - fixed behavior of Desync test to avoid sporadic issues 2. `test_gapi_infer_onnx.py` - fixed model lookup (it was still using the ONNX Zoo layout but was NOT using the proper env var we use to point to one). ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [x] The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp b/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp
@@ -13,7 +13,7 @@
 
 namespace cv { namespace gapi { namespace imgproc { namespace fluid {
 
-GAPI_EXPORTS GKernelPackage kernels();
+GAPI_EXPORTS_W GKernelPackage kernels();
 
 }}}}
 
diff --git a/modules/gapi/include/opencv2/gapi/gkernel.hpp b/modules/gapi/include/opencv2/gapi/gkernel.hpp
@@ -414,8 +414,8 @@ namespace cv {
     class GAPI_EXPORTS_W_SIMPLE GKernelPackage;
 
 namespace gapi {
-    GAPI_EXPORTS cv::GKernelPackage combine(const cv::GKernelPackage  &lhs,
-                                            const cv::GKernelPackage  &rhs);
+    GAPI_EXPORTS_W cv::GKernelPackage combine(const cv::GKernelPackage  &lhs,
+                                              const cv::GKernelPackage  &rhs);
 
     /// @private
     class GFunctor
@@ -513,7 +513,7 @@ namespace gapi {
          *
          * @return a number of kernels in the package
          */
-        std::size_t size() const;
+        GAPI_WRAP std::size_t size() const;
 
         /**
          * @brief Returns vector of transformations included in the package
@@ -717,6 +717,8 @@ namespace gapi {
     {
         return combine(a, combine(b, rest...));
     }
+    // NB(DM): Variadic-arg version in Python may require the same
+    // approach as used in GComputation::compile/apply.
 
     /** \addtogroup gapi_compile_args
      * @{
diff --git a/modules/gapi/include/opencv2/gapi/infer/bindings_onnx.hpp b/modules/gapi/include/opencv2/gapi/infer/bindings_onnx.hpp
@@ -26,6 +26,13 @@ class GAPI_EXPORTS_W_SIMPLE PyParams {
     GAPI_WRAP
     PyParams(const std::string& tag, const std::string& model_path);
 
+    GAPI_WRAP
+    PyParams& cfgMeanStd(const std::string &layer_name,
+                         const cv::Scalar &m,
+                         const cv::Scalar &s);
+    GAPI_WRAP
+    PyParams& cfgNormalize(const std::string &layer_name, bool flag);
+
     GBackend backend() const;
     std::string tag() const;
     cv::util::any params() const;
diff --git a/modules/gapi/include/opencv2/gapi/infer/ie.hpp b/modules/gapi/include/opencv2/gapi/infer/ie.hpp
@@ -242,7 +242,7 @@ template<typename Net> class Params {
     @param cfg Map of pairs: (config parameter name, config parameter value).
     @return reference to this parameter structure.
     */
-       Params& pluginConfig(const IEConfig& cfg) {
+    Params& pluginConfig(const IEConfig& cfg) {
         desc.config = cfg;
         return *this;
     }
diff --git a/modules/gapi/include/opencv2/gapi/infer/onnx.hpp b/modules/gapi/include/opencv2/gapi/infer/onnx.hpp
@@ -70,6 +70,14 @@ struct ParamDesc {
     std::vector<std::string> names_to_remap; //!< Names of output layers that will be processed in PostProc function.
 
     bool is_generic;
+
+    // TODO: Needs to modify the rest of ParamDesc accordingly to support
+    // both generic and non-generic options without duplication
+    // (as it was done for the OV IE backend)
+    // These values are pushed into the respective vector<> fields above
+    // when the generic infer parameters are unpacked (see GONNXBackendImpl::unpackKernel)
+    std::unordered_map<std::string, std::pair<cv::Scalar, cv::Scalar> > generic_mstd;
+    std::unordered_map<std::string, bool> generic_norm;
 };
 } // namespace detail
 
@@ -298,7 +306,17 @@ class Params<cv::gapi::Generic> {
     @param model_path path to model file (.onnx file).
     */
     Params(const std::string& tag, const std::string& model_path)
-         : desc{model_path, 0u, 0u, {}, {}, {}, {}, {}, {}, {}, {}, {}, true}, m_tag(tag) {}
+        : desc{model_path, 0u, 0u, {}, {}, {}, {}, {}, {}, {}, {}, {}, true, {}, {} }, m_tag(tag) {}
+
+    void cfgMeanStdDev(const std::string &layer,
+                       const cv::Scalar &m,
+                       const cv::Scalar &s) {
+        desc.generic_mstd[layer] = std::make_pair(m, s);
+    }
+
+    void cfgNormalize(const std::string &layer, bool flag) {
+        desc.generic_norm[layer] = flag;
+    }
 
     // BEGIN(G-API's network parametrization API)
     GBackend      backend() const { return cv::gapi::onnx::backend(); }
diff --git a/modules/gapi/misc/python/pyopencv_gapi.hpp b/modules/gapi/misc/python/pyopencv_gapi.hpp
@@ -785,39 +785,35 @@ static void unpackMetasToTuple(const cv::GMetaArgs&        meta,
     }
 }
 
-static cv::GArg setup_py(cv::detail::PyObjectHolder setup,
-                         const cv::GMetaArgs&       meta,
-                         const cv::GArgs&           gargs)
+static cv::GArg run_py_setup(cv::detail::PyObjectHolder setup,
+                             const cv::GMetaArgs        &meta,
+                             const cv::GArgs            &gargs)
 {
     PyGILState_STATE gstate;
     gstate = PyGILState_Ensure();
 
-    cv::GArg out;
-
+    cv::GArg state;
     try
     {
         // NB: Doesn't increase reference counter (false),
         // because PyObject already have ownership.
         // In case exception decrement reference counter.
         cv::detail::PyObjectHolder args(PyTuple_New(meta.size()), false);
         unpackMetasToTuple(meta, gargs, args);
-        // NB: Take an onwership because this state is "Python" type so it will be wrapped as-is
-        // into cv::GArg and stored in GPythonBackend. Object without ownership can't
-        // be dealocated outside this function.
-        cv::detail::PyObjectHolder result(PyObject_CallObject(setup.get(), args.get()), true);
 
+        PyObject *py_kernel_state = PyObject_CallObject(setup.get(), args.get());
         if (PyErr_Occurred())
         {
             PyErr_PrintEx(0);
             PyErr_Clear();
-            throw std::logic_error("Python kernel failed with error!");
+            throw std::logic_error("Python kernel setup failed with error!");
         }
         // NB: In fact it's impossible situation, because errors were handled above.
-        GAPI_Assert(result.get() && "Python kernel returned NULL!");
+        GAPI_Assert(py_kernel_state && "Python kernel setup returned NULL!");
 
-        if (!pyopencv_to(result.get(), out, ArgInfo("arg", false)))
+        if (!pyopencv_to(py_kernel_state, state, ArgInfo("arg", false)))
         {
-            util::throw_error(std::logic_error("Unsupported output meta type"));
+            util::throw_error(std::logic_error("Failed to convert python state"));
         }
     }
     catch (...)
@@ -826,7 +822,7 @@ static cv::GArg setup_py(cv::detail::PyObjectHolder setup,
         throw;
     }
     PyGILState_Release(gstate);
-    return out;
+    return state;
 }
 
 static GMetaArg get_meta_arg(PyObject* obj)
@@ -947,7 +943,7 @@ static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObjec
             gapi::python::GPythonFunctor f(
                 id.c_str(), std::bind(run_py_meta, cv::detail::PyObjectHolder{out_meta}, _1, _2),
                 std::bind(run_py_kernel, cv::detail::PyObjectHolder{run}, _1),
-                std::bind(setup_py, cv::detail::PyObjectHolder{setup}, _1, _2));
+                std::bind(run_py_setup, cv::detail::PyObjectHolder{setup}, _1, _2));
             pkg.include(f);
         }
         else
diff --git a/modules/gapi/misc/python/test/test_gapi_infer_onnx.py b/modules/gapi/misc/python/test/test_gapi_infer_onnx.py
@@ -14,21 +14,14 @@
     if sys.version_info[:2] < (3, 0):
         raise unittest.SkipTest('Python 2.x is not supported')
 
-    CLASSIFICATION_MODEL_PATH = "onnx_models/vision/classification/squeezenet/model/squeezenet1.0-9.onnx"
-
-    testdata_required = bool(os.environ.get('OPENCV_DNN_TEST_REQUIRE_TESTDATA', False))
+    CLASSIFICATION_MODEL_PATH = "vision/classification/squeezenet/model/squeezenet1.0-9.onnx"
 
     class test_gapi_infer(NewOpenCVTests):
-        def find_dnn_file(self, filename, required=None):
-            if not required:
-                required = testdata_required
-            return self.find_file(filename, [os.environ.get('OPENCV_DNN_TEST_DATA_PATH', os.getcwd()),
-                                            os.environ['OPENCV_TEST_DATA_PATH']],
-                                required=required)
+        def find_dnn_file(self, filename):
+            return self.find_file(filename, [os.environ.get('OPENCV_GAPI_ONNX_MODEL_PATH')], False)
 
         def test_onnx_classification(self):
             model_path = self.find_dnn_file(CLASSIFICATION_MODEL_PATH)
-
             if model_path is None:
                 raise unittest.SkipTest("Missing DNN test file")
 
@@ -45,6 +38,7 @@ def test_onnx_classification(self):
             comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
 
             net = cv.gapi.onnx.params("squeeze-net", model_path)
+            net.cfgNormalize("data_0", False)
             try:
                 out_gapi = comp.apply(cv.gin(in_mat), cv.gapi.compile_args(cv.gapi.networks(net)))
             except cv.error as err:
diff --git a/modules/gapi/misc/python/test/test_gapi_kernels.py b/modules/gapi/misc/python/test/test_gapi_kernels.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+import sys
+import unittest
+
+from tests_common import NewOpenCVTests
+
+
+try:
+
+    if sys.version_info[:2] < (3, 0):
+        raise unittest.SkipTest('Python 2.x is not supported')
+
+    class gapi_kernels_test(NewOpenCVTests):
+
+        def test_fluid_core_package(self):
+            fluid_core = cv.gapi.core.fluid.kernels()
+            self.assertLess(0, fluid_core.size())
+
+        def test_fluid_imgproc_package(self):
+            fluid_imgproc = cv.gapi.imgproc.fluid.kernels()
+            self.assertLess(0, fluid_imgproc.size())
+
+        def test_combine(self):
+            fluid_core = cv.gapi.core.fluid.kernels()
+            fluid_imgproc = cv.gapi.imgproc.fluid.kernels()
+            fluid = cv.gapi.combine(fluid_core, fluid_imgproc)
+            self.assertEqual(fluid_core.size() + fluid_imgproc.size(), fluid.size())
+
+except unittest.SkipTest as e:
+
+    message = str(e)
+
+    class TestSkip(unittest.TestCase):
+        def setUp(self):
+            self.skipTest('Skip tests: ' + message)
+
+        def test_skip():
+            pass
+
+    pass
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
diff --git a/modules/gapi/misc/python/test/test_gapi_stateful_kernel.py b/modules/gapi/misc/python/test/test_gapi_stateful_kernel.py
@@ -24,7 +24,7 @@ def __init__(self):
                 in_types=[cv.GOpaque.Int],
                 out_types=[cv.GOpaque.Int])
     class GStatefulCounter:
-        """Accumulate state counter on every call"""
+        """Accumulates state counter on every call"""
 
         @staticmethod
         def outMeta(desc):
@@ -45,6 +45,22 @@ def run(value, state):
             return state.counter
 
 
+    class SumState:
+        def __init__(self):
+            self.sum = 0
+
+
+    @cv.gapi.op('stateful_sum',
+                in_types=[cv.GOpaque.Int, cv.GOpaque.Int],
+                out_types=[cv.GOpaque.Int])
+    class GStatefulSum:
+        """Accumulates sum on every call"""
+
+        @staticmethod
+        def outMeta(lhs_desc, rhs_desc):
+            return cv.empty_gopaque_desc()
+
+
     class gapi_sample_pipelines(NewOpenCVTests):
         def test_stateful_kernel_single_instance(self):
             g_in  = cv.GOpaque.Int()
@@ -124,6 +140,64 @@ def test_stateful_reset(self):
             cc.stop()
 
 
+        def test_stateful_multiple_inputs(self):
+            @cv.gapi.kernel(GStatefulSum)
+            class GStatefulSumImpl:
+                """Implementation for GStatefulCounter operation."""
+
+                @staticmethod
+                def setup(lhs_desc, rhs_desc):
+                    return SumState()
+
+                @staticmethod
+                def run(lhs, rhs, state):
+                    state.sum+= lhs + rhs
+                    return state.sum
+
+
+            g_in1 = cv.GOpaque.Int()
+            g_in2 = cv.GOpaque.Int()
+            g_out = GStatefulSum.on(g_in1, g_in2)
+            comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
+            pkg  = cv.gapi.kernels(GStatefulSumImpl)
+
+            lhs_list = [1, 10, 15]
+            rhs_list = [2, 14, 32]
+
+            ref_out = 0
+            for lhs, rhs in zip(lhs_list, rhs_list):
+                ref_out += lhs + rhs
+                gapi_out = comp.apply(cv.gin(lhs, rhs), cv.gapi.compile_args(pkg))
+                self.assertEqual(ref_out, gapi_out)
+
+
+        def test_stateful_multiple_inputs_throw(self):
+            @cv.gapi.kernel(GStatefulSum)
+            class GStatefulSumImplIncorrect:
+                """Incorrect implementation for GStatefulCounter operation."""
+
+                # NB: setup methods is intentionally
+                # incorrect - accepts one meta arg instead of two
+                @staticmethod
+                def setup(desc):
+                    return SumState()
+
+                @staticmethod
+                def run(lhs, rhs, state):
+                    state.sum+= lhs + rhs
+                    return state.sum
+
+
+            g_in1 = cv.GOpaque.Int()
+            g_in2 = cv.GOpaque.Int()
+            g_out = GStatefulSum.on(g_in1, g_in2)
+            comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
+            pkg  = cv.gapi.kernels(GStatefulSumImplIncorrect)
+
+            with self.assertRaises(Exception): comp.apply(cv.gin(42, 42),
+                                                          args=cv.gapi.compile_args(pkg))
+
+
 except unittest.SkipTest as e:
 
     message = str(e)
diff --git a/modules/gapi/misc/python/test/test_gapi_streaming.py b/modules/gapi/misc/python/test/test_gapi_streaming.py
@@ -17,7 +17,7 @@
 
     @cv.gapi.op('custom.delay', in_types=[cv.GMat], out_types=[cv.GMat])
     class GDelay:
-        """Delay for 10 ms."""
+        """Delay for 50 ms."""
 
         @staticmethod
         def outMeta(desc):
@@ -30,7 +30,7 @@ class GDelayImpl:
 
         @staticmethod
         def run(img):
-            time.sleep(0.01)
+            time.sleep(0.05)
             return img
 
 
@@ -289,8 +289,7 @@ def test_desync(self):
             ccomp.start()
 
             # Assert
-            max_num_frames  = 10
-            proc_num_frames = 0
+            max_num_frames  = 50
 
             out_counter = 0
             desync_out_counter = 0
@@ -307,12 +306,11 @@ def test_desync(self):
                 else:
                     none_counter += 1
 
-                proc_num_frames += 1
-                if proc_num_frames == max_num_frames:
+                if out_counter == max_num_frames:
                     ccomp.stop()
                     break
 
-            self.assertLess(0, proc_num_frames)
+            self.assertLess(0, out_counter)
             self.assertLess(desync_out_counter, out_counter)
             self.assertLess(0, none_counter)
 
diff --git a/modules/gapi/src/backends/onnx/bindings_onnx.cpp b/modules/gapi/src/backends/onnx/bindings_onnx.cpp
diff --git a/modules/gapi/src/backends/onnx/gonnxbackend.cpp b/modules/gapi/src/backends/onnx/gonnxbackend.cpp
diff --git a/modules/gapi/test/infer/gapi_infer_onnx_test.cpp b/modules/gapi/test/infer/gapi_infer_onnx_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ template<typename Net> class Params {`
`242`	`242`	`@param cfg Map of pairs: (config parameter name, config parameter value).`
`243`	`243`	`@return reference to this parameter structure.`
`244`	`244`	`*/`
`245`		`- Params& pluginConfig(const IEConfig& cfg) {`
	`245`	`+ Params& pluginConfig(const IEConfig& cfg) {`
`246`	`246`	`desc.config = cfg;`
`247`	`247`	`return *this;`
`248`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -785,39 +785,35 @@ static void unpackMetasToTuple(const cv::GMetaArgs& meta,`
`785`	`785`	`}`
`786`	`786`	`}`
`787`	`787`
`788`		`-static cv::GArg setup_py(cv::detail::PyObjectHolder setup,`
`789`		`- const cv::GMetaArgs& meta,`
`790`		`- const cv::GArgs& gargs)`
	`788`	`+static cv::GArg run_py_setup(cv::detail::PyObjectHolder setup,`
	`789`	`+ const cv::GMetaArgs &meta,`
	`790`	`+ const cv::GArgs &gargs)`
`791`	`791`	`{`
`792`	`792`	`PyGILState_STATE gstate;`
`793`	`793`	`gstate = PyGILState_Ensure();`
`794`	`794`
`795`		`- cv::GArg out;`
`796`		`-`
	`795`	`+ cv::GArg state;`
`797`	`796`	`try`
`798`	`797`	`{`
`799`	`798`	`// NB: Doesn't increase reference counter (false),`
`800`	`799`	`// because PyObject already have ownership.`
`801`	`800`	`// In case exception decrement reference counter.`
`802`	`801`	`cv::detail::PyObjectHolder args(PyTuple_New(meta.size()), false);`
`803`	`802`	`unpackMetasToTuple(meta, gargs, args);`
`804`		`- // NB: Take an onwership because this state is "Python" type so it will be wrapped as-is`
`805`		`- // into cv::GArg and stored in GPythonBackend. Object without ownership can't`
`806`		`- // be dealocated outside this function.`
`807`		`- cv::detail::PyObjectHolder result(PyObject_CallObject(setup.get(), args.get()), true);`
`808`	`803`
	`804`	`+ PyObject *py_kernel_state = PyObject_CallObject(setup.get(), args.get());`
`809`	`805`	`if (PyErr_Occurred())`
`810`	`806`	`{`
`811`	`807`	`PyErr_PrintEx(0);`
`812`	`808`	`PyErr_Clear();`
`813`		`- throw std::logic_error("Python kernel failed with error!");`
	`809`	`+ throw std::logic_error("Python kernel setup failed with error!");`
`814`	`810`	`}`
`815`	`811`	`// NB: In fact it's impossible situation, because errors were handled above.`
`816`		`- GAPI_Assert(result.get() && "Python kernel returned NULL!");`
	`812`	`+ GAPI_Assert(py_kernel_state && "Python kernel setup returned NULL!");`
`817`	`813`
`818`		`- if (!pyopencv_to(result.get(), out, ArgInfo("arg", false)))`
	`814`	`+ if (!pyopencv_to(py_kernel_state, state, ArgInfo("arg", false)))`
`819`	`815`	`{`
`820`		`- util::throw_error(std::logic_error("Unsupported output meta type"));`
	`816`	`+ util::throw_error(std::logic_error("Failed to convert python state"));`
`821`	`817`	`}`
`822`	`818`	`}`
`823`	`819`	`catch (...)`
`@@ -826,7 +822,7 @@ static cv::GArg setup_py(cv::detail::PyObjectHolder setup,`
`826`	`822`	`throw;`
`827`	`823`	`}`
`828`	`824`	`PyGILState_Release(gstate);`
`829`		`- return out;`
	`825`	`+ return state;`
`830`	`826`	`}`
`831`	`827`
`832`	`828`	`static GMetaArg get_meta_arg(PyObject* obj)`
`@@ -947,7 +943,7 @@ static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObjec`
`947`	`943`	`gapi::python::GPythonFunctor f(`
`948`	`944`	`id.c_str(), std::bind(run_py_meta, cv::detail::PyObjectHolder{out_meta}, _1, _2),`
`949`	`945`	`std::bind(run_py_kernel, cv::detail::PyObjectHolder{run}, _1),`
`950`		`- std::bind(setup_py, cv::detail::PyObjectHolder{setup}, _1, _2));`
	`946`	`+ std::bind(run_py_setup, cv::detail::PyObjectHolder{setup}, _1, _2));`
`951`	`947`	`pkg.include(f);`
`952`	`948`	`}`
`953`	`949`	`else`