depthtensor 2.4.0__tar.gz

depthtensor-2.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Le Hong Ha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

depthtensor-2.4.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: depthtensor
+Version: 2.4.0
+Summary: A Hardware-Accelerated Tensor Computation and Autograd Engine
+Author-email: Le Hong Ha <lehahong1310@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Le Hong Ha
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/l-h-ha/DepthTensor
+Project-URL: Bug Tracker, https://github.com/l-h-ha/DepthTensor/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: gpu
+Requires-Dist: cupy; extra == "gpu"
+Dynamic: license-file
+
+# DepthTensor: A Hardware-Accelerated Tensor Computation and Autograd Engine
+
+**DepthTensor** is a light-weight, high-performance library for reverse-mode automatic differentiation (AD). It is useful in building the mathematical foundation of deep learning frameworks, with the use of a `Tensor` object which dynamically builds computational graphs and computes gradients using **Vector-Jacobian Products (VJP)**, generalized for tensors of abritrary rank.
+
+> **Note**: This is the core autograd and tensor computation engine. For the full deep learning framework, refer to [DepthML](https://github.com/l-h-ha/DepthML).
+
+## 1. Mathematical Foundation
+
+The goal is to compute the gradient of scalar field $L$ with respect to an input tensor $X$, denoted as the adjoint $\bar{X}$.
+
+### 1.1. Generalized VJPs via Tensor Contractions
+
+Let $X$ be a tensor of shape $\mathcal{I} = (i_1, \dots, i_n)$ and $Y = f(X)$ be a tensor of shape $\mathcal{J} = (j_1, \dots, j_m)$.
+
+Mathematically, the Jacobian is the tensor of rank $n + m$ which contains all the partial derivatives $\frac{\partial Y_{\mathcal{J}}}{\partial X_{\mathcal{I}}}$. DepthTensor does not compute this object, but, rather, it computes the contraction of the incoming adjoint $\bar{Y}$ with the local derivative:
+
+$$
+\bar{X}_{i_1 \dots i_n} = \sum_{j_1 \dots j_m} \bar{Y}_{j_1 \dots j_m} \frac{\partial Y_{j_1 \dots j_m}}{\partial X_{i_1 \dots i_n}}
+$$
+
+If X and Y are scalars, indices vanish, and this reduces to:
+
+$$
+\bar{x} = \bar{y} \cdot f'(x)
+$$
+
+If X and Y are matrices, this reduces to:
+
+$$
+\bar{X} = \bar{Y} W^{T}
+$$
+
+### 1.2. Graph Topology and Gradient Accumulation
+
+Gradients are accumulated using a Depth-First Search (DFS) topological sort, which ensures that for any node $X$ with multiple gradient flow streams ${Y^{(1)}, \dots, Y^{k}}$, the gradient sum is the sum of contractions:
+
+$$
+\bar{X} = \sum_{k} \mathrm{VJP}(Y^{(k)}, X)
+$$
+
+All gradients are aggregated from all gradient downstreams.
+
+## 2. Architecture and System Design
+
+### 2.1. The differentiable Primitive (`Tensor`)
+
+The `Tensor` class acts like a node in the Directed Acyclic Graph (DAG).
+
+Operations are automatically dispatched to backend computers, which consists of `numpy` (CPU) and `cupy` (GPU).
+
+Computational graphs are built dynamically at runtime.
+
+## 3. Empirical Validation
+
+We will verify the tensor engine by minimizing the Rosenbrock function, which is a non-convex optimization benchmark:
+
+$$
+f(x, y) = (a - x)^2 + b(y - x^2)^2
+$$
+
+```python
+import depthtensor as dt
+
+# Initialize tensors
+x = dt.Tensor([1.2], device="gpu", requires_grad=True)
+y = dt.Tensor([1.2], device="gpu", requires_grad=True)
+
+a, b = dt.Tensor([1], device="gpu"), dt.Tensor(
+    [100], device="gpu"
+)
+
+# 2. Optimization Loop
+lr = 0.001
+for i in range(500):
+    # Rosenbrock: f(x,y) = (a-x)^2 + b(y-x^2)^2
+    loss = (a - x) ** 2 + b * (y - x**2) ** 2
+
+    # Backpward pass
+    dt.differentiate(loss)
+
+    # Gradient Descent
+    x.data -= lr * x.grad  # type: ignore
+    y.data -= lr * y.grad  # type: ignore
+
+    # Zero grads
+    x.zeros_grad()
+    y.zeros_grad()
+
+    if i % 10 == 0:
+        print(loss.item())
+
+print(f"Converged: ({x.data}, {y.data})")
+# Target: (1.0, 1.0)
+```
+
+## 4. Installation
+
+Requirements: 
+- `numpy`
+- `cupy` (optional: for NVIDIA GPU acceleration)
+
+### 4.1. Bash
+
+```bash
+git clone https://github.com/YourUsername/DepthTensor.git
+pip install -e .
+```
+
+### 4.2. Pip
+
+```bash
+pip install depthtensor
+```
+
+## Author: Le Hong Ha

depthtensor-2.4.0/README.md

@@ -0,0 +1,115 @@
+# DepthTensor: A Hardware-Accelerated Tensor Computation and Autograd Engine
+
+**DepthTensor** is a light-weight, high-performance library for reverse-mode automatic differentiation (AD). It is useful in building the mathematical foundation of deep learning frameworks, with the use of a `Tensor` object which dynamically builds computational graphs and computes gradients using **Vector-Jacobian Products (VJP)**, generalized for tensors of abritrary rank.
+
+> **Note**: This is the core autograd and tensor computation engine. For the full deep learning framework, refer to [DepthML](https://github.com/l-h-ha/DepthML).
+
+## 1. Mathematical Foundation
+
+The goal is to compute the gradient of scalar field $L$ with respect to an input tensor $X$, denoted as the adjoint $\bar{X}$.
+
+### 1.1. Generalized VJPs via Tensor Contractions
+
+Let $X$ be a tensor of shape $\mathcal{I} = (i_1, \dots, i_n)$ and $Y = f(X)$ be a tensor of shape $\mathcal{J} = (j_1, \dots, j_m)$.
+
+Mathematically, the Jacobian is the tensor of rank $n + m$ which contains all the partial derivatives $\frac{\partial Y_{\mathcal{J}}}{\partial X_{\mathcal{I}}}$. DepthTensor does not compute this object, but, rather, it computes the contraction of the incoming adjoint $\bar{Y}$ with the local derivative:
+
+$$
+\bar{X}_{i_1 \dots i_n} = \sum_{j_1 \dots j_m} \bar{Y}_{j_1 \dots j_m} \frac{\partial Y_{j_1 \dots j_m}}{\partial X_{i_1 \dots i_n}}
+$$
+
+If X and Y are scalars, indices vanish, and this reduces to:
+
+$$
+\bar{x} = \bar{y} \cdot f'(x)
+$$
+
+If X and Y are matrices, this reduces to:
+
+$$
+\bar{X} = \bar{Y} W^{T}
+$$
+
+### 1.2. Graph Topology and Gradient Accumulation
+
+Gradients are accumulated using a Depth-First Search (DFS) topological sort, which ensures that for any node $X$ with multiple gradient flow streams ${Y^{(1)}, \dots, Y^{k}}$, the gradient sum is the sum of contractions:
+
+$$
+\bar{X} = \sum_{k} \mathrm{VJP}(Y^{(k)}, X)
+$$
+
+All gradients are aggregated from all gradient downstreams.
+
+## 2. Architecture and System Design
+
+### 2.1. The differentiable Primitive (`Tensor`)
+
+The `Tensor` class acts like a node in the Directed Acyclic Graph (DAG).
+
+Operations are automatically dispatched to backend computers, which consists of `numpy` (CPU) and `cupy` (GPU).
+
+Computational graphs are built dynamically at runtime.
+
+## 3. Empirical Validation
+
+We will verify the tensor engine by minimizing the Rosenbrock function, which is a non-convex optimization benchmark:
+
+$$
+f(x, y) = (a - x)^2 + b(y - x^2)^2
+$$
+
+```python
+import depthtensor as dt
+
+# Initialize tensors
+x = dt.Tensor([1.2], device="gpu", requires_grad=True)
+y = dt.Tensor([1.2], device="gpu", requires_grad=True)
+
+a, b = dt.Tensor([1], device="gpu"), dt.Tensor(
+    [100], device="gpu"
+)
+
+# 2. Optimization Loop
+lr = 0.001
+for i in range(500):
+    # Rosenbrock: f(x,y) = (a-x)^2 + b(y-x^2)^2
+    loss = (a - x) ** 2 + b * (y - x**2) ** 2
+
+    # Backpward pass
+    dt.differentiate(loss)
+
+    # Gradient Descent
+    x.data -= lr * x.grad  # type: ignore
+    y.data -= lr * y.grad  # type: ignore
+
+    # Zero grads
+    x.zeros_grad()
+    y.zeros_grad()
+
+    if i % 10 == 0:
+        print(loss.item())
+
+print(f"Converged: ({x.data}, {y.data})")
+# Target: (1.0, 1.0)
+```
+
+## 4. Installation
+
+Requirements: 
+- `numpy`
+- `cupy` (optional: for NVIDIA GPU acceleration)
+
+### 4.1. Bash
+
+```bash
+git clone https://github.com/YourUsername/DepthTensor.git
+pip install -e .
+```
+
+### 4.2. Pip
+
+```bash
+pip install depthtensor
+```
+
+## Author: Le Hong Ha

depthtensor-2.4.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "depthtensor"
+version = "2.4.0"
+description = "A Hardware-Accelerated Tensor Computation and Autograd Engine"
+readme = "README.md"
+authors = [
+    { name = "Le Hong Ha", email = "lehahong1310@gmail.com" }
+]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",  # Fixed
+    "License :: OSI Approved :: MIT License",                      # Fixed
+    "Operating System :: OS Independent"
+]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy"
+]
+
+[project.optional-dependencies]
+gpu = [
+    "cupy"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/l-h-ha/DepthTensor"
+"Bug Tracker" = "https://github.com/l-h-ha/DepthTensor/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

depthtensor-2.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

depthtensor-2.4.0/src/DepthTensor/__init__.py

@@ -0,0 +1,9 @@
+from .tensor import Tensor
+from .autodiff import differentiate
+from .typing import *
+
+from ._core.ops import *
+from ._core.exceptions import *
+from ._core import random
+
+__version__ = "2.4.0"

depthtensor-2.4.0/src/DepthTensor/_core/__init__.py

@@ -0,0 +1,4 @@
+from .utils import *
+from .exceptions import *
+
+from .ops import *

depthtensor-2.4.0/src/DepthTensor/_core/exceptions.py

@@ -0,0 +1,16 @@
+CUPY_NOT_FOUND_MSG = "Module CuPy not found or installed. Please install CuPy."
+DEVICE_MISMATCH_MSG = "There is a mismatch in device between two objects."
+OPERAND_MISMATCH_MSG = "There is a mismatch in the type between two operands."
+GRADIENT_COMPUTATION_ERROR = "An error in gradient computation has occurred."
+
+class CuPyNotFound(RuntimeError):
+    ...
+
+class DeviceMismatch(RuntimeError):
+    ...
+
+class OperandMismatch(RuntimeError):
+    ...
+
+class GradientComputationError(RuntimeError):
+    ...

depthtensor-2.4.0/src/DepthTensor/_core/ops/__init__.py

@@ -0,0 +1,6 @@
+from .creation import *
+from .elementwise import *
+from .comparison import *
+from .reduction import *
+
+from .diff import *

depthtensor-2.4.0/src/DepthTensor/_core/ops/comparison.py

@@ -0,0 +1,318 @@
+from typing import Union, Optional, Tuple, overload
+
+from ...typing import (
+    TensorLike,
+    DeviceLike,
+    NDArrayLikeBool,
+    Casting,
+    Order,
+    OperandLike,
+)
+
+from ..exceptions import (
+    CuPyNotFound,
+    CUPY_NOT_FOUND_MSG,
+    DeviceMismatch,
+    DEVICE_MISMATCH_MSG,
+)
+
+from ..utils import to_xp_array, get_device, get_two_operand_op_device
+
+import numpy as np
+
+try:
+    import cupy as cp
+except (ImportError, ModuleNotFoundError):
+    cp = None
+
+###
+###
+###
+
+
+@overload
+def where(
+    condition: OperandLike,
+    /,
+    *,
+    device: DeviceLike = "cpu",
+    requires_grad: bool = False,
+) -> Tuple[TensorLike, ...]: ...
+
+
+@overload
+def where(
+    condition: OperandLike,
+    x: Optional[OperandLike],
+    y: Optional[OperandLike],
+    /,
+    *,
+    device: DeviceLike = "cpu",
+    requires_grad: bool = False,
+) -> TensorLike: ...
+
+
+def where(
+    condition: OperandLike,
+    x: Optional[OperandLike] = None,
+    y: Optional[OperandLike] = None,
+    /,
+    *,
+    device: Optional[DeviceLike] = None,
+    requires_grad: bool = False,
+) -> Union[Tuple[TensorLike, ...], TensorLike]:
+    from ...tensor import Tensor
+
+    if device is None:
+        device = get_device(condition)
+
+    # * One parameter overload
+    if (x is None) and (y is None):
+        data = to_xp_array(condition, device=device)
+        if device == "cpu":
+            result = np.where(data)
+        else:
+            if cp is None:
+                raise CuPyNotFound(CUPY_NOT_FOUND_MSG)
+            result = cp.where(data)
+        return tuple([Tensor(array, requires_grad=requires_grad) for array in result])
+    # * Two parameters overload
+    elif x is not None and y is not None:
+        if (
+            not (get_device(x) == get_device(y) == device)
+            and not isinstance(x, (int, float, list, tuple))
+            and not isinstance(y, (int, float, list, tuple))
+        ):
+            raise DeviceMismatch(DEVICE_MISMATCH_MSG)
+
+        data = to_xp_array(condition, device=device)
+        x_data = to_xp_array(x, device=device)
+        y_data = to_xp_array(y, device=device)
+        if device == "cpu":
+            result = np.where(data, x_data, y_data)
+        else:
+            if cp is None:
+                raise CuPyNotFound(CUPY_NOT_FOUND_MSG)
+            result = cp.where(data, x_data, y_data)
+        return Tensor(result, requires_grad=requires_grad)
+    else:
+        raise ValueError("Both x and y parameters must be given.")
+
+
+###
+###
+###
+
+
+def wrapper_2in_1out(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    func_name: str,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    from ...tensor import Tensor
+
+    op_device = get_two_operand_op_device(x1, x2, device)
+
+    x1, x2 = to_xp_array(x1, device=op_device), to_xp_array(x2, device=op_device)
+    if op_device == "cpu":
+        y = getattr(np, func_name)(
+            x1,
+            x2,
+            out=out,
+            dtype=dtype,
+            where=where,
+            casting=casting,
+            order=order,
+            subok=subok,
+        )
+    else:
+        if cp is None:
+            raise CuPyNotFound(CUPY_NOT_FOUND_MSG)
+        y = getattr(cp, func_name)(x1, x2, out=out, dtype=dtype, casting=casting)
+    return Tensor(y)
+
+
+def equal(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="equal",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+def not_equal(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="not_equal",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+def greater(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="greater",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+def greater_equal(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="greater_equal",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+def less(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="less",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+def less_equal(
+    x1: OperandLike,
+    x2: OperandLike,
+    /,
+    out: Optional[NDArrayLikeBool] = None,
+    *,
+    device: Optional[DeviceLike] = None,
+    where: Union[bool, NDArrayLikeBool] = True,
+    casting: Casting = "same_kind",
+    order: Order = "K",
+    dtype: None = None,
+    subok: bool = True,
+) -> TensorLike:
+    return wrapper_2in_1out(
+        x1,
+        x2,
+        out=out,
+        func_name="less_equal",
+        device=device,
+        where=where,
+        casting=casting,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+    )
+
+
+###
+###
+###
+
+__all__ = [
+    "where",
+    "equal",
+    "not_equal",
+    "greater",
+    "greater_equal",
+    "less",
+    "less_equal",
+]