heroch 0.1.0__tar.gz

heroch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Death Legion Team
+
+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.

heroch-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: heroch
+Version: 0.1.0
+Summary: A flexible deep learning library for machine learning and scientific computing with GPU acceleration.
+Author-email: Death Legion Team <contact@deathlegion.team>
+Project-URL: Homepage, https://github.com/death-legion-team/heroch
+Project-URL: Bug Tracker, https://github.com/death-legion-team/heroch/issues
+Keywords: machine learning,deep learning,tensors,autograd,neural networks,GPU acceleration,CUDA,scientific computing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# Heroch: High-Performance Deep Learning and Scientific Computing Library
+
+[![PyPI version](https://badge.fury.io/py/heroch.svg)](https://badge.fury.io/py/heroch)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Heroch** is a powerful, flexible, and intuitive Python library designed for **machine learning**, **deep learning**, and **scientific computing**. It provides a high-performance tensor computation platform with seamless **GPU acceleration** (via CUDA/CuPy) and a dynamic **automatic differentiation** (autograd) engine.
+
+## Why Heroch?
+
+Heroch is built to feel like a native Python library, integrating perfectly with the SciPy ecosystem. Whether you are conducting academic research or building production-level neural networks, Heroch offers the flexibility to experiment and the speed to scale.
+
+### Key Features
+
+*   **⚡ High-Performance Tensor Computations**: Native NumPy interface with optional GPU acceleration for massive speedups.
+*   **🧠 Dynamic Autograd Engine**: Flexible computational graphs that allow you to change network structures on the fly.
+*   **🛠️ Complete Deep Learning Platform**: Built-in modules for linear layers, common activations (ReLU, Sigmoid), and loss functions (MSELoss).
+*   **🚀 Optimized Training**: Robust optimizers including Stochastic Gradient Descent (SGD) with momentum.
+*   **🐍 Pythonic API**: Intuitive design that is easy to debug and executes code as you write it.
+
+## Installation
+
+Install Heroch easily via pip:
+
+```bash
+pip install heroch
+```
+
+*Note: For GPU support, ensure you have an NVIDIA GPU and the appropriate CUDA drivers installed.*
+
+## Quick Start Example
+
+Build and train a simple neural network in minutes:
+
+```python
+import heroch
+import heroch.nn as nn
+import heroch.optim as optim
+from heroch import Tensor
+
+# Define your flexible model structure
+class MyNeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(2, 4)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(4, 1)
+        
+    def forward(self, x):
+        x = self.relu(self.fc1(x))
+        return self.fc2(x)
+
+# Initialize model, loss, and optimizer
+model = MyNeuralNetwork()
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+
+# Training data
+inputs = Tensor([[1.0, 2.0], [3.0, 4.0]])
+targets = Tensor([[5.0], [11.0]])
+
+# Training loop
+for epoch in range(100):
+    optimizer.zero_grad()
+    predictions = model(inputs)
+    loss = criterion(predictions, targets)
+    loss.backward()
+    optimizer.step()
+    
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data}")
+```
+
+## Advanced Usage: GPU Acceleration
+
+Heroch makes it easy to move your computations to the GPU:
+
+```python
+# Move model parameters and data to GPU
+x_gpu = Tensor([1.0, 2.0, 3.0]).to_gpu()
+```
+
+## Contributing
+
+We welcome contributions from the community! Check out our [GitHub repository](https://github.com/death-legion-team/heroch) to get involved.
+
+---
+Developed with 🔥 by **Death Legion Team**.

heroch-0.1.0/README.md

@@ -0,0 +1,87 @@
+# Heroch: High-Performance Deep Learning and Scientific Computing Library
+
+[![PyPI version](https://badge.fury.io/py/heroch.svg)](https://badge.fury.io/py/heroch)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Heroch** is a powerful, flexible, and intuitive Python library designed for **machine learning**, **deep learning**, and **scientific computing**. It provides a high-performance tensor computation platform with seamless **GPU acceleration** (via CUDA/CuPy) and a dynamic **automatic differentiation** (autograd) engine.
+
+## Why Heroch?
+
+Heroch is built to feel like a native Python library, integrating perfectly with the SciPy ecosystem. Whether you are conducting academic research or building production-level neural networks, Heroch offers the flexibility to experiment and the speed to scale.
+
+### Key Features
+
+*   **⚡ High-Performance Tensor Computations**: Native NumPy interface with optional GPU acceleration for massive speedups.
+*   **🧠 Dynamic Autograd Engine**: Flexible computational graphs that allow you to change network structures on the fly.
+*   **🛠️ Complete Deep Learning Platform**: Built-in modules for linear layers, common activations (ReLU, Sigmoid), and loss functions (MSELoss).
+*   **🚀 Optimized Training**: Robust optimizers including Stochastic Gradient Descent (SGD) with momentum.
+*   **🐍 Pythonic API**: Intuitive design that is easy to debug and executes code as you write it.
+
+## Installation
+
+Install Heroch easily via pip:
+
+```bash
+pip install heroch
+```
+
+*Note: For GPU support, ensure you have an NVIDIA GPU and the appropriate CUDA drivers installed.*
+
+## Quick Start Example
+
+Build and train a simple neural network in minutes:
+
+```python
+import heroch
+import heroch.nn as nn
+import heroch.optim as optim
+from heroch import Tensor
+
+# Define your flexible model structure
+class MyNeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(2, 4)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(4, 1)
+        
+    def forward(self, x):
+        x = self.relu(self.fc1(x))
+        return self.fc2(x)
+
+# Initialize model, loss, and optimizer
+model = MyNeuralNetwork()
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+
+# Training data
+inputs = Tensor([[1.0, 2.0], [3.0, 4.0]])
+targets = Tensor([[5.0], [11.0]])
+
+# Training loop
+for epoch in range(100):
+    optimizer.zero_grad()
+    predictions = model(inputs)
+    loss = criterion(predictions, targets)
+    loss.backward()
+    optimizer.step()
+    
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data}")
+```
+
+## Advanced Usage: GPU Acceleration
+
+Heroch makes it easy to move your computations to the GPU:
+
+```python
+# Move model parameters and data to GPU
+x_gpu = Tensor([1.0, 2.0, 3.0]).to_gpu()
+```
+
+## Contributing
+
+We welcome contributions from the community! Check out our [GitHub repository](https://github.com/death-legion-team/heroch) to get involved.
+
+---
+Developed with 🔥 by **Death Legion Team**.

heroch-0.1.0/heroch/__init__.py

@@ -0,0 +1,3 @@
+from .tensor import Tensor
+
+__version__ = "0.1.0"

heroch-0.1.0/heroch/nn/__init__.py

@@ -0,0 +1,4 @@
+from .module import Module
+from .linear import Linear
+from .activations import ReLU, Sigmoid
+from .loss import MSELoss

heroch-0.1.0/heroch/nn/activations.py

@@ -0,0 +1,31 @@
+import numpy as np
+from heroch.tensor import Tensor
+from heroch.nn.module import Module
+
+class ReLU(Module):
+    def forward(self, x):
+        data = np.maximum(0, x.data)
+        requires_grad = x.requires_grad
+        depends_on = []
+
+        if x.requires_grad:
+            def backward_func(grad):
+                # dReLU(x)/dx = 1 if x > 0 else 0
+                return grad * (x.data > 0).astype(np.float32)
+            depends_on.append({'tensor': x, 'backward_func': backward_func})
+
+        return Tensor(data, requires_grad, depends_on)
+
+class Sigmoid(Module):
+    def forward(self, x):
+        data = 1 / (1 + np.exp(-x.data))
+        requires_grad = x.requires_grad
+        depends_on = []
+
+        if x.requires_grad:
+            def backward_func(grad):
+                # dSigmoid(x)/dx = Sigmoid(x) * (1 - Sigmoid(x))
+                return grad * (data * (1 - data))
+            depends_on.append({'tensor': x, 'backward_func': backward_func})
+
+        return Tensor(data, requires_grad, depends_on)

heroch-0.1.0/heroch/nn/linear.py

@@ -0,0 +1,28 @@
+import numpy as np
+from heroch.tensor import Tensor
+from heroch.nn.module import Module
+
+class Linear(Module):
+    def __init__(self, in_features, out_features, bias=True):
+        super().__init__()
+        # Xavier/Glorot initialization
+        limit = np.sqrt(6 / (in_features + out_features))
+        self.weight = Tensor(
+            np.random.uniform(-limit, limit, (in_features, out_features)).astype(np.float32),
+            requires_grad=True
+        )
+        if bias:
+            self.bias = Tensor(
+                np.zeros((1, out_features), dtype=np.float32),
+                requires_grad=True
+            )
+        else:
+            self.bias = None
+
+    def forward(self, x):
+        # x is (batch_size, in_features)
+        # weight is (in_features, out_features)
+        out = x @ self.weight
+        if self.bias is not None:
+            out = out + self.bias
+        return out

heroch-0.1.0/heroch/nn/loss.py

@@ -0,0 +1,17 @@
+import numpy as np
+from heroch.tensor import Tensor
+from heroch.nn.module import Module
+
+class MSELoss(Module):
+    def forward(self, input, target):
+        # input: Tensor (batch_size, ...)
+        # target: Tensor (batch_size, ...)
+        diff = input - target
+        # Mean squared error: sum((input - target)^2) / n
+        n = np.prod(input.shape)
+        
+        # We need a pow operation for Tensor, or just use mul
+        sq_diff = diff * diff
+        loss = sq_diff.sum() * (1.0 / n)
+        
+        return loss

heroch-0.1.0/heroch/nn/module.py

@@ -0,0 +1,28 @@
+from heroch.tensor import Tensor
+
+class Module:
+    def __init__(self):
+        self._parameters = {}
+
+    def parameters(self):
+        for name, value in self.__dict__.items():
+            if isinstance(value, Tensor) and value.requires_grad:
+                yield value
+            elif isinstance(value, Module):
+                yield from value.parameters()
+            elif isinstance(value, (list, tuple)):
+                for item in value:
+                    if isinstance(item, Tensor) and item.requires_grad:
+                        yield item
+                    elif isinstance(item, Module):
+                        yield from item.parameters()
+
+    def __call__(self, *args, **kwargs):
+        return self.forward(*args, **kwargs)
+
+    def forward(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def zero_grad(self):
+        for p in self.parameters():
+            p.zero_grad()

heroch-0.1.0/heroch/optim/__init__.py

@@ -0,0 +1,2 @@
+from .optimizer import Optimizer
+from .sgd import SGD

heroch-0.1.0/heroch/optim/optimizer.py

@@ -0,0 +1,11 @@
+class Optimizer:
+    def __init__(self, parameters, lr=0.01):
+        self.parameters = list(parameters)
+        self.lr = lr
+
+    def zero_grad(self):
+        for p in self.parameters:
+            p.zero_grad()
+
+    def step(self):
+        raise NotImplementedError

heroch-0.1.0/heroch/optim/sgd.py

@@ -0,0 +1,18 @@
+from heroch.optim.optimizer import Optimizer
+
+class SGD(Optimizer):
+    def __init__(self, parameters, lr=0.01, momentum=0.0):
+        super().__init__(parameters, lr)
+        self.momentum = momentum
+        self.velocities = [0.0 for _ in self.parameters]
+
+    def step(self):
+        for i, p in enumerate(self.parameters):
+            if p.grad is None:
+                continue
+            
+            if self.momentum > 0:
+                self.velocities[i] = self.momentum * self.velocities[i] + (1 - self.momentum) * p.grad
+                p.data -= self.lr * self.velocities[i]
+            else:
+                p.data -= self.lr * p.grad

heroch-0.1.0/heroch/tensor.py

@@ -0,0 +1,195 @@
+import numpy as np
+
+try:
+    import cupy as cp
+    HAS_CUPY = True
+except ImportError:
+    HAS_CUPY = False
+
+def get_array_module(data):
+    if HAS_CUPY:
+        return cp.get_array_module(data)
+    return np
+
+class Tensor:
+    def __init__(self, data, requires_grad=False, depends_on=None):
+        xp = cp if HAS_CUPY and isinstance(data, cp.ndarray) else np
+        
+        if isinstance(data, (int, float)):
+            data = xp.array(data, dtype=np.float32)
+        elif isinstance(data, list):
+            data = xp.array(data, dtype=np.float32)
+        
+        self.data = data
+        self.requires_grad = requires_grad
+        self.depends_on = depends_on or []
+        self.grad = None
+        self.shape = self.data.shape
+
+        if self.requires_grad:
+            self.zero_grad()
+
+    def zero_grad(self):
+        xp = get_array_module(self.data)
+        self.grad = xp.zeros_like(self.data, dtype=np.float32)
+
+    def to_gpu(self):
+        if HAS_CUPY:
+            self.data = cp.asarray(self.data)
+            if self.grad is not None:
+                self.grad = cp.asarray(self.grad)
+        return self
+
+    def to_cpu(self):
+        if HAS_CUPY and isinstance(self.data, cp.ndarray):
+            self.data = cp.asnumpy(self.data)
+            if self.grad is not None:
+                self.grad = cp.asnumpy(self.grad)
+        return self
+
+    def __repr__(self):
+        return f"Tensor({self.data}, requires_grad={self.requires_grad})"
+
+    def backward(self, grad=None):
+        xp = get_array_module(self.data)
+        if grad is None:
+            if self.shape == ():
+                grad = xp.array(1.0, dtype=np.float32)
+            else:
+                raise RuntimeError("backward() can only be called on scalar tensors if no gradient is provided.")
+        
+        if isinstance(grad, Tensor):
+            grad = grad.data
+
+        if self.grad is None:
+            self.grad = grad
+        else:
+            self.grad += grad
+
+        for dependency in self.depends_on:
+            backward_func = dependency['backward_func']
+            tensor = dependency['tensor']
+            grad_to_propagate = backward_func(grad)
+            tensor.backward(grad_to_propagate)
+
+    def __add__(self, other):
+        other = ensure_tensor(other)
+        data = self.data + other.data
+        requires_grad = self.requires_grad or other.requires_grad
+        depends_on = []
+
+        if self.requires_grad:
+            def backward_func(grad):
+                # Gradient of sum is just the gradient (with broadcast handling)
+                ndims_added = grad.ndim - self.data.ndim
+                for _ in range(ndims_added):
+                    grad = grad.sum(axis=0)
+                for i, dim in enumerate(self.data.shape):
+                    if dim == 1:
+                        grad = grad.sum(axis=i, keepdims=True)
+                return grad
+            depends_on.append({'tensor': self, 'backward_func': backward_func})
+        
+        if other.requires_grad:
+            def backward_func(grad):
+                ndims_added = grad.ndim - other.data.ndim
+                for _ in range(ndims_added):
+                    grad = grad.sum(axis=0)
+                for i, dim in enumerate(other.data.shape):
+                    if dim == 1:
+                        grad = grad.sum(axis=i, keepdims=True)
+                return grad
+            depends_on.append({'tensor': other, 'backward_func': backward_func})
+
+        return Tensor(data, requires_grad, depends_on)
+
+    def __mul__(self, other):
+        other = ensure_tensor(other)
+        data = self.data * other.data
+        requires_grad = self.requires_grad or other.requires_grad
+        depends_on = []
+
+        if self.requires_grad:
+            def backward_func(grad):
+                # d(x*y)/dx = y
+                res = grad * other.data
+                ndims_added = res.ndim - self.data.ndim
+                for _ in range(ndims_added):
+                    res = res.sum(axis=0)
+                for i, dim in enumerate(self.data.shape):
+                    if dim == 1:
+                        res = res.sum(axis=i, keepdims=True)
+                return res
+            depends_on.append({'tensor': self, 'backward_func': backward_func})
+
+        if other.requires_grad:
+            def backward_func(grad):
+                # d(x*y)/dy = x
+                res = grad * self.data
+                ndims_added = res.ndim - other.data.ndim
+                for _ in range(ndims_added):
+                    res = res.sum(axis=0)
+                for i, dim in enumerate(other.data.shape):
+                    if dim == 1:
+                        res = res.sum(axis=i, keepdims=True)
+                return res
+            depends_on.append({'tensor': other, 'backward_func': backward_func})
+
+        return Tensor(data, requires_grad, depends_on)
+
+    def __sub__(self, other):
+        return self + (-other)
+
+    def __neg__(self):
+        return self * (-1.0)
+
+    def __matmul__(self, other):
+        # self @ other
+        other = ensure_tensor(other)
+        data = self.data @ other.data
+        requires_grad = self.requires_grad or other.requires_grad
+        depends_on = []
+
+        if self.requires_grad:
+            def backward_func(grad):
+                # d(X@W)/dX = grad @ W.T
+                return grad @ other.data.T
+            depends_on.append({'tensor': self, 'backward_func': backward_func})
+        
+        if other.requires_grad:
+            def backward_func(grad):
+                # d(X@W)/dW = X.T @ grad
+                return self.data.T @ grad
+            depends_on.append({'tensor': other, 'backward_func': backward_func})
+        
+        return Tensor(data, requires_grad, depends_on)
+
+    def sum(self):
+        data = self.data.sum()
+        requires_grad = self.requires_grad
+        depends_on = []
+
+        if self.requires_grad:
+            def backward_func(grad):
+                # Gradient of sum is just the gradient broadcasted to original shape
+                xp = get_array_module(self.data)
+                return grad * xp.ones_like(self.data)
+            depends_on.append({'tensor': self, 'backward_func': backward_func})
+
+        return Tensor(data, requires_grad, depends_on)
+
+    @property
+    def T(self):
+        data = self.data.T
+        requires_grad = self.requires_grad
+        depends_on = []
+        if self.requires_grad:
+            def backward_func(grad):
+                return grad.T
+            depends_on.append({'tensor': self, 'backward_func': backward_func})
+        return Tensor(data, requires_grad, depends_on)
+
+def ensure_tensor(obj):
+    if isinstance(obj, Tensor):
+        return obj
+    return Tensor(obj)

heroch-0.1.0/heroch.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: heroch
+Version: 0.1.0
+Summary: A flexible deep learning library for machine learning and scientific computing with GPU acceleration.
+Author-email: Death Legion Team <contact@deathlegion.team>
+Project-URL: Homepage, https://github.com/death-legion-team/heroch
+Project-URL: Bug Tracker, https://github.com/death-legion-team/heroch/issues
+Keywords: machine learning,deep learning,tensors,autograd,neural networks,GPU acceleration,CUDA,scientific computing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# Heroch: High-Performance Deep Learning and Scientific Computing Library
+
+[![PyPI version](https://badge.fury.io/py/heroch.svg)](https://badge.fury.io/py/heroch)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Heroch** is a powerful, flexible, and intuitive Python library designed for **machine learning**, **deep learning**, and **scientific computing**. It provides a high-performance tensor computation platform with seamless **GPU acceleration** (via CUDA/CuPy) and a dynamic **automatic differentiation** (autograd) engine.
+
+## Why Heroch?
+
+Heroch is built to feel like a native Python library, integrating perfectly with the SciPy ecosystem. Whether you are conducting academic research or building production-level neural networks, Heroch offers the flexibility to experiment and the speed to scale.
+
+### Key Features
+
+*   **⚡ High-Performance Tensor Computations**: Native NumPy interface with optional GPU acceleration for massive speedups.
+*   **🧠 Dynamic Autograd Engine**: Flexible computational graphs that allow you to change network structures on the fly.
+*   **🛠️ Complete Deep Learning Platform**: Built-in modules for linear layers, common activations (ReLU, Sigmoid), and loss functions (MSELoss).
+*   **🚀 Optimized Training**: Robust optimizers including Stochastic Gradient Descent (SGD) with momentum.
+*   **🐍 Pythonic API**: Intuitive design that is easy to debug and executes code as you write it.
+
+## Installation
+
+Install Heroch easily via pip:
+
+```bash
+pip install heroch
+```
+
+*Note: For GPU support, ensure you have an NVIDIA GPU and the appropriate CUDA drivers installed.*
+
+## Quick Start Example
+
+Build and train a simple neural network in minutes:
+
+```python
+import heroch
+import heroch.nn as nn
+import heroch.optim as optim
+from heroch import Tensor
+
+# Define your flexible model structure
+class MyNeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(2, 4)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(4, 1)
+        
+    def forward(self, x):
+        x = self.relu(self.fc1(x))
+        return self.fc2(x)
+
+# Initialize model, loss, and optimizer
+model = MyNeuralNetwork()
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+
+# Training data
+inputs = Tensor([[1.0, 2.0], [3.0, 4.0]])
+targets = Tensor([[5.0], [11.0]])
+
+# Training loop
+for epoch in range(100):
+    optimizer.zero_grad()
+    predictions = model(inputs)
+    loss = criterion(predictions, targets)
+    loss.backward()
+    optimizer.step()
+    
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data}")
+```
+
+## Advanced Usage: GPU Acceleration
+
+Heroch makes it easy to move your computations to the GPU:
+
+```python
+# Move model parameters and data to GPU
+x_gpu = Tensor([1.0, 2.0, 3.0]).to_gpu()
+```
+
+## Contributing
+
+We welcome contributions from the community! Check out our [GitHub repository](https://github.com/death-legion-team/heroch) to get involved.
+
+---
+Developed with 🔥 by **Death Legion Team**.

heroch-0.1.0/heroch.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+heroch/__init__.py
+heroch/tensor.py
+heroch.egg-info/PKG-INFO
+heroch.egg-info/SOURCES.txt
+heroch.egg-info/dependency_links.txt
+heroch.egg-info/requires.txt
+heroch.egg-info/top_level.txt
+heroch/nn/__init__.py
+heroch/nn/activations.py
+heroch/nn/linear.py
+heroch/nn/loss.py
+heroch/nn/module.py
+heroch/optim/__init__.py
+heroch/optim/optimizer.py
+heroch/optim/sgd.py
+tests/test_heroch.py

heroch-0.1.0/heroch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

heroch-0.1.0/heroch.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.20.0

heroch-0.1.0/heroch.egg-info/top_level.txt

@@ -0,0 +1 @@
+heroch

heroch-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "heroch"
+version = "0.1.0"
+authors = [
+  { name="Death Legion Team", email="contact@deathlegion.team" },
+]
+description = "A flexible deep learning library for machine learning and scientific computing with GPU acceleration."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Science/Research",
+    "Development Status :: 3 - Alpha",
+]
+keywords = ["machine learning", "deep learning", "tensors", "autograd", "neural networks", "GPU acceleration", "CUDA", "scientific computing"]
+dependencies = [
+    "numpy>=1.20.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/death-legion-team/heroch"
+"Bug Tracker" = "https://github.com/death-legion-team/heroch/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["heroch*"]

heroch-0.1.0/setup.cfg

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

heroch-0.1.0/tests/test_heroch.py

@@ -0,0 +1,67 @@
+import unittest
+import numpy as np
+from heroch import Tensor
+from heroch.nn.linear import Linear
+from heroch.nn.activations import ReLU, Sigmoid
+from heroch.nn.loss import MSELoss
+from heroch.optim.sgd import SGD
+
+class TestHeroch(unittest.TestCase):
+    def test_tensor_ops(self):
+        a = Tensor([1, 2, 3])
+        b = Tensor([4, 5, 6])
+        c = a + b
+        np.testing.assert_array_equal(c.data, [5, 7, 9])
+        
+        d = a * b
+        np.testing.assert_array_equal(d.data, [4, 10, 18])
+        
+        e = a - b
+        np.testing.assert_array_equal(e.data, [-3, -3, -3])
+
+    def test_autograd_complex(self):
+        x = Tensor(2.0, requires_grad=True)
+        y = Tensor(3.0, requires_grad=True)
+        
+        # f(x, y) = x^2 + 3xy
+        # df/dx = 2x + 3y = 4 + 9 = 13
+        # df/dy = 3x = 6
+        
+        f = x * x + Tensor(3.0) * x * y
+        f.backward()
+        
+        self.assertEqual(x.grad, 13.0)
+        self.assertEqual(y.grad, 6.0)
+
+    def test_linear_layer(self):
+        layer = Linear(3, 2)
+        x = Tensor([[1, 2, 3]], requires_grad=True)
+        out = layer(x)
+        self.assertEqual(out.shape, (1, 2))
+        
+        out.sum().backward()
+        self.assertIsNotNone(layer.weight.grad)
+        self.assertIsNotNone(layer.bias.grad)
+        self.assertIsNotNone(x.grad)
+
+    def test_relu(self):
+        relu = ReLU()
+        x = Tensor([-1, 0, 1], requires_grad=True)
+        out = relu(x)
+        np.testing.assert_array_equal(out.data, [0, 0, 1])
+        
+        out.sum().backward()
+        np.testing.assert_array_equal(x.grad, [0, 0, 1])
+
+    def test_sigmoid(self):
+        sigmoid = Sigmoid()
+        x = Tensor(0.0, requires_grad=True)
+        out = sigmoid(x)
+        self.assertAlmostEqual(out.data.item(), 0.5)
+        
+        out.backward()
+        # dSigmoid(0)/dx = 0.5 * (1 - 0.5) = 0.25
+        self.assertAlmostEqual(x.grad.item(), 0.25)
+
+if __name__ == '__main__':
+    unittest.main()