Mega Update for the tensor class.

Author: BigNoobWasTaken

.github/workflows/python-publish.yml

@@ -26,6 +26,14 @@ jobs:
       uses: actions/setup-python@v3
       with:
         python-version: '3.x'
+    - name: Run CUDA bash shell
+      env:
+        temp: ${{ runner.temp }}
+        cuda: '12.9'
+      run: |
+        chmod +x ${{github.workspace}}/tensor-array-repo/Tensor-Array/scripts/actions/install-cuda-ubuntu.sh
+        ${{github.workspace}}/tensor-array-repo/Tensor-Array/scripts/actions/install-cuda-ubuntu.sh
+      shell: bash
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

MANIFEST.in

@@ -1,6 +1,7 @@
 include README.md LICENSE tensor-array-repo/Tensor-Array/LICENSE third_party/pybind11/LICENSE
 graft third_party/pybind11/include
 graft third_party/pybind11/tools
+graft third_party/pybind11/pybind11
 graft tensor-array-repo/Tensor-Array/src
 graft src
 global-include CMakeLists.txt *.cmake Config.cmake.in

README.md

@@ -10,6 +10,45 @@ This machine learning library using [Tensor-Array](https://github.com/Tensor-Arr
 This project is still in alpha version, we are trying to make this look like the main framework but it is easier to code.
 
 ## How to install Tensor-Array python version.
+
+Before install this library please install [NVIDIA CUDA toolkit](https://developer.nvidia.com/cuda-toolkit) first.
+
+It can not work without [NVIDIA CUDA toolkit](https://developer.nvidia.com/cuda-toolkit).
+
+If you did not install [Python](https://www.python.org/) then install [Python 3](https://www.python.org/):
+
 ```shell
-$ pip install TensorArray
+apt-get update
+apt-get install python3
+```
+
+After that go to command and install:
+
+```shell
+pip install TensorArray
+```
+
+## Testing with the [Tensor](https://github.com/Tensor-Array/Tensor-Array/tab=readme-ov-file#the-tensor-class) object.
+
+The `Tensor` class is a storage that store value and calculate the tensor.
+
+The `Tensor.calc_grad()` method can do automatic differentiation.
+
+The `Tensor.get_grad()` method can get the gradient after call `Tensor.calc_grad()`.
+
+```python
+import tensor_array.core as ta
+import numpy as np
+
+def test_add():
+    example_tensor_array = ta.Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], dtype=np.int32))
+    example_tensor_array_scalar = ta.Tensor(100)
+    example_tensor_sum = example_tensor_array + example_tensor_array_scalar
+    print(example_tensor_sum)
+    example_tensor_sum.calc_grad()
+    print(example_tensor_array.get_grad())
+    print(example_tensor_array_scalar.get_grad())
+
+test_add()
+
 ```

setup.py

@@ -127,17 +127,17 @@ def main():
     with open(os.path.join(cwd, "README.md"), encoding="utf-8") as f:
         long_description = f.read()
 
-    packages = find_packages("")
+    packages = find_packages()
 
     print(packages)
 
     setup(
         name = "TensorArray",
-        version = "0.0.3",
+        version = "0.0.4",
         description = "A machine learning package",
         long_description=long_description,
-        authors = "TensorArray-Creators",
-        url= "https://github.com/Tensor-Array/Tensor-Array-Python",
+        author="TensorArray-Creators",
+        url="https://github.com/Tensor-Array/Tensor-Array-Python",
         packages=packages,
         ext_modules=[
             CMakeExtension("tensor_array/core/tensor2")
@@ -146,6 +146,7 @@ def main():
             "Development Status :: 2 - Pre-Alpha",
 
             "Programming Language :: Python :: 3",
+            "Programming Language :: Python :: 3.8",
             "Programming Language :: Python :: 3.9",
             "Programming Language :: Python :: 3.10",
             "Programming Language :: Python :: 3.11",
@@ -162,6 +163,7 @@ def main():
         },
         package_dir={
             "": "src",
+            "pybind11": "third_party/pybind11/pybind11",
             "tests": "tests"
         },
         python_requires=">=3.8",

src/tensor_array/_core/tensor_bind.cc

@@ -150,7 +150,7 @@ DataType tensor_type(const Tensor& self)
 
 Tensor tensor_copying(const Tensor& self)
 {
-	return self;
+	return Tensor(self);
 }
 
 Tensor py_zeros(pybind11::tuple shape_tuple, DataType dtype)
@@ -161,6 +161,14 @@ Tensor py_zeros(pybind11::tuple shape_tuple, DataType dtype)
 	return TensorBase(warp_type(dtype), shape_vec);
 }
 
+Tensor py_rand(pybind11::tuple shape_tuple, unsigned int seed = std::rand())
+{
+	std::vector<unsigned int> shape_vec;
+	for (auto& it: shape_tuple)
+		shape_vec.push_back(it.cast<unsigned int>());
+	return tensor_rand(shape_vec, seed);
+}
+
 PYBIND11_MODULE(tensor2, m)
 {
 	pybind11::enum_<DataType>(m, "DataType")
@@ -187,6 +195,13 @@ PYBIND11_MODULE(tensor2, m)
 		pybind11::arg("dtype") = S_INT_32
 	);
 
+	m.def(
+		"rand",
+		&py_rand,
+		pybind11::arg("shape"),
+		pybind11::arg("seed") = std::rand()
+	);
+
 	m.def(
 		"add",
 		&tensor_array::value::add,
@@ -207,6 +222,13 @@ PYBIND11_MODULE(tensor2, m)
 		pybind11::arg("value_1"),
 		pybind11::arg("value_2")
 	);
+
+	m.def(
+		"power",
+		&tensor_array::value::power,
+		pybind11::arg("value_1"),
+		pybind11::arg("value_2")
+	);
 
 	m.def(
 		"matmul",
@@ -245,17 +267,17 @@ PYBIND11_MODULE(tensor2, m)
 		.def(+pybind11::self)
 		.def(-pybind11::self)
 		.def(hash(pybind11::self))
-		.def("transpose", &tensor_array::value::Tensor::transpose)
-		.def("calc_grad", &tensor_array::value::Tensor::calc_grad)
-		.def("get_grad", &tensor_array::value::Tensor::get_grad)
-		.def("sin", &tensor_array::value::Tensor::sin)
-		.def("cos", &tensor_array::value::Tensor::cos)
-		.def("tan", &tensor_array::value::Tensor::tan)
-		.def("sinh", &tensor_array::value::Tensor::sinh)
-		.def("cosh", &tensor_array::value::Tensor::cosh)
-		.def("tanh", &tensor_array::value::Tensor::tanh)
-		.def("log", &tensor_array::value::Tensor::log)
-		.def("clone", &tensor_array::value::Tensor::clone)
+		.def("transpose", &Tensor::transpose)
+		.def("calc_grad", &Tensor::calc_grad)
+		.def("get_grad", &Tensor::get_grad)
+		.def("sin", &Tensor::sin)
+		.def("cos", &Tensor::cos)
+		.def("tan", &Tensor::tan)
+		.def("sinh", &Tensor::sinh)
+		.def("cosh", &Tensor::cosh)
+		.def("tanh", &Tensor::tanh)
+		.def("log", &Tensor::log)
+		.def("clone", &Tensor::clone)
 		.def("cast", &tensor_cast_1)
 		.def("numpy", &convert_tensor_to_numpy)
 		.def("shape", &tensor_shape)
@@ -264,8 +286,7 @@ PYBIND11_MODULE(tensor2, m)
 		.def("__getitem__", &python_slice)
 		.def("__getitem__", &python_tuple_slice)
 		.def("__len__", &python_len)
-		.def("__matmul__", &tensor_array::value::matmul)
-		.def("__rmatmul__", &tensor_array::value::matmul)
+		.def("__matmul__", &matmul)
 		.def("__repr__", &tensor_to_string)
 		.def("__copy__", &tensor_copying);
 }

src/tensor_array/activation.py

@@ -1,12 +1,13 @@
 from tensor_array.core import Tensor
 from tensor_array.core import zeros
+from tensor_array.core import condition
 
-def relu(input):
+def relu(input: Tensor) -> Tensor:
     tensor_zeros = zeros(shape = input.shape(), dtype = input.dtype())
-    return (input > tensor_zeros).condition(input, tensor_zeros)
+    return condition(input > tensor_zeros, input, tensor_zeros)
 
-def sigmoid(input):
+def sigmoid(input: Tensor) -> Tensor:
     return input.sigmoid()
 
-def softmax(input, dim = 0):
-    return input
+def softmax(input: Tensor, dim: int = 0) -> Tensor:
+    return input.softmax(dim)

src/tensor_array/core/__init__.py

@@ -1,3 +1,9 @@
+"""
+# src/tensor_array/core/__init__.py
+# This module provides core functionalities for the TensorArray library, including tensor creation, random tensor generation, and data type definitions.
+# It includes functions to create tensors filled with zeros or random values, and defines the DataTypes enumeration for various data types supported by the library.
+"""
+
 from .tensor import Tensor
 from .constants import *
 from .datatypes import DataTypes

src/tensor_array/core/constants.py

@@ -1,6 +1,36 @@
-from .tensor2 import zeros as zerosWrapper
+"""
+# src/tensor_array/core/__init__.py
+# This module provides core functionalities for the TensorArray library, including tensor creation, random tensor generation, and data type definitions.
+# It includes functions to create tensors filled with zeros or random values, and defines the DataTypes enumeration for various data types supported by the library.
+"""
+
 from .tensor import Tensor
 from .datatypes import DataTypes
 
-def zeros(shape : Tensor, dtype : DataTypes = DataTypes.S_INT_32):
-    return zerosWrapper(shape, dtype)
+def zeros(shape : tuple, dtype : DataTypes = DataTypes.S_INT_32) -> Tensor:
+    """
+    Creates a tensor filled with zeros.
+    Args:
+        shape (tuple): The shape of the tensor.
+        dtype (DataTypes): The data type of the tensor.
+    Returns:
+        Tensor: A tensor filled with zeros.
+    """
+
+    from .tensor2 import zeros as zerosWrapper
+    return zerosWrapper(shape, dtype)
+
+def rand(shape : tuple, seed: int = 0) -> Tensor:
+    """
+    Generates a tensor with random values.
+    
+    Args:
+        shape (tuple): The shape of the tensor.
+        seed (int): The seed for random number generation.
+    
+    Returns:
+        Tensor: A tensor filled with random values.
+    """
+
+    from .tensor2 import rand as randWrapper
+    return randWrapper(shape, seed)

src/tensor_array/core/datatypes.py

@@ -1,7 +1,16 @@
+"""
+# src/tensor_array/core/datatypes.py
+# This module defines an enumeration for various data types supported by the TensorArray library.
+# The DataTypes enum includes types such as BOOL, INT, FLOAT, DOUBLE, and others, which correspond to the data types used in tensors.
+"""
+
 from .tensor2 import DataType as DataTypeWrapper
 from enum import Enum
 
 class DataTypes(Enum):
+    """
+    Enum representing various data types supported by the TensorArray library.
+    """
     BOOL = DataTypeWrapper.BOOL
     S_INT_8 = DataTypeWrapper.S_INT_8
     S_INT_16 = DataTypeWrapper.S_INT_16

src/tensor_array/core/operator.py

@@ -1,22 +1,80 @@
+"""
+# src/tensor_array/core/operator.py
+# This module provides various mathematical operations for tensors, including addition, division, multiplication, power, matrix multiplication, and conditional selection.
+# Each operation is implemented as a function that takes two tensors as input and returns a new tensor representing the result of the operation.
+"""
+
 from .tensor import Tensor
-from .tensor2 import add as addWrapper
-from .tensor2 import multiply as multiplyWrapper
-from .tensor2 import divide as divideWrapper
-from .tensor2 import matmul as matmulWrapper
-from .tensor2 import condition as conditionWrapper
 
-def add(value_1 : Tensor, value_2 : Tensor):
+def add(value_1 : Tensor, value_2 : Tensor) -> Tensor:
+    """
+    Adds two tensors element-wise.
+    Args:
+        value_1 (Tensor): The first tensor.
+        value_2 (Tensor): The second tensor.
+    Returns:
+        Tensor: A tensor that is the element-wise sum of value_1 and value_2
+    """
+    from .tensor2 import add as addWrapper
     return addWrapper(value_1, value_2)
 
-def divide(value_1 : Tensor, value_2 : Tensor):
+def divide(value_1 : Tensor, value_2 : Tensor) -> Tensor:
+    """
+    Divides two tensors element-wise.
+    Args:
+        value_1 (Tensor): The first tensor.
+        value_2 (Tensor): The second tensor.
+    Returns:
+        Tensor: A tensor that is the element-wise division of value_1 by value_2
+    """
+    from .tensor2 import divide as divideWrapper
+    return divideWrapper(value_1, value_2)
+
+def multiply(value_1 : Tensor, value_2 : Tensor) -> Tensor:
+    """
+    Multiplies two tensors element-wise.
+    Args:
+        value_1 (Tensor): The first tensor.
+        value_2 (Tensor): The second tensor.
+    Returns:
+        Tensor: A tensor that is the element-wise product of value_1 and value_2
+    """
+    from .tensor2 import multiply as multiplyWrapper
     return multiplyWrapper(value_1, value_2)
 
-def multiply(value_1 : Tensor, value_2 : Tensor):
-    return divideWrapper(value_1, value_2)
+def power(value_1 : Tensor, value_2 : Tensor) -> Tensor:
+    """
+    Raises the first tensor to the power of the second tensor element-wise.
+    Args:
+        value_1 (Tensor): The base tensor.
+        value_2 (Tensor): The exponent tensor.
+    Returns:
+        Tensor: A tensor that is the element-wise result of value_1 raised to the power of value_2
+    """
+    from .tensor2 import power as powerWrapper
+    return powerWrapper(value_1, value_2)
 
-def matmul(value_1 : Tensor, value_2 : Tensor):
+def matmul(value_1 : Tensor, value_2 : Tensor) -> Tensor:
+    """
+    Performs matrix multiplication between two tensors.
+    Args:
+        value_1 (Tensor): The first tensor.
+        value_2 (Tensor): The second tensor.
+    Returns:
+        Tensor: A tensor that is the result of matrix multiplication between value_1 and value_2
+    """
+    from .tensor2 import matmul as matmulWrapper
     return matmulWrapper(value_1, value_2)
 
-def condition(condition_value : Tensor, value_if_true : Tensor, value_if_false : Tensor):
+def condition(condition_value : Tensor, value_if_true : Tensor, value_if_false : Tensor) -> Tensor:
+    """
+    Chooses between two tensors based on a condition tensor.
+    Args:
+        condition_value (Tensor): The condition tensor.
+        value_if_true (Tensor): The tensor to return if the condition is true.
+        value_if_false (Tensor): The tensor to return if the condition is false.
+    Returns:
+        Tensor: A tensor that is either value_if_true or value_if_false, depending on the condition.
+    """
+    from .tensor2 import condition as conditionWrapper
     return conditionWrapper(condition_value, value_if_true, value_if_false)
-