mirror of
https://github.com/pytorch/pytorch.git
synced 2025-11-04 08:00:58 +08:00
Delete dead Tensor code paths (#5417)
This deletes most of the dead Tensor code paths, including the TensorMethods cwrap and generic/Tensor.cpp. This also moves the THNN.cwrap/.cpp generation to generate_code which can use ninja if installed.
This commit is contained in:
Sam Gross
GitHub
@ -34,52 +34,17 @@
|
||||
#define WITH_NUMPY_IMPORT_ARRAY
|
||||
#include "THP.h"
|
||||
|
||||
#include "ModuleSparse.cpp"
|
||||
#include "DataLoader.cpp"
|
||||
|
||||
namespace py = pybind11;
|
||||
|
||||
PyObject* module;
|
||||
PyObject* tensor_classes;
|
||||
|
||||
PyObject *THPDefaultTensorClass = NULL;
|
||||
THPGenerator *THPDefaultGenerator = NULL;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static bool THPModule_loadClasses(PyObject *self)
|
||||
{
|
||||
#define ASSERT_NOT_NULL(ptr) if (!(ptr)) { THPUtils_setError("couldn't load classes"); return false; }
|
||||
PyObject *torch_module = PyImport_ImportModule("torch");
|
||||
if (!torch_module) {
|
||||
THPUtils_setError("class loader couldn't access torch module");
|
||||
return false;
|
||||
}
|
||||
|
||||
ASSERT_NOT_NULL(tensor_classes = PyObject_GetAttrString(torch_module, "_tensor_classes"));
|
||||
if (!THPDoubleTensor_postInit(torch_module)) return false;
|
||||
if (!THPFloatTensor_postInit(torch_module)) return false;
|
||||
if (!THPHalfTensor_postInit(torch_module)) return false;
|
||||
if (!THPLongTensor_postInit(torch_module)) return false;
|
||||
if (!THPIntTensor_postInit(torch_module)) return false;
|
||||
if (!THPShortTensor_postInit(torch_module)) return false;
|
||||
if (!THPCharTensor_postInit(torch_module)) return false;
|
||||
if (!THPByteTensor_postInit(torch_module)) return false;
|
||||
|
||||
THPDoubleStorage_postInit(torch_module);
|
||||
THPFloatStorage_postInit(torch_module);
|
||||
THPHalfStorage_postInit(torch_module);
|
||||
THPLongStorage_postInit(torch_module);
|
||||
THPIntStorage_postInit(torch_module);
|
||||
THPShortStorage_postInit(torch_module);
|
||||
THPCharStorage_postInit(torch_module);
|
||||
THPByteStorage_postInit(torch_module);
|
||||
|
||||
return true;
|
||||
#undef ASSERT_NOT_NULL
|
||||
}
|
||||
|
||||
static PyObject * THPModule_initNames(PyObject *self, PyObject *arg)
|
||||
{
|
||||
static std::vector<std::string> names;
|
||||
@ -104,43 +69,31 @@ static PyObject * THPModule_initNames(PyObject *self, PyObject *arg)
|
||||
}
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
static bool THPModule_assignStateless(PyObject *self)
|
||||
{
|
||||
#define INIT_STATELESS(type) \
|
||||
stateless = PyObject_CallFunctionObjArgs((PyObject*)&TH_CONCAT_2(type, TensorStatelessType), NULL); \
|
||||
if (!stateless) { \
|
||||
return false; \
|
||||
} \
|
||||
if (PyObject_SetAttrString(TH_CONCAT_3(THP,type,TensorClass), THP_STATELESS_ATTRIBUTE_NAME, stateless) == -1) { \
|
||||
return false; \
|
||||
}
|
||||
PyObject *stateless;
|
||||
INIT_STATELESS(Double);
|
||||
INIT_STATELESS(Float);
|
||||
INIT_STATELESS(Half);
|
||||
INIT_STATELESS(Long);
|
||||
INIT_STATELESS(Int);
|
||||
INIT_STATELESS(Short);
|
||||
INIT_STATELESS(Char);
|
||||
INIT_STATELESS(Byte);
|
||||
return true;
|
||||
#undef INIT_STATELESS
|
||||
}
|
||||
//
|
||||
// Callback for python part. Used for additional initialization of python classes
|
||||
static PyObject * THPModule_initExtension(PyObject *self, PyObject *shm_manager_path)
|
||||
static PyObject * THPModule_initExtension(PyObject *_unused, PyObject *shm_manager_path)
|
||||
{
|
||||
HANDLE_TH_ERRORS
|
||||
if (!THPUtils_checkString(shm_manager_path)) {
|
||||
THPUtils_setError("initialization error - expected bytes/string object as shm_manager_path!");
|
||||
return NULL;
|
||||
}
|
||||
torch::tensor::initialize_python_bindings();
|
||||
std::string path = THPUtils_unpackString(shm_manager_path);
|
||||
libshm_init(path.c_str());
|
||||
if (!THPModule_loadClasses(self)) return NULL;
|
||||
if (!THPModule_assignStateless(self)) return NULL;
|
||||
if (!THPAutograd_initFunctions(self)) return NULL;
|
||||
|
||||
auto module = THPObjectPtr(PyImport_ImportModule("torch"));
|
||||
if (!module) throw python_error();
|
||||
|
||||
THPDoubleStorage_postInit(module);
|
||||
THPFloatStorage_postInit(module);
|
||||
THPHalfStorage_postInit(module);
|
||||
THPLongStorage_postInit(module);
|
||||
THPIntStorage_postInit(module);
|
||||
THPShortStorage_postInit(module);
|
||||
THPCharStorage_postInit(module);
|
||||
THPByteStorage_postInit(module);
|
||||
THPAutograd_initFunctions();
|
||||
Py_RETURN_NONE;
|
||||
END_HANDLE_TH_ERRORS
|
||||
}
|
||||
@ -158,19 +111,10 @@ static PyObject * THPModule_setNumThreads(PyObject *module, PyObject *arg)
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
bool THPModule_isTensor(PyObject *obj)
|
||||
{
|
||||
int result = PySet_Contains(tensor_classes, (PyObject*)Py_TYPE(obj));
|
||||
if (result == -1)
|
||||
throw std::logic_error("FATAL: tensor_classes isn't a set!");
|
||||
return result;
|
||||
}
|
||||
|
||||
PyObject * THPModule_setDefaultTensorType(PyObject *_unused, PyObject *type)
|
||||
{
|
||||
HANDLE_TH_ERRORS
|
||||
torch::tensor::py_set_default_tensor_type(type);
|
||||
THPDefaultTensorClass = type;
|
||||
Py_RETURN_NONE;
|
||||
END_HANDLE_TH_ERRORS
|
||||
}
|
||||
@ -182,219 +126,6 @@ PyObject * THPModule_fromNumpy(PyObject *_unused, PyObject *array)
|
||||
END_HANDLE_TH_ERRORS
|
||||
}
|
||||
|
||||
/**
|
||||
* STATELESS FUNCTIONS
|
||||
**/
|
||||
|
||||
static PyObject * findTensor(PyObject *args, PyObject *kwargs) {
|
||||
for (Py_ssize_t i = 0; i < PyTuple_Size(args); i++) {
|
||||
PyObject *item = PyTuple_GET_ITEM(args, i);
|
||||
if (THPModule_isTensor(item) || THPVariable_Check(item)) {
|
||||
return item;
|
||||
}
|
||||
}
|
||||
if (kwargs) {
|
||||
Py_ssize_t pos = 0;
|
||||
PyObject *key, *value;
|
||||
while (PyDict_Next(kwargs, &pos, &key, &value)) {
|
||||
if (THPModule_isTensor(value) || THPVariable_Check(value)) {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return THPDefaultTensorClass;
|
||||
}
|
||||
|
||||
static PyObject * dispatchStateless(PyObject *args, PyObject *kwargs, const char *name) {
|
||||
PyObject *tensor = findTensor(args, kwargs);
|
||||
return THPUtils_dispatchStateless(tensor, name, args, kwargs);
|
||||
}
|
||||
|
||||
#define IMPLEMENT_STATELESS(name) \
|
||||
static PyObject * TH_CONCAT_2(THPModule_, name)(PyObject *_unused, PyObject *args, PyObject *kwargs) \
|
||||
{ \
|
||||
return dispatchStateless(args, kwargs, #name); \
|
||||
}
|
||||
|
||||
IMPLEMENT_STATELESS(sigmoid)
|
||||
IMPLEMENT_STATELESS(log)
|
||||
IMPLEMENT_STATELESS(log1p)
|
||||
IMPLEMENT_STATELESS(lgamma)
|
||||
IMPLEMENT_STATELESS(digamma)
|
||||
IMPLEMENT_STATELESS(polygamma)
|
||||
IMPLEMENT_STATELESS(erf)
|
||||
IMPLEMENT_STATELESS(erfinv)
|
||||
IMPLEMENT_STATELESS(exp)
|
||||
IMPLEMENT_STATELESS(expm1)
|
||||
IMPLEMENT_STATELESS(cos)
|
||||
IMPLEMENT_STATELESS(acos)
|
||||
IMPLEMENT_STATELESS(cosh)
|
||||
IMPLEMENT_STATELESS(sin)
|
||||
IMPLEMENT_STATELESS(asin)
|
||||
IMPLEMENT_STATELESS(sinh)
|
||||
IMPLEMENT_STATELESS(tan)
|
||||
IMPLEMENT_STATELESS(atan)
|
||||
IMPLEMENT_STATELESS(tanh)
|
||||
IMPLEMENT_STATELESS(sqrt)
|
||||
IMPLEMENT_STATELESS(rsqrt)
|
||||
IMPLEMENT_STATELESS(ceil)
|
||||
IMPLEMENT_STATELESS(floor)
|
||||
IMPLEMENT_STATELESS(round)
|
||||
IMPLEMENT_STATELESS(abs)
|
||||
IMPLEMENT_STATELESS(trunc)
|
||||
IMPLEMENT_STATELESS(frac)
|
||||
IMPLEMENT_STATELESS(mean)
|
||||
IMPLEMENT_STATELESS(std)
|
||||
IMPLEMENT_STATELESS(var)
|
||||
IMPLEMENT_STATELESS(norm)
|
||||
IMPLEMENT_STATELESS(reciprocal)
|
||||
IMPLEMENT_STATELESS(neg)
|
||||
IMPLEMENT_STATELESS(add)
|
||||
IMPLEMENT_STATELESS(mul)
|
||||
IMPLEMENT_STATELESS(div)
|
||||
IMPLEMENT_STATELESS(fmod)
|
||||
IMPLEMENT_STATELESS(min)
|
||||
IMPLEMENT_STATELESS(max)
|
||||
IMPLEMENT_STATELESS(dot)
|
||||
IMPLEMENT_STATELESS(sum)
|
||||
IMPLEMENT_STATELESS(prod)
|
||||
IMPLEMENT_STATELESS(remainder)
|
||||
IMPLEMENT_STATELESS(cumsum)
|
||||
IMPLEMENT_STATELESS(cumprod)
|
||||
IMPLEMENT_STATELESS(clamp)
|
||||
IMPLEMENT_STATELESS(equal)
|
||||
IMPLEMENT_STATELESS(eye)
|
||||
IMPLEMENT_STATELESS(diag)
|
||||
IMPLEMENT_STATELESS(numel)
|
||||
IMPLEMENT_STATELESS(sign)
|
||||
IMPLEMENT_STATELESS(trace)
|
||||
IMPLEMENT_STATELESS(tril)
|
||||
IMPLEMENT_STATELESS(triu)
|
||||
IMPLEMENT_STATELESS(zero)
|
||||
IMPLEMENT_STATELESS(kthvalue)
|
||||
IMPLEMENT_STATELESS(mode)
|
||||
IMPLEMENT_STATELESS(median)
|
||||
IMPLEMENT_STATELESS(cross)
|
||||
IMPLEMENT_STATELESS(sort)
|
||||
IMPLEMENT_STATELESS(topk)
|
||||
IMPLEMENT_STATELESS(t)
|
||||
IMPLEMENT_STATELESS(transpose)
|
||||
IMPLEMENT_STATELESS(squeeze)
|
||||
IMPLEMENT_STATELESS(unsqueeze)
|
||||
IMPLEMENT_STATELESS(renorm)
|
||||
IMPLEMENT_STATELESS(dist)
|
||||
IMPLEMENT_STATELESS(linspace)
|
||||
IMPLEMENT_STATELESS(logspace)
|
||||
IMPLEMENT_STATELESS(histc)
|
||||
IMPLEMENT_STATELESS(atan2)
|
||||
IMPLEMENT_STATELESS(pow)
|
||||
IMPLEMENT_STATELESS(lerp)
|
||||
IMPLEMENT_STATELESS(zeros)
|
||||
IMPLEMENT_STATELESS(zeros_like)
|
||||
IMPLEMENT_STATELESS(ones)
|
||||
IMPLEMENT_STATELESS(ones_like)
|
||||
IMPLEMENT_STATELESS(index_select)
|
||||
IMPLEMENT_STATELESS(take)
|
||||
IMPLEMENT_STATELESS(ger)
|
||||
IMPLEMENT_STATELESS(mv)
|
||||
IMPLEMENT_STATELESS(mm)
|
||||
IMPLEMENT_STATELESS(bmm)
|
||||
// TODO: this doesn't implement options that return numbers!
|
||||
IMPLEMENT_STATELESS(multinomial)
|
||||
IMPLEMENT_STATELESS(normal)
|
||||
IMPLEMENT_STATELESS(_standard_gamma)
|
||||
IMPLEMENT_STATELESS(_dirichlet_grad)
|
||||
IMPLEMENT_STATELESS(bernoulli)
|
||||
IMPLEMENT_STATELESS(range)
|
||||
IMPLEMENT_STATELESS(arange)
|
||||
IMPLEMENT_STATELESS(gather)
|
||||
IMPLEMENT_STATELESS(rand)
|
||||
IMPLEMENT_STATELESS(randn)
|
||||
IMPLEMENT_STATELESS(masked_select)
|
||||
IMPLEMENT_STATELESS(gesv)
|
||||
IMPLEMENT_STATELESS(gels)
|
||||
IMPLEMENT_STATELESS(trtrs)
|
||||
IMPLEMENT_STATELESS(symeig)
|
||||
IMPLEMENT_STATELESS(eig)
|
||||
IMPLEMENT_STATELESS(svd)
|
||||
IMPLEMENT_STATELESS(inverse)
|
||||
IMPLEMENT_STATELESS(potrf)
|
||||
IMPLEMENT_STATELESS(potrs)
|
||||
IMPLEMENT_STATELESS(potri)
|
||||
IMPLEMENT_STATELESS(pstrf)
|
||||
IMPLEMENT_STATELESS(qr)
|
||||
IMPLEMENT_STATELESS(geqrf)
|
||||
IMPLEMENT_STATELESS(orgqr)
|
||||
IMPLEMENT_STATELESS(ormqr)
|
||||
IMPLEMENT_STATELESS(btrifact)
|
||||
IMPLEMENT_STATELESS(btrifact_with_info)
|
||||
IMPLEMENT_STATELESS(btrisolve)
|
||||
IMPLEMENT_STATELESS(gt)
|
||||
IMPLEMENT_STATELESS(lt)
|
||||
IMPLEMENT_STATELESS(ge)
|
||||
IMPLEMENT_STATELESS(le)
|
||||
IMPLEMENT_STATELESS(eq)
|
||||
IMPLEMENT_STATELESS(ne)
|
||||
|
||||
IMPLEMENT_STATELESS(addmm)
|
||||
IMPLEMENT_STATELESS(addmv)
|
||||
IMPLEMENT_STATELESS(addr)
|
||||
IMPLEMENT_STATELESS(addbmm)
|
||||
IMPLEMENT_STATELESS(baddbmm)
|
||||
IMPLEMENT_STATELESS(addcmul)
|
||||
IMPLEMENT_STATELESS(addcdiv)
|
||||
|
||||
#undef IMPLEMENT_STATELESS
|
||||
|
||||
// In nonzero, the first argument might be a LongTensor that will be used
|
||||
// for indices output, so we should pick a function based on second
|
||||
// tensor's type.
|
||||
static PyObject * THPModule_nonzero(PyObject *_unused, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *tensor = THPDefaultTensorClass;
|
||||
if (PyTuple_Size(args) == 1)
|
||||
tensor = PyTuple_GET_ITEM(args, 0);
|
||||
else if (PyTuple_Size(args) == 2)
|
||||
tensor = PyTuple_GET_ITEM(args, 1);
|
||||
return THPUtils_dispatchStateless(tensor, "nonzero", args, kwargs);
|
||||
}
|
||||
|
||||
static PyObject * THPModule_randperm(PyObject *_unused, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *tensor = THPLongTensorClass;
|
||||
PyObject *out;
|
||||
if (kwargs && (out = PyDict_GetItemString(kwargs, "out")))
|
||||
tensor = out;
|
||||
return THPUtils_dispatchStateless(tensor, "randperm", args, kwargs);
|
||||
}
|
||||
|
||||
static PyObject * THPModule_cat(PyObject *_unused, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *tensor = THPDefaultTensorClass;
|
||||
THPObjectPtr iterator;
|
||||
THPObjectPtr item;
|
||||
PyObject *first_arg=nullptr;
|
||||
if (args && PyTuple_GET_SIZE(args) > 0) {
|
||||
first_arg = PyTuple_GET_ITEM(args, 0);
|
||||
} else if (kwargs && PyTuple_GET_ITEM(args, 0)) {
|
||||
first_arg = PyDict_GetItemString(kwargs, "seq");
|
||||
}
|
||||
|
||||
if (first_arg) {
|
||||
if (THPModule_isTensor(first_arg)) {
|
||||
tensor = first_arg;
|
||||
} else if (PySequence_Check(first_arg)) {
|
||||
item = PySequence_GetItem(first_arg, 0);
|
||||
if (item && (THPModule_isTensor(item) || THPVariable_Check(item))) {
|
||||
tensor = item;
|
||||
}
|
||||
}
|
||||
PyErr_Clear();
|
||||
}
|
||||
|
||||
return THPUtils_dispatchStateless(tensor, "cat", args, kwargs);
|
||||
}
|
||||
|
||||
PyObject *THPModule_safeCall(PyObject *_unused, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *result = NULL;
|
||||
@ -600,30 +331,13 @@ PyObject *THPModule_setFlushDenormal(PyObject *_unused, PyObject *arg) {
|
||||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
static PyObject* THPModule_initializeTensorTypeBindings(PyObject *_unused)
|
||||
{
|
||||
HANDLE_TH_ERRORS
|
||||
torch::tensor::initialize_python_bindings(nullptr);
|
||||
Py_RETURN_NONE;
|
||||
END_HANDLE_TH_ERRORS
|
||||
}
|
||||
|
||||
#ifdef WITH_CUDA
|
||||
extern PyObject * THCSPModule_initExtension(PyObject *self);
|
||||
#endif
|
||||
|
||||
static PyMethodDef TorchMethods[] = {
|
||||
{"_initExtension", (PyCFunction)THPModule_initExtension, METH_O, NULL},
|
||||
{"_autograd_init", (PyCFunction)THPAutograd_initExtension, METH_NOARGS, NULL},
|
||||
{"_add_docstr", (PyCFunction)THPModule_addDocStr, METH_VARARGS, NULL},
|
||||
{"_sparse_init", (PyCFunction)THSPModule_initExtension, METH_NOARGS, NULL},
|
||||
{"_init_names", (PyCFunction)THPModule_initNames, METH_O, NULL},
|
||||
{"_has_distributed",(PyCFunction)THPModule_hasDistributed, METH_NOARGS, NULL},
|
||||
{"_initialize_dtypes",(PyCFunction)THPModule_initializeDtypes, METH_NOARGS, NULL},
|
||||
{"_initialize_tensor_type_bindings", (PyCFunction)THPModule_initializeTensorTypeBindings, METH_NOARGS, NULL},
|
||||
#ifdef WITH_CUDA
|
||||
{"_cuda_sparse_init", (PyCFunction)THCSPModule_initExtension, METH_NOARGS, NULL},
|
||||
#endif
|
||||
{"_safe_call", (PyCFunction)THPModule_safeCall, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"_set_default_tensor_type", (PyCFunction)THPModule_setDefaultTensorType, METH_O, NULL},
|
||||
{"_infer_size", (PyCFunction)THPModule_inferSize, METH_VARARGS, NULL},
|
||||
@ -643,141 +357,11 @@ static PyMethodDef TorchMethods[] = {
|
||||
{"_to_dlpack", (PyCFunction)THPModule_toDLPack, METH_O, NULL},
|
||||
{"_from_dlpack", (PyCFunction)THPModule_fromDLPack, METH_O, NULL},
|
||||
{"set_flush_denormal", (PyCFunction)THPModule_setFlushDenormal, METH_O, NULL},
|
||||
|
||||
{"sigmoid", (PyCFunction)THPModule_sigmoid, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"log", (PyCFunction)THPModule_log, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"log1p", (PyCFunction)THPModule_log1p, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"lgamma", (PyCFunction)THPModule_lgamma, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"digamma", (PyCFunction)THPModule_digamma, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"polygamma", (PyCFunction)THPModule_polygamma, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"erf", (PyCFunction)THPModule_erf, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"erfinv", (PyCFunction)THPModule_erfinv, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"exp", (PyCFunction)THPModule_exp, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"expm1", (PyCFunction)THPModule_expm1, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cos", (PyCFunction)THPModule_cos, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"acos", (PyCFunction)THPModule_acos, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cosh", (PyCFunction)THPModule_cosh, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sin", (PyCFunction)THPModule_sin, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"asin", (PyCFunction)THPModule_asin, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sinh", (PyCFunction)THPModule_sinh, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"tan", (PyCFunction)THPModule_tan, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"atan", (PyCFunction)THPModule_atan, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"tanh", (PyCFunction)THPModule_tanh, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sqrt", (PyCFunction)THPModule_sqrt, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"rsqrt", (PyCFunction)THPModule_rsqrt, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ceil", (PyCFunction)THPModule_ceil, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"floor", (PyCFunction)THPModule_floor, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"round", (PyCFunction)THPModule_round, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"abs", (PyCFunction)THPModule_abs, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"trunc", (PyCFunction)THPModule_trunc, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"frac", (PyCFunction)THPModule_frac, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"mean", (PyCFunction)THPModule_mean, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"std", (PyCFunction)THPModule_std, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"var", (PyCFunction)THPModule_var, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"norm", (PyCFunction)THPModule_norm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"reciprocal", (PyCFunction)THPModule_reciprocal, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"neg", (PyCFunction)THPModule_neg, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"add", (PyCFunction)THPModule_add, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"mul", (PyCFunction)THPModule_mul, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"div", (PyCFunction)THPModule_div, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"fmod", (PyCFunction)THPModule_fmod, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"min", (PyCFunction)THPModule_min, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"max", (PyCFunction)THPModule_max, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"dot", (PyCFunction)THPModule_dot, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sum", (PyCFunction)THPModule_sum, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"prod", (PyCFunction)THPModule_prod, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"remainder", (PyCFunction)THPModule_remainder, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cumsum", (PyCFunction)THPModule_cumsum, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cumprod", (PyCFunction)THPModule_cumprod, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"clamp", (PyCFunction)THPModule_clamp, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"equal", (PyCFunction)THPModule_equal, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"eye", (PyCFunction)THPModule_eye, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"diag", (PyCFunction)THPModule_diag, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"numel", (PyCFunction)THPModule_numel, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sign", (PyCFunction)THPModule_sign, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"trace", (PyCFunction)THPModule_trace, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"tril", (PyCFunction)THPModule_tril, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"triu", (PyCFunction)THPModule_triu, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"zero", (PyCFunction)THPModule_zero, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"gt", (PyCFunction)THPModule_gt, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"lt", (PyCFunction)THPModule_lt, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ge", (PyCFunction)THPModule_ge, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"le", (PyCFunction)THPModule_le, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"eq", (PyCFunction)THPModule_eq, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ne", (PyCFunction)THPModule_ne, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"kthvalue", (PyCFunction)THPModule_kthvalue, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"mode", (PyCFunction)THPModule_mode, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"median", (PyCFunction)THPModule_median, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cross", (PyCFunction)THPModule_cross, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"sort", (PyCFunction)THPModule_sort, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"topk", (PyCFunction)THPModule_topk, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"t", (PyCFunction)THPModule_t, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"transpose", (PyCFunction)THPModule_transpose, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"squeeze", (PyCFunction)THPModule_squeeze, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"unsqueeze", (PyCFunction)THPModule_unsqueeze, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"nonzero", (PyCFunction)THPModule_nonzero, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"renorm", (PyCFunction)THPModule_renorm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"dist", (PyCFunction)THPModule_dist, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"linspace", (PyCFunction)THPModule_linspace, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"logspace", (PyCFunction)THPModule_logspace, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"histc", (PyCFunction)THPModule_histc, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"atan2", (PyCFunction)THPModule_atan2, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"pow", (PyCFunction)THPModule_pow, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"lerp", (PyCFunction)THPModule_lerp, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"zeros", (PyCFunction)THPModule_zeros, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"zeros_like", (PyCFunction)THPModule_zeros_like, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ones", (PyCFunction)THPModule_ones, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ones_like", (PyCFunction)THPModule_ones_like, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"index_select", (PyCFunction)THPModule_index_select, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"take", (PyCFunction)THPModule_take, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addmm", (PyCFunction)THPModule_addmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addmv", (PyCFunction)THPModule_addmv, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addr", (PyCFunction)THPModule_addr, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ger", (PyCFunction)THPModule_ger, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"mv", (PyCFunction)THPModule_mv, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addbmm", (PyCFunction)THPModule_addbmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"baddbmm", (PyCFunction)THPModule_baddbmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addcmul", (PyCFunction)THPModule_addcmul, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"addcdiv", (PyCFunction)THPModule_addcdiv, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"mm", (PyCFunction)THPModule_mm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"bmm", (PyCFunction)THPModule_bmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"multinomial", (PyCFunction)THPModule_multinomial, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"normal", (PyCFunction)THPModule_normal, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"_standard_gamma", (PyCFunction)THPModule__standard_gamma, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"_dirichlet_grad", (PyCFunction)THPModule__dirichlet_grad, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"bernoulli", (PyCFunction)THPModule_bernoulli, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"rand", (PyCFunction)THPModule_rand, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"randn", (PyCFunction)THPModule_randn, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"randperm", (PyCFunction)THPModule_randperm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"range", (PyCFunction)THPModule_range, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"arange", (PyCFunction)THPModule_arange, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"gather", (PyCFunction)THPModule_gather, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"cat", (PyCFunction)THPModule_cat, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"masked_select", (PyCFunction)THPModule_masked_select, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"gesv", (PyCFunction)THPModule_gesv, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"gels", (PyCFunction)THPModule_gels, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"trtrs", (PyCFunction)THPModule_trtrs, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"symeig", (PyCFunction)THPModule_symeig, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"eig", (PyCFunction)THPModule_eig, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"svd", (PyCFunction)THPModule_svd, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"inverse", (PyCFunction)THPModule_inverse, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"potrf", (PyCFunction)THPModule_potrf, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"potrs", (PyCFunction)THPModule_potrs, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"potri", (PyCFunction)THPModule_potri, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"pstrf", (PyCFunction)THPModule_pstrf, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"qr", (PyCFunction)THPModule_qr, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"geqrf", (PyCFunction)THPModule_geqrf, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"orgqr", (PyCFunction)THPModule_orgqr, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"ormqr", (PyCFunction)THPModule_ormqr, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"btrifact", (PyCFunction)THPModule_btrifact, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"btrifact_with_info", (PyCFunction)THPModule_btrifact_with_info, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"btrisolve", (PyCFunction)THPModule_btrisolve, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
|
||||
// Sparse functions
|
||||
{"smm", (PyCFunction)THSPModule_sspmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"saddmm", (PyCFunction)THSPModule_sspaddmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"dsmm", (PyCFunction)THSPModule_spmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{"hsmm", (PyCFunction)THSPModule_hspmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
// {"smm", (PyCFunction)THSPModule_sspmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
// {"saddmm", (PyCFunction)THSPModule_sspaddmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
// {"dsmm", (PyCFunction)THSPModule_spmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
// {"hsmm", (PyCFunction)THSPModule_hspmm, METH_VARARGS | METH_KEYWORDS, NULL},
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
@ -790,15 +374,6 @@ bool THCPShortStorage_init(PyObject *module);
|
||||
bool THCPCharStorage_init(PyObject *module);
|
||||
bool THCPByteStorage_init(PyObject *module);
|
||||
|
||||
bool THCPDoubleTensor_init(PyObject *module);
|
||||
bool THCPFloatTensor_init(PyObject *module);
|
||||
bool THCPHalfTensor_init(PyObject *module);
|
||||
bool THCPLongTensor_init(PyObject *module);
|
||||
bool THCPIntTensor_init(PyObject *module);
|
||||
bool THCPShortTensor_init(PyObject *module);
|
||||
bool THCPCharTensor_init(PyObject *module);
|
||||
bool THCPByteTensor_init(PyObject *module);
|
||||
|
||||
bool THCPStream_init(PyObject *module);
|
||||
|
||||
#ifdef WITH_CUDA
|
||||
@ -810,14 +385,14 @@ void initModule(PyObject *module);
|
||||
}} // namespace torch::cuda
|
||||
#endif
|
||||
|
||||
bool THCSPDoubleTensor_init(PyObject *module);
|
||||
bool THCSPFloatTensor_init(PyObject *module);
|
||||
bool THCSPHalfTensor_init(PyObject *module);
|
||||
bool THCSPLongTensor_init(PyObject *module);
|
||||
bool THCSPIntTensor_init(PyObject *module);
|
||||
bool THCSPShortTensor_init(PyObject *module);
|
||||
bool THCSPCharTensor_init(PyObject *module);
|
||||
bool THCSPByteTensor_init(PyObject *module);
|
||||
namespace torch { namespace nn {
|
||||
|
||||
void init__THNN(PyObject*);
|
||||
#ifdef WITH_CUDA
|
||||
void init__THCUNN(PyObject*);
|
||||
#endif
|
||||
|
||||
}} // namespace torch::nn
|
||||
|
||||
bool THDPDoubleStorage_init(PyObject *module);
|
||||
bool THDPFloatStorage_init(PyObject *module);
|
||||
@ -828,15 +403,6 @@ bool THDPShortStorage_init(PyObject *module);
|
||||
bool THDPCharStorage_init(PyObject *module);
|
||||
bool THDPByteStorage_init(PyObject *module);
|
||||
|
||||
bool THDPDoubleTensor_init(PyObject *module);
|
||||
bool THDPFloatTensor_init(PyObject *module);
|
||||
//bool THDPHalfTensor_init(PyObject *module);
|
||||
bool THDPLongTensor_init(PyObject *module);
|
||||
bool THDPIntTensor_init(PyObject *module);
|
||||
bool THDPShortTensor_init(PyObject *module);
|
||||
bool THDPCharTensor_init(PyObject *module);
|
||||
bool THDPByteTensor_init(PyObject *module);
|
||||
|
||||
static std::vector<PyMethodDef> methods;
|
||||
|
||||
#ifdef WITH_DISTRIBUTED
|
||||
@ -914,23 +480,6 @@ static PyObject* initModule() {
|
||||
ASSERT_TRUE(THPCharStorage_init(module));
|
||||
ASSERT_TRUE(THPByteStorage_init(module));
|
||||
|
||||
ASSERT_TRUE(THPDoubleTensor_init(module));
|
||||
ASSERT_TRUE(THPFloatTensor_init(module));
|
||||
ASSERT_TRUE(THPHalfTensor_init(module));
|
||||
ASSERT_TRUE(THPLongTensor_init(module));
|
||||
ASSERT_TRUE(THPIntTensor_init(module));
|
||||
ASSERT_TRUE(THPShortTensor_init(module));
|
||||
ASSERT_TRUE(THPCharTensor_init(module));
|
||||
ASSERT_TRUE(THPByteTensor_init(module));
|
||||
|
||||
ASSERT_TRUE(THSPDoubleTensor_init(module));
|
||||
ASSERT_TRUE(THSPFloatTensor_init(module));
|
||||
ASSERT_TRUE(THSPLongTensor_init(module));
|
||||
ASSERT_TRUE(THSPIntTensor_init(module));
|
||||
ASSERT_TRUE(THSPShortTensor_init(module));
|
||||
ASSERT_TRUE(THSPCharTensor_init(module));
|
||||
ASSERT_TRUE(THSPByteTensor_init(module));
|
||||
|
||||
#ifdef WITH_CUDA
|
||||
// This will only initialise base classes and attach them to library namespace
|
||||
// They won't be ready for real usage until importing cuda module, that will
|
||||
@ -945,25 +494,7 @@ static PyObject* initModule() {
|
||||
ASSERT_TRUE(THCPCharStorage_init(module));
|
||||
ASSERT_TRUE(THCPByteStorage_init(module));
|
||||
|
||||
ASSERT_TRUE(THCPDoubleTensor_init(module));
|
||||
ASSERT_TRUE(THCPFloatTensor_init(module));
|
||||
ASSERT_TRUE(THCPHalfTensor_init(module));
|
||||
ASSERT_TRUE(THCPLongTensor_init(module));
|
||||
ASSERT_TRUE(THCPIntTensor_init(module));
|
||||
ASSERT_TRUE(THCPShortTensor_init(module));
|
||||
ASSERT_TRUE(THCPCharTensor_init(module));
|
||||
ASSERT_TRUE(THCPByteTensor_init(module));
|
||||
|
||||
ASSERT_TRUE(THCPStream_init(module));
|
||||
|
||||
ASSERT_TRUE(THCSPDoubleTensor_init(module));
|
||||
ASSERT_TRUE(THCSPFloatTensor_init(module));
|
||||
ASSERT_TRUE(THCSPHalfTensor_init(module));
|
||||
ASSERT_TRUE(THCSPLongTensor_init(module));
|
||||
ASSERT_TRUE(THCSPIntTensor_init(module));
|
||||
ASSERT_TRUE(THCSPShortTensor_init(module));
|
||||
ASSERT_TRUE(THCSPCharTensor_init(module));
|
||||
ASSERT_TRUE(THCSPByteTensor_init(module));
|
||||
#endif
|
||||
|
||||
#ifdef WITH_CUDNN
|
||||
@ -984,15 +515,6 @@ static PyObject* initModule() {
|
||||
ASSERT_TRUE(THDPShortStorage_init(module));
|
||||
ASSERT_TRUE(THDPCharStorage_init(module));
|
||||
ASSERT_TRUE(THDPByteStorage_init(module));
|
||||
|
||||
ASSERT_TRUE(THDPDoubleTensor_init(module));
|
||||
ASSERT_TRUE(THDPFloatTensor_init(module));
|
||||
//ASSERT_TRUE(THDPHalfTensor_init(module));
|
||||
ASSERT_TRUE(THDPLongTensor_init(module));
|
||||
ASSERT_TRUE(THDPIntTensor_init(module));
|
||||
ASSERT_TRUE(THDPShortTensor_init(module));
|
||||
ASSERT_TRUE(THDPCharTensor_init(module));
|
||||
ASSERT_TRUE(THDPByteTensor_init(module));
|
||||
#endif
|
||||
|
||||
// force ATen to initialize because it handles
|
||||
@ -1008,6 +530,11 @@ static PyObject* initModule() {
|
||||
if (_import_array() < 0) return NULL;
|
||||
#endif
|
||||
|
||||
torch::nn::init__THNN(module);
|
||||
#ifdef WITH_CUDA
|
||||
torch::nn::init__THCUNN(module);
|
||||
#endif
|
||||
|
||||
return module;
|
||||
END_HANDLE_TH_ERRORS
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user