test linear

Author: BigNoobWasTaken

include/tensor_bind.cc

@@ -23,17 +23,34 @@ TensorBase convert_numpy_to_tensor_base(pybind11::array_t<T> py_buf)
 			return static_cast<unsigned int>(dim);
 		}
 	);
-	warp_type(warp_type(typeid(T)));
-	return TensorBase(typeid(T), shape_vec, info.ptr);
+	return TensorBase(warp_type(warp_type(typeid(T))), shape_vec, info.ptr);
 }
 
 pybind11::dtype get_py_type(const std::type_info& info)
 {
+	if (info == typeid(std::int8_t))
+		return pybind11::dtype::of<std::int8_t>();
+	if (info == typeid(std::int16_t))
+		return pybind11::dtype::of<std::int16_t>();
+	if (info == typeid(std::int32_t))
+		return pybind11::dtype::of<std::int32_t>();
+	if (info == typeid(std::int64_t))
+		return pybind11::dtype::of<std::int64_t>();
+	if (info == typeid(std::uint8_t))
+		return pybind11::dtype::of<std::uint8_t>();
+	if (info == typeid(std::uint16_t))
+		return pybind11::dtype::of<std::uint16_t>();
+	if (info == typeid(std::uint32_t))
+		return pybind11::dtype::of<std::uint32_t>();
+	if (info == typeid(std::uint64_t))
+		return pybind11::dtype::of<std::uint64_t>();
 	if (info == typeid(bool))
 		return pybind11::dtype::of<bool>();
 	if (info == typeid(float))
 		return pybind11::dtype::of<float>();
-	throw std::exception();
+	if (info == typeid(double))
+		return pybind11::dtype::of<double>();
+	throw std::runtime_error("no dtype");
 }
 
 pybind11::array convert_tensor_to_numpy(const Tensor& self)
@@ -125,6 +142,11 @@ pybind11::tuple tensor_shape(const Tensor& self)
 	return pybind11::cast(std::vector(self.get_buffer().shape()));
 }
 
+DataType tensor_type(const Tensor& self)
+{
+	return warp_type(self.get_buffer().type());
+}
+
 Tensor tensor_copying(const Tensor& self)
 {
 	return self;
@@ -205,6 +227,7 @@ PYBIND11_MODULE(tensor2, m)
 		.def("condition", &condition)
 		.def("numpy", &convert_tensor_to_numpy)
 		.def("shape", &tensor_shape)
+		.def("dtype", &tensor_type)
 		.def("__getitem__", &python_index)
 		.def("__getitem__", &python_slice)
 		.def("__getitem__", &python_tuple_slice)

src/main.py

@@ -22,4 +22,5 @@
 
 layer1 = Linear(3)
 
-print(layer1(Tensor([[1, 2, 3], [4, 5, 6]])))
+result_layer_1 = layer1(Tensor([[1, 2, 3], [4, 5, 6]]))
+print(result_layer_1)

src/tensor_array/core/__init__.py

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

src/tensor_array/core/libTensorArray_Core.so

@@ -21,9 +21,15 @@ def __init__(self) -> None:
 
     def __call__(self, *args: Any, **kwds: Any) -> Any:
         if not self.__dict__['is_running']:
-            self.init_value(*args, **kwds)
+            list_arg = ((t.shape(), t.dtype()) for t in args if isinstance(t, Tensor))
+            dict_kwargs = {
+                key: (val.shape(), val.dtype())
+                for key, val in kwds
+                if isinstance(val, Tensor)
+            }
+            self.init_value(*list_arg, **dict_kwargs)
         super().__setattr__('is_running', True)
-        self.calculate(*args, **kwds)
+        return self.calculate(*args, **kwds)
 
     def init_value(self, *args: Any, **kwds: Any) -> Any:
         pass

src/tensor_array/core/tensor2.so

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