rmontanana/PyWrap
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adding tensor methods

Browse Source
This commit is contained in:
Ricardo Montañana Gómez
2023-11-01 14:13:45 +01:00
parent cb3281ed91
commit 296ed6b785
9 changed files with 144 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pspp.jnl
View File

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

13
src/PyClassifier.cc
View File

@@ -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 */

5
src/PyClassifier.h
View File

@@ -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;

211
src/PyWrap.cc
View File

@@ -83,34 +83,19 @@ namespace pywrap {
PyErr_Print();
exit(1);
}
template<typename T>
T PyWrap::callMethod(const std::string& moduleName, const std::string& className, const std::string& method)
PyObject* PyWrap::getClass(const std::string& moduleName, const std::string& className)
{
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);
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;
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" << 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);
std::cout << "Llamando método " << method << std::endl;
PyObject* instance = getClass(moduleName, className);
PyObject* result;
if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL)))
errorAbort("Couldn't call method " + method);
@@ -120,83 +105,119 @@ namespace pywrap {
Py_DECREF(result);
return value;
}
// void PyWrap::doCommand2()
// {
// PyObject* list = Py_BuildValue("[s]", "Stree");
// // PyObject* module = PyImport_ImportModuleEx("stree", NULL, NULL, list);
// PyObject* module = PyImport_ImportModule("stree");
// if (PyErr_Occurred()) {
// PyErr_Print();
// cout << "Fails to obtain the module.\n";
// return;
// }
// cout << "Antes de empezar" << endl;
// if (module != nullptr) {
// cout << "Lo consiguió!!!" << endl;
// // dict is a borrowed reference.
// auto pdict = PyModule_GetDict(module);
// if (pdict == nullptr) {
// cout << "Fails to get the dictionary.\n";
// return;
// }
// Py_DECREF(module);
// PyObject* pKeys = PyDict_Keys(pdict);
// PyObject* pValues = PyDict_Values(pdict);
// map<string, string> my_map;
// cout << "size: " << PyDict_Size(pdict) << endl;
// char* cstr_key = new char[100];
// char* cstr_value = new char[500];
// for (Py_ssize_t i = 0; i < PyDict_Size(pdict); ++i) {
// PyArg_Parse(PyList_GetItem(pKeys, i), "s", &cstr_key);
// PyArg_Parse(PyList_GetItem(pValues, i), "s", &cstr_value);
// //cout << cstr<< " "<< cstr2 <<endl;
// my_map.emplace(cstr_key, cstr_value);
// }
// for (auto x : my_map) {
// cout << x.first << " : " << x.second << endl;
// }
// // Builds the name of a callable class
// const char* class_name = "Stree";
// auto python_class = PyDict_GetItemString(pdict, class_name);
// // if (PyErr_Occurred()) {
// // PyErr_Print();
// // cout << "Fails to obtain the class.\n";
// // return;
// // }
// if (python_class == nullptr) {
// cout << "Fails to get the Python class.\n";
// return;
// }
// Py_DECREF(pdict);
// cout << "Clase: " << python_class << endl;
// PyObject* object;
// // Creates an instance of the class
// if (PyCallable_Check(python_class)) {
// cout << "Es callable" << endl;
// object = PyObject_CallObject(python_class, NULL);
// Py_DECREF(python_class);
// } else {
// std::cout << "Cannot instantiate the Python class" << endl;
// Py_DECREF(python_class);
// return;
// }
// if (PyErr_Occurred()) {
// PyErr_Print();
// cout << "Fails to create the Python object.\n";
// return;
// }
// auto val = PyObject_CallMethod(object, "version", NULL);
// if (val != nullptr) {
// cout << "Valor: " << val << endl;
// } else {
// cout << "No se pudo ejecutar" << endl;
// }
std::string PyWrap::version(const std::string& moduleName, const std::string& className)
{
return callMethodString(moduleName, className, "version");
}
// } else {
// cout << "No lo consiguió :(" << endl;
// }
// Py_RunMain();
// }
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");
// // PyObject* module = PyImport_ImportModuleEx("stree", NULL, NULL, list);
// PyObject* module = PyImport_ImportModule("stree");
// if (PyErr_Occurred()) {
// PyErr_Print();
// cout << "Fails to obtain the module.\n";
// return;
// }
// cout << "Antes de empezar" << endl;
// if (module != nullptr) {
// cout << "Lo consiguió!!!" << endl;
// // dict is a borrowed reference.
// auto pdict = PyModule_GetDict(module);
// if (pdict == nullptr) {
// cout << "Fails to get the dictionary.\n";
// return;
// }
// Py_DECREF(module);
// PyObject* pKeys = PyDict_Keys(pdict);
// PyObject* pValues = PyDict_Values(pdict);
// map<string, string> my_map;
// cout << "size: " << PyDict_Size(pdict) << endl;
// char* cstr_key = new char[100];
// char* cstr_value = new char[500];
// for (Py_ssize_t i = 0; i < PyDict_Size(pdict); ++i) {
// PyArg_Parse(PyList_GetItem(pKeys, i), "s", &cstr_key);
// PyArg_Parse(PyList_GetItem(pValues, i), "s", &cstr_value);
// //cout << cstr<< " "<< cstr2 <<endl;
// my_map.emplace(cstr_key, cstr_value);
// }
// for (auto x : my_map) {
// cout << x.first << " : " << x.second << endl;
// }
// // Builds the name of a callable class
// const char* class_name = "Stree";
// auto python_class = PyDict_GetItemString(pdict, class_name);
// // if (PyErr_Occurred()) {
// // PyErr_Print();
// // cout << "Fails to obtain the class.\n";
// // return;
// // }
// if (python_class == nullptr) {
// cout << "Fails to get the Python class.\n";
// return;
// }
// Py_DECREF(pdict);
// cout << "Clase: " << python_class << endl;
// PyObject* object;
// // Creates an instance of the class
// if (PyCallable_Check(python_class)) {
// cout << "Es callable" << endl;
// object = PyObject_CallObject(python_class, NULL);
// Py_DECREF(python_class);
// } else {
// std::cout << "Cannot instantiate the Python class" << endl;
// Py_DECREF(python_class);
// return;
// }
// if (PyErr_Occurred()) {
// PyErr_Print();
// cout << "Fails to create the Python object.\n";
// return;
// }
// auto val = PyObject_CallMethod(object, "version", NULL);
// if (val != nullptr) {
// cout << "Valor: " << val << endl;
// } else {
// cout << "No se pudo ejecutar" << endl;
// }
// } else {
// cout << "No lo consiguió :(" << endl;
// }
// Py_RunMain();
// }
PyStatus PyWrap::initPython()
{

12
src/PyWrap.h
View File

@@ -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;

5
src/STree.cc
View File

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

1
src/STree.h
View File

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

5
src/SVC.cc
View File

@@ -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 */

2
src/SVC.h
View File

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