Adding tensor methods

pspp.jnl

@@ -1 +1,3 @@
 GET FILE="/home/rmontanana/Code/covbench/data/covid_v9_20220630.sav".
+SHOW SYSTEM.
+SHOW SYSTEM.

src/PyClassifier.cc

@@ -1,4 +1,5 @@
 #include "PyClassifier.h"
+#include <torch/csrc/autograd/python_variable.h>
 
 namespace pywrap {
 
@@ -13,13 +14,21 @@ namespace pywrap {
         pyWrap->clean(module, className);
     }
 
-    std::string PyClassifier::callMethod(const std::string& method)
+    std::string PyClassifier::version()
+    {
+        return pyWrap->version(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<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states)
     {
-
+        PyObject* Xp = NULL;//THPVariable_Wrap(X);
+        PyObject* yp = NULL;//THPVariable_Wrap(y);
+        pyWrap->fit(module, className, Xp, yp);
+        return *this;
     }
 
 } /* namespace PyWrap */

src/PyClassifier.h

@@ -12,7 +12,10 @@ namespace pywrap {
         PyClassifier(const std::string& module, const std::string& className);
         virtual ~PyClassifier();
         PyClassifier& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states);
-        std::string callMethod(const std::string& method);
+        torch::Tensor predict(torch::Tensor& X);
+        double score(torch::Tensor& X, torch::Tensor& y);
+        std::string version();
+        std::string callMethodString(const std::string& method);
     private:
         PyWrap* pyWrap;
         std::string module;

src/PyWrap.cc

@@ -83,34 +83,19 @@ namespace pywrap {
         PyErr_Print();
         exit(1);
     }
-    template<typename T>
+    PyObject* PyWrap::getClass(const std::string& moduleName, const std::string& className)
-    T PyWrap::callMethod(const std::string& moduleName, const std::string& className, const std::string& method)
     {
-        std::cout << "Llamando método" << std::endl;
         auto item = moduleClassMap.find({ moduleName, className });
         if (item == moduleClassMap.end()) {
             errorAbort("Module " + moduleName + " and class " + className + " not found");
         }
         std::cout << "Clase encontrada" << std::endl;
-        PyObject* instance = std::get<2>(item->second);
+        return std::get<2>(item->second);
-        PyObject* result;
-        if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL)))
-            errorAbort("Couldn't call method " + method);
-
-        T value = PyUnicode_AsUTF8(result);
-        std::cout << "Result: " << value << std::endl;
-        Py_DECREF(result);
-        return value;
     }
     std::string PyWrap::callMethodString(const std::string& moduleName, const std::string& className, const std::string& method)
     {
-        std::cout << "Llamando método" << std::endl;
+        std::cout << "Llamando método " << method << std::endl;
-        auto item = moduleClassMap.find({ moduleName, className });
+        PyObject* instance = getClass(moduleName, className);
-        if (item == moduleClassMap.end()) {
-            errorAbort("Module " + moduleName + " and class " + className + " not found");
-        }
-        std::cout << "Clase encontrada" << std::endl;
-        PyObject* instance = std::get<2>(item->second);
         PyObject* result;
         if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL)))
             errorAbort("Couldn't call method " + method);
@@ -120,6 +105,42 @@ namespace pywrap {
         Py_DECREF(result);
         return value;
     }
+    std::string PyWrap::version(const std::string& moduleName, const std::string& className)
+    {
+        return callMethodString(moduleName, className, "version");
+    }
+
+    void PyWrap::fit(const std::string& moduleName, const std::string& className, PyObject* X, PyObject* y)
+    {
+        std::cout << "Llamando método fit" << std::endl;
+        PyObject* instance = getClass(moduleName, className);
+        PyObject* result;
+        const char method[] = "fit";
+
+        if (!(result = PyObject_CallMethodObjArgs(instance, PyBytes_FromString(method), X, y, NULL)))
+            errorAbort("Couldn't call method fit");
+        Py_DECREF(result);
+    }
+    PyObject* PyWrap::predict(const std::string& moduleName, const std::string& className, PyObject* X)
+    {
+        std::cout << "Llamando método predict" << std::endl;
+        PyObject* instance = getClass(moduleName, className);
+        PyObject* result;
+        const char method[] = "predict";
+        if (!(result = PyObject_CallMethodObjArgs(instance, PyBytes_FromString(method), X, NULL)))
+            errorAbort("Couldn't call method predict");
+        return result; // The caller has to decref the result
+    }
+    double PyWrap::score(const std::string& moduleName, const std::string& className, PyObject* X, PyObject* y)
+    {
+        std::cout << "Llamando método score" << std::endl;
+        PyObject* instance = getClass(moduleName, className);
+        PyObject* result;
+        const char method[] = "score";
+        if (!(result = PyObject_CallMethodObjArgs(instance, PyBytes_FromString(method), X, y, NULL)))
+            errorAbort("Couldn't call method score");
+        return PyFloat_AsDouble(result);
+    }
     // void PyWrap::doCommand2()
 // {
 //     PyObject* list = Py_BuildValue("[s]", "Stree");

src/PyWrap.h

@@ -16,9 +16,6 @@ namespace pywrap {
         static PyWrap* GetInstance();
         void operator=(const PyWrap&) = delete;
         ~PyWrap();
-        template<typename T>
-        T callMethod(const std::string& moduleName, const std::string& className, const std::string& method);
-        std::string callMethodString(const std::string& moduleName, const std::string& className, const std::string& method);
         // template<typename T> T returnMethod(PyObject* result);
         // template<std::string> std::string returnMethod(PyObject* result);
         // template<int> int returnMethod(PyObject* result);
@@ -29,11 +26,18 @@ namespace pywrap {
         //     // at::Tensor& THPVariable_Unpack(PyObject * obj);
         //     return THPVariable_Unpack(result);
         // };
-        void importClass(const std::string& moduleName, const std::string& className);
+        // PyObject* callMethodArgs(const std::string& moduleName, const std::string& className, const std::string& method, PyObject* args);
+        void fit(const std::string& moduleName, const std::string& className, PyObject* X, PyObject* y);
+        PyObject* predict(const std::string& moduleName, const std::string& className, PyObject* X);
+        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);
+        double score(const std::string& moduleName, const std::string& className, PyObject* X, PyObject* y);
         void clean(const std::string& moduleName, const std::string& className);
+        void importClass(const std::string& moduleName, const std::string& className);
         // void doCommand2();
     private:
         PyWrap();
+        PyObject* getClass(const std::string& moduleName, const std::string& className);
         void errorAbort(const std::string& message);
         PyStatus initPython();
         static PyWrap* wrapper;

src/STree.cc

@@ -1,11 +1,6 @@
 #include "STree.h"
-#include <iostream>
 
 namespace pywrap {
 
-    void STree::version()
-    {
-        std::cout << "Version: " << callMethod("version") << std::endl;
-    }
 
 } /* namespace pywrap */

src/STree.h

@@ -7,7 +7,6 @@ namespace pywrap {
     public:
         STree() : PyClassifier("stree", "Stree") {};
         ~STree() = default;
-        void version();
     private:
 
     };

src/SVC.cc

@@ -1,11 +1,10 @@
 #include "SVC.h"
-#include <iostream>
 
 namespace pywrap {
 
-    void SVC::version()
+    std::string SVC::version()
     {
-        std::cout << "repr_html: " << callMethod("_repr_html_") << std::endl;
+        return callMethodString("_repr_html_");
     }
 
 } /* namespace pywrap */

src/SVC.h

@@ -7,7 +7,7 @@ namespace pywrap {
     public:
         SVC() : PyClassifier("sklearn.svm", "SVC") {};
         ~SVC() = default;
-        void version();
+        std::string version();
     private:
 
     };