From ed21f90b69292c0c61deb318557b8c83cafa2002 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ricardo=20Monta=C3=B1ana=20G=C3=B3mez?= Date: Mon, 6 Nov 2023 15:22:27 +0100 Subject: [PATCH] Begin predict --- src/PyClassifier.cc | 61 +++++++++++++++++++++++++-------------------- src/PyClassifier.h | 2 -- src/PyWrap.cc | 28 +++++++-------------- src/PyWrap.h | 3 +-- src/STree.cc | 4 +-- src/STree.h | 1 - src/SVC.cc | 2 -- src/main.cc | 23 ++++++++--------- 8 files changed, 55 insertions(+), 69 deletions(-) diff --git a/src/PyClassifier.cc b/src/PyClassifier.cc index a97033f..39b8885 100644 --- a/src/PyClassifier.cc +++ b/src/PyClassifier.cc @@ -1,5 +1,5 @@ #include "PyClassifier.h" - +#include "numpy/arrayobject.h" #include namespace pywrap { @@ -16,11 +16,6 @@ namespace pywrap { pyWrap->clean(module, className); std::cout << "Classifier cleaned" << std::endl; } - void print_array(np::ndarray& array) - { - std::cout << "Array: " << std::endl; - std::cout << p::extract(p::str(array)) << std::endl; - } np::ndarray tensor2numpy(torch::Tensor& X) { int m = X.size(0); @@ -33,51 +28,63 @@ namespace pywrap { { int n = X.size(1); auto yn = np::from_data(y.data_ptr(), np::dtype::get_builtin(), p::make_tuple(n), p::make_tuple(sizeof(y.dtype()) * 2), p::object()); - //std::cout << "Printing from within tensors2numpy" << std::endl; - // print_array(yn); return { tensor2numpy(X), yn }; } std::string PyClassifier::version() { return pyWrap->version(module, className); } - std::string PyClassifier::graph() - { - return pyWrap->graph(module, className); - } std::string PyClassifier::callMethodString(const std::string& method) { return pyWrap->callMethodString(module, className, method); } - PyClassifier& PyClassifier::fit(torch::Tensor& X, torch::Tensor& y, const std::vector& features, const std::string& className, std::map>& states) { - std::cout << "PyClassifier:fit:Converting X to PyObject" << std::endl; auto [Xn, yn] = tensors2numpy(X, y); - CPyObject Xp = boost::python::incref(boost::python::object(Xn).ptr()); - std::cout << "PyClassifier:fit:Converting y to PyObject" << std::endl; - print_array(yn); - CPyObject yp = boost::python::incref(boost::python::object(yn).ptr()); - std::cout << "PyClassifier:fit:Calling fit" << std::endl; + CPyObject Xp = p::incref(p::object(Xn).ptr()); + CPyObject yp = p::incref(p::object(yn).ptr()); pyWrap->fit(module, this->className, Xp, yp); return *this; } + void print_array(np::ndarray& array) + { + std::cout << "Array: " << std::endl; + std::cout << p::extract(p::str(array)) << std::endl; + } torch::Tensor PyClassifier::predict(torch::Tensor& X) { + int dimension = X.size(1); auto Xn = tensor2numpy(X); - CPyObject Xp = boost::python::incref(boost::python::object(Xn).ptr()); - auto PyResult = pyWrap->predict(module, className, Xp); - auto result = torch::tensor({ 1,2,3 }); + CPyObject Xp = p::incref(p::object(Xn).ptr()); + PyObject* incoming = pyWrap->predict(module, className, Xp); + std::cout << "Return from predict" << std::endl; + p::handle<> handle(incoming); + p::object object(handle); + np::ndarray prediction = np::from_object(object); + print_array(prediction); + // import_array(); + // if (!PyArray_Check(incoming)) { + // throw std::logic_error("Returned value is not array"); + // } + // std::cout << "Returned value is array" << std::endl; + // PyArrayObject* np_ret = (PyArrayObject*)incoming; + // if (PyArray_NDIM(np_ret) != dimension - 1) { + // throw std::logic_error("Returned array has wrong dimension" + std::to_string(PyArray_NDIM(np_ret)) + "!=" + std::to_string(dimension - 1)); + // } + // std::cout << "Returned array has correct dimension" << PyArray_NDIM(np_ret) << std::endl; + // int len{ PyArray_SHAPE(np_ret)[0] }; + // int* data = reinterpret_cast(PyArray_DATA(np_ret)); - return result; + // int* data = reinterpret_cast(prediction.get_data()); + // auto resultTensor = torch::tensor({ data }, torch::kInt32); + auto resultTensor = torch::zeros({ prediction.shape(0) }, torch::kInt32); + return resultTensor; } double PyClassifier::score(torch::Tensor& X, torch::Tensor& y) { - std::cout << "PyClassifier::Score:Converting X to PyObject" << std::endl; auto [Xn, yn] = tensors2numpy(X, y); - CPyObject Xp = boost::python::incref(boost::python::object(Xn).ptr()); - CPyObject yp = boost::python::incref(boost::python::object(yn).ptr()); - print_array(yn); + CPyObject Xp = p::incref(p::object(Xn).ptr()); + CPyObject yp = p::incref(p::object(yn).ptr()); auto result = pyWrap->score(module, className, Xp, yp); return result; } diff --git a/src/PyClassifier.h b/src/PyClassifier.h index c777624..35f76a5 100644 --- a/src/PyClassifier.h +++ b/src/PyClassifier.h @@ -10,7 +10,6 @@ #include "PyWrap.h" namespace pywrap { - class PyClassifier { public: PyClassifier(const std::string& module, const std::string& className); @@ -19,7 +18,6 @@ namespace pywrap { torch::Tensor predict(torch::Tensor& X); double score(torch::Tensor& X, torch::Tensor& y); std::string version(); - std::string graph(); std::string callMethodString(const std::string& method); private: PyWrap* pyWrap; diff --git a/src/PyWrap.cc b/src/PyWrap.cc index 90e266b..f5f183f 100644 --- a/src/PyWrap.cc +++ b/src/PyWrap.cc @@ -47,12 +47,10 @@ namespace pywrap { } void PyWrap::importClass(const std::string& moduleName, const std::string& className) { - std::cout << "Importando clase" << std::endl; auto result = moduleClassMap.find({ moduleName, className }); if (result != moduleClassMap.end()) { return; } - std::cout << "No estaba en el mapa" << std::endl; CPyObject module = PyImport_ImportModule(moduleName.c_str()); if (PyErr_Occurred()) { errorAbort("Could't import module " + moduleName); @@ -75,12 +73,12 @@ namespace pywrap { void PyWrap::clean(const std::string& moduleName, const std::string& className) { std::lock_guard lock(mutex); - std::cout << "Limpiando" << std::endl; + std::cout << "Start cleaning " << moduleName << "." << className << std::endl; auto result = moduleClassMap.find({ moduleName, className }); if (result == moduleClassMap.end()) { return; } - std::cout << "--> Limpiando" << std::endl; + std::cout << "--> Cleaning PyObject" << std::endl; Py_DECREF(std::get<0>(result->second)); Py_DECREF(std::get<1>(result->second)); Py_DECREF(std::get<2>(result->second)); @@ -92,7 +90,7 @@ namespace pywrap { if (moduleClassMap.empty()) { RemoveInstance(); } - std::cout << "Limpieza terminada" << std::endl; + std::cout << "End Cleaning " << moduleName << "." << className << std::endl; } void PyWrap::errorAbort(const std::string& message) { @@ -107,12 +105,10 @@ namespace pywrap { if (item == moduleClassMap.end()) { errorAbort("Module " + moduleName + " and class " + className + " not found"); } - std::cout << "Clase encontrada" << std::endl; return std::get<2>(item->second); } std::string PyWrap::callMethodString(const std::string& moduleName, const std::string& className, const std::string& method) { - std::cout << "Llamando método " << method << std::endl; PyObject* instance = getClass(moduleName, className); PyObject* result; try { @@ -125,21 +121,15 @@ namespace pywrap { exit(1); } std::string value = PyUnicode_AsUTF8(result); - std::cout << "Result: " << value << std::endl; - Py_DECREF(result); + Py_XDECREF(result); return value; } std::string PyWrap::version(const std::string& moduleName, const std::string& className) { return callMethodString(moduleName, className, "version"); } - std::string PyWrap::graph(const std::string& moduleName, const std::string& className) - { - return callMethodString(moduleName, className, "graph"); - } void PyWrap::fit(const std::string& moduleName, const std::string& className, CPyObject& X, CPyObject& y) { - std::cout << "Llamando método fit" << std::endl; PyObject* instance = getClass(moduleName, className); CPyObject result; std::string method = "fit"; @@ -153,11 +143,12 @@ namespace pywrap { exit(1); } } - CPyObject PyWrap::predict(const std::string& moduleName, const std::string& className, CPyObject& X) + + PyObject* PyWrap::predict(const std::string& moduleName, const std::string& className, CPyObject& X) { std::cout << "Llamando método predict" << std::endl; - CPyObject instance = getClass(moduleName, className); - CPyObject result; + PyObject* instance = getClass(moduleName, className); + PyObject* result; std::string method = "predict"; try { if (!(result = PyObject_CallMethodObjArgs(instance, PyUnicode_FromString(method.c_str()), X.getObject(), NULL))) @@ -168,11 +159,10 @@ namespace pywrap { RemoveInstance(); exit(1); } - return result; + return result; // Caller must free this object } double PyWrap::score(const std::string& moduleName, const std::string& className, CPyObject& X, CPyObject& y) { - std::cout << "Llamando método score" << std::endl; PyObject* instance = getClass(moduleName, className); CPyObject result; std::string method = "score"; diff --git a/src/PyWrap.h b/src/PyWrap.h index 96edd79..4b271e8 100644 --- a/src/PyWrap.h +++ b/src/PyWrap.h @@ -22,9 +22,8 @@ namespace pywrap { ~PyWrap() = default; std::string callMethodString(const std::string& moduleName, const std::string& className, const std::string& method); std::string version(const std::string& moduleName, const std::string& className); - std::string graph(const std::string& moduleName, const std::string& className); void fit(const std::string& moduleName, const std::string& className, CPyObject& X, CPyObject& y); - CPyObject predict(const std::string& moduleName, const std::string& className, CPyObject& X); + PyObject* predict(const std::string& moduleName, const std::string& className, CPyObject& X); double score(const std::string& moduleName, const std::string& className, CPyObject& X, CPyObject& y); void clean(const std::string& moduleName, const std::string& className); void importClass(const std::string& moduleName, const std::string& className); diff --git a/src/STree.cc b/src/STree.cc index af247b9..15fa1b4 100644 --- a/src/STree.cc +++ b/src/STree.cc @@ -1,10 +1,8 @@ #include "STree.h" namespace pywrap { - std::string STree::graph() { - // return callMethodString("graph"); - return PyClassifier::graph(); + return callMethodString("graph"); } } /* namespace pywrap */ \ No newline at end of file diff --git a/src/STree.h b/src/STree.h index f2e1c37..4319ef2 100644 --- a/src/STree.h +++ b/src/STree.h @@ -9,6 +9,5 @@ namespace pywrap { ~STree() = default; std::string graph(); }; - } /* namespace pywrap */ #endif /* STREE_H */ \ No newline at end of file diff --git a/src/SVC.cc b/src/SVC.cc index 993ad5f..e299a40 100644 --- a/src/SVC.cc +++ b/src/SVC.cc @@ -1,10 +1,8 @@ #include "SVC.h" namespace pywrap { - std::string SVC::version() { return callMethodString("_repr_html_"); } - } /* namespace pywrap */ \ No newline at end of file diff --git a/src/main.cc b/src/main.cc index e2d642a..736b194 100644 --- a/src/main.cc +++ b/src/main.cc @@ -47,21 +47,18 @@ int main(int argc, char* argv[]) auto [X, y, features, className, states] = loadDataset("iris", true); cout << "X: " << X.sizes() << endl; cout << "y: " << y.sizes() << endl; - auto clf = pywrap::PyClassifier("stree", "Stree"); + auto clf = pywrap::STree(); cout << "STree Version: " << clf.version() << endl; - if (true) { - auto svc = pywrap::PyClassifier("sklearn.svm", "SVC"); - cout << "SVC Version: " << svc.callMethodString("_repr_html_") << endl; - cout << "Calling fit" << endl; - svc.fit(X, y, features, className, states); - cout << "Calling score" << endl; - cout << "SVC Score: " << svc.score(X, y) << endl; - } - cout << "Graph: " << clf.graph() << endl; - cout << "Calling fit" << endl; + // if (true) { + // auto svc = pywrap::SVC(); + // svc.fit(X, y, features, className, states); + // cout << "SVC Score: " << svc.score(X, y) << endl; + // } + // cout << "Graph: " << endl << clf.graph() << endl; clf.fit(X, y, features, className, states); - cout << "Calling score" << endl; - cout << "STree Score: " << clf.score(X, y) << endl; + // cout << "STree Score: " << clf.score(X, y) << endl; + auto prediction = clf.predict(X); + cout << "Prediction: " << prediction << endl; } cout << "* End." << endl; } \ No newline at end of file