test

Author: BigNoobWasTaken

include/tensor_bind.cc

@@ -3,6 +3,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
 #include <pybind11/operators.h>
+#include <pybind11/stl.h>
 
 using namespace tensor_array::value;
 using namespace tensor_array::datatype;
@@ -35,9 +36,9 @@ pybind11::dtype get_py_type(const std::type_info& info)
 	throw std::exception();
 }
 
-pybind11::array convert_tensor_to_numpy(const Tensor& tensor)
+pybind11::array convert_tensor_to_numpy(const Tensor& self)
 {
-	const TensorBase& base_tensor = tensor.get_buffer().change_device({tensor_array::devices::CPU, 0});
+	const TensorBase& base_tensor = self.get_buffer().change_device({tensor_array::devices::CPU, 0});
 	std::vector<pybind11::size_t> shape_vec(base_tensor.shape().size());
 	std::transform
 	(
@@ -54,15 +55,15 @@ pybind11::array convert_tensor_to_numpy(const Tensor& tensor)
 	return pybind11::array(ty1, shape_vec, base_tensor.data());
 }
 
-Tensor python_tuple_slice(const Tensor& t, pybind11::tuple tuple_slice)
+Tensor python_tuple_slice(const Tensor& self, pybind11::tuple tuple_slice)
 {
 	std::vector<Tensor::Slice> t_slices;
 	for (size_t i = 0; i < tuple_slice.size(); i++)
 	{
 		ssize_t start, stop, step;
 		ssize_t length;
 		pybind11::slice py_slice = tuple_slice[i].cast<pybind11::slice>();
-		if (!py_slice.compute(t.get_buffer().shape().begin()[i], &start, &stop, &step, &length))
+		if (!py_slice.compute(self.get_buffer().shape().begin()[i], &start, &stop, &step, &length))
 			throw std::runtime_error("Invalid slice");
 		t_slices.insert
 		(
@@ -75,17 +76,17 @@ Tensor python_tuple_slice(const Tensor& t, pybind11::tuple tuple_slice)
 			}
 		);
 	}
-	return t[tensor_array::wrapper::initializer_wrapper(t_slices.begin().operator->(), t_slices.end().operator->())];
+	return self[tensor_array::wrapper::initializer_wrapper(t_slices.begin().operator->(), t_slices.end().operator->())];
 }
 
-Tensor python_slice(const Tensor& t, pybind11::slice py_slice)
+Tensor python_slice(const Tensor& self, pybind11::slice py_slice)
 {
 	std::vector<Tensor::Slice> t_slices;
 	ssize_t start, stop, step;
 	ssize_t length;
-	if (!py_slice.compute(t.get_buffer().shape().begin()[0], &start, &stop, &step, &length))
+	if (!py_slice.compute(self.get_buffer().shape().begin()[0], &start, &stop, &step, &length))
 	throw std::runtime_error("Invalid slice");
-	return t
+	return self
 	[
 		{
 			Tensor::Slice
@@ -98,25 +99,43 @@ Tensor python_slice(const Tensor& t, pybind11::slice py_slice)
 	];
 }
 
-Tensor python_index(const Tensor& t, unsigned int i)
+Tensor python_index(const Tensor& self, unsigned int i)
 {
-	return t[i];
+	return self[i];
 }
 
-std::size_t python_len(const Tensor& t)
+std::size_t python_len(const Tensor& self)
 {
-	std::initializer_list<unsigned int> shape_list = t.get_buffer().shape();
+	std::initializer_list<unsigned int> shape_list = self.get_buffer().shape();
 	return shape_list.size() != 0 ? shape_list.begin()[0]: 1U;
 }
 
-pybind11::str tensor_to_string(const Tensor& t)
+pybind11::str tensor_to_string(const Tensor& self)
 {
-	return pybind11::repr(convert_tensor_to_numpy(t));
+	return pybind11::repr(convert_tensor_to_numpy(self));
 }
 
-Tensor tensor_cast_1(const Tensor& t, DataType dtype)
+Tensor tensor_cast_1(const Tensor& self, DataType dtype)
 {
-	return t.tensor_cast(warp_type(dtype));
+	return self.tensor_cast(warp_type(dtype));
+}
+
+pybind11::tuple tensor_shape(const Tensor& self)
+{
+	return pybind11::cast(std::vector(self.get_buffer().shape()));
+}
+
+Tensor tensor_copying(const Tensor& self)
+{
+	return self;
+}
+
+Tensor py_zeros(pybind11::tuple shape_tuple, DataType dtype)
+{
+	std::vector<unsigned int> shape_vec;
+	for (auto& it: shape_tuple)
+		shape_vec.push_back(it.cast<unsigned int>());
+	return TensorBase(warp_type(dtype), shape_vec);
 }
 
 PYBIND11_MODULE(tensor2, m)
@@ -136,9 +155,18 @@ PYBIND11_MODULE(tensor2, m)
 		.value("U_INT_32", U_INT_32)
 		.value("U_INT_64", U_INT_64)
 		.export_values();
+	
+	m.def
+	(
+		"zeros",
+		&py_zeros,
+		pybind11::arg("shape"),
+		pybind11::arg("dtype") = S_INT_32
+	);
 
 	pybind11::class_<Tensor>(m, "Tensor")
 		.def(pybind11::init())
+		.def(pybind11::init(&tensor_copying))
 		.def(pybind11::init(&convert_numpy_to_tensor_base<float>))
 		.def(pybind11::self + pybind11::self)
 		.def(pybind11::self - pybind11::self)
@@ -176,11 +204,13 @@ PYBIND11_MODULE(tensor2, m)
 		.def("matmul", &matmul)
 		.def("condition", &condition)
 		.def("numpy", &convert_tensor_to_numpy)
+		.def("shape", &tensor_shape)
 		.def("__getitem__", &python_index)
 		.def("__getitem__", &python_slice)
 		.def("__getitem__", &python_tuple_slice)
 		.def("__len__", &python_len)
 		.def("__matmul__", &matmul)
 		.def("__rmatmul__", &matmul)
-		.def("__repr__", &tensor_to_string);
+		.def("__repr__", &tensor_to_string)
+		.def("__copy__", &tensor_copying);
 }

src/main.py

@@ -1,10 +1,12 @@
 from tensor_array.core import Tensor
+from tensor_array.layers.util import Linear
 
 print("hello")
 
 t1 = Tensor([[1, 2, 3], [4, 5, 6]])
 t2 = t1.clone()
 print("tensor len", t1.__len__())
+print("tensor shape", t1.shape())
 print(t1)
 print(t1.__dir__())
 t1 = t1[::]
@@ -17,3 +19,7 @@
 print(t3)
 
 print(t1 != t3)
+
+layer1 = Linear(3)
+
+print(layer1(Tensor([[1, 2, 3], [4, 5, 6]])))

src/tensor_array/__init__.py

@@ -1 +1,2 @@
-from tensor_array.core.tensor2 import Tensor
+from tensor_array.core.tensor2 import Tensor
+from tensor_array.core.tensor2 import zeros

src/tensor_array/core/__init__.py

@@ -1,2 +1,2 @@
-from layer import Layer
-from parameter import Parameter
+from .layer import Layer
+from .parameter import Parameter

src/tensor_array/core/libTensorArray_Core.so

@@ -1,7 +1,7 @@
 from collections import OrderedDict, namedtuple
 from typing import Union, Tuple, Any, Callable, Iterator, Set, Optional, overload, TypeVar, Mapping, Dict, List
 from typing import Any
-from tensor_array.core import tensor2 as t
+from tensor_array.core import Tensor
 from .parameter import Parameter
 
 class Layer:
@@ -11,7 +11,7 @@ class Layer:
     is_running: bool
     _layers: Dict[str, Optional['Layer']]
     _parameters: Dict[str, Optional[Parameter]]
-    _tensors: Dict[str, Optional[t.Tensor]]
+    _tensors: Dict[str, Optional[Tensor]]
 
     def __init__(self) -> None:
         super().__setattr__('is_running', False)
@@ -20,10 +20,10 @@ def __init__(self) -> None:
         super().__setattr__('_tensors', OrderedDict())
 
     def __call__(self, *args: Any, **kwds: Any) -> Any:
-        if not super().__getattr__('is_running'):
-            self.init_value(args, kwds)
+        if not self.__dict__['is_running']:
+            self.init_value(*args, **kwds)
         super().__setattr__('is_running', True)
-        self.calculate(args, kwds)
+        self.calculate(*args, **kwds)
 
     def init_value(self, *args: Any, **kwds: Any) -> Any:
         pass
@@ -48,7 +48,7 @@ def register_parameter(self, name: str, param: Optional[Parameter]) -> None:
         else:
             self._parameters[name] = param
 
-    def register_tensor(self, name: str, param: Optional[t.Tensor]) -> None:
+    def register_tensor(self, name: str, param: Optional[Tensor]) -> None:
         if '_tensors' not in self.__dict__:
             raise AttributeError("cannot assign tensor before Module.__init__() call")
         elif not isinstance(name, str):
@@ -57,13 +57,13 @@ def register_tensor(self, name: str, param: Optional[t.Tensor]) -> None:
             raise KeyError("tensor name can't contain \".\"")
         elif name == '':
             raise KeyError("tensor name can't be empty string \"\"")
-        elif hasattr(self, name) and name not in self._parameters:
+        elif hasattr(self, name) and name not in self._tensors:
             raise KeyError(f"attribute '{name}' already exists")
-        elif not isinstance(param, t.Tensor) and param is not None:
+        elif not isinstance(param, Tensor) and param is not None:
             raise TypeError(f"cannot assign '{param}' object to parameter '{name}' "
                             "(tensor_array.core.tensor2.Tensor or None required)")
         else:
-            self._parameters[name] = param
+            self._tensors[name] = param
 
     def register_layer(self, name: str, layer: Optional['Layer']) -> None:
         if not isinstance(layer, Layer) and layer is not None:
@@ -97,7 +97,7 @@ def remove_from(*dicts_or_sets):
                 raise AttributeError("cannot assign parameters before Layer.__init__() call")
             remove_from(self.__dict__, self._layers, self._tensors)
             self.register_parameter(__name, __value)
-        elif isinstance(__value, t.Tensor):
+        elif isinstance(__value, Tensor):
             if layers is None:
                 raise AttributeError("cannot assign layers before Layer.__init__() call")
             remove_from(self.__dict__, self._parameters, self._layers)
@@ -128,9 +128,9 @@ def __getattr__(self, __name: str) -> Any:
     def __delattr__(self, __name: str) -> None:
         if __name in self._parameters:
             del self._parameters[__name]
-        elif __name in self._buffers:
-            del self._buffers[__name]
-        elif __name in self._modules:
-            del self._modules[__name]
+        elif __name in self._tensors:
+            del self._tensors[__name]
+        elif __name in self._layers:
+            del self._layers[__name]
         else:
             super().__delattr__(__name)

src/tensor_array/core/tensor2.so

@@ -1,8 +1,4 @@
-from tensor_array.core.tensor2 import tensor2 as t
+from tensor_array.core import Tensor
 
-class Parameter:
-    def __init__(self, tensor_param: t.Tensor) -> None:
-        self.tensor_param = tensor_param
-
-    def update_grad(self):
-        self.tensor_param -= self.tensor_param.get_grad().clone()
+class Parameter(Tensor):
+    pass

src/tensor_array/layers/__init__.py

@@ -0,0 +1 @@
+from tensor_array.layers.util.linear import Linear

src/tensor_array/layers/layer.py

@@ -1,18 +1,22 @@
-from tensor_array.layers import Layer
-from tensor_array.layers import Parameter
+from .. import Layer
+from .. import Parameter
 from tensor_array.core import Tensor
+from tensor_array.core import zeros
 from typing import Any
 
 
 class Linear(Layer):
     def __init__(self, bias) -> None:
-        super(self)
+        super(Linear, self).__init__()
         self.bias_shape = bias
-        self.b = Parameter(Tensor(shape = (bias)))
+        self.b = Parameter(zeros(shape = (bias,)))
 
     def init_value(self, t):
-        self.w = Parameter(Tensor(shape = (t.shape(-1), self.bias_shape)))
+        self.w = Parameter(zeros(shape = (t.shape()[-1], self.bias_shape)))
 
     def calculate(self, t):
-        return self.w @ t + self.b
+        print("t", t)
+        print("w", self.w)
+        print("b", self.b)
+        return t @ self.w + self.b