Vishtorch 0.1.0__tar.gz

vishtorch-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: Vishtorch
+Version: 0.1.0
+Summary: A deep learning framework built completely from scratch.
+Author-email: Vish <your_email@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0

vishtorch-0.1.0/Vishtorch/__init__.py

@@ -0,0 +1,3 @@
+from .tensor import Tensor
+from .nn import Module, Parameter, Linear, Sequential, ReLU, Sigmoid, MSELoss, BCELoss, SimpleDataset, DataLoader
+from .optim import SGD

vishtorch-0.1.0/Vishtorch/nn.py

@@ -0,0 +1,131 @@
+import numpy as np
+from Vishtorch.tensor import Tensor
+
+class Parameter(Tensor):
+    """ A wrapper designating a Tensor as a trainable layer weight or bias """
+    def __init__(self, data):
+        super().__init__(data, requires_grad=True)
+
+
+class Module:
+    """ Base structural Module matching PyTorch tracking layout """
+    def __init__(self):
+        self._modules = {}
+        self._parameters = {}
+
+    def __setattr__(self, name, value):
+        if isinstance(value, Parameter):
+            self._parameters[name] = value
+        elif isinstance(value, Module):
+            self._modules[name] = value
+        super().__setattr__(name, value)
+
+    def parameters(self):
+        params = list(self._parameters.values())
+        for module in self._modules.values():
+            params.extend(module.parameters())
+        return params
+
+    def __call__(self, *args, **kwargs):
+        if hasattr(self, 'forward'):
+            return self.forward(*args, **kwargs)
+        raise NotImplementedError
+
+
+class Linear(Module):
+    """ Fully connected deep learning dense network layer """
+    def __init__(self, in_features, out_features):
+        super().__init__()
+        # Standard Xavier/He initial weight variance scaling
+        bound = 1.0 / np.sqrt(in_features)
+        self.weight = Parameter(np.random.uniform(-bound, bound, (in_features, out_features)))
+        self.bias = Parameter(np.zeros((1, out_features)))
+
+    def forward(self, x):
+        return x @ self.weight + self.bias
+
+
+class Sequential(Module):
+    """ Structural module pipe container that runs layers consecutively """
+    def __init__(self, *layers):
+        super().__init__()
+        self.layers = list(layers)
+        for i, layer in enumerate(self.layers):
+            setattr(self, f"layer_{i}", layer)
+
+    def forward(self, x):
+        out = x
+        for layer in self.layers:
+            out = layer(out)
+        return out
+
+
+class ReLU(Module):
+    def forward(self, x): return x.relu()
+
+
+class Sigmoid(Module):
+    def forward(self, x): return x.sigmoid()
+
+
+class MSELoss(Module):
+    def __call__(self, predictions, targets):
+        diff = predictions + (targets.data * -1.0)
+        sq_diff = Tensor(diff.data ** 2, requires_grad=predictions.requires_grad, _children=(predictions,))
+
+        def _backward():
+            if predictions.requires_grad:
+                N = predictions.data.size
+                predictions.grad += out.grad * (2.0 / N) * diff.data
+        
+        out = sq_diff.sum()
+        out._backward = _backward
+        return out
+
+
+class BCELoss(Module):
+    def __call__(self, predictions, targets):
+        p = np.clip(predictions.data, 1e-7, 1.0 - 1e-7)
+        t = targets.data
+        loss_val = -np.mean(t * np.log(p) + (1.0 - t) * np.log(1.0 - p))
+        out = Tensor(loss_val, requires_grad=predictions.requires_grad, _children=(predictions,))
+
+        def _backward():
+            if predictions.requires_grad:
+                N = predictions.data.size
+                predictions.grad += out.grad * (1.0 / N) * (p - t) / (p * (1.0 - p))
+
+        out._backward = _backward
+        return out
+
+
+class SimpleDataset:
+    def __init__(self, X, y):
+        self.X = np.array(X, dtype=np.float32)
+        self.y = np.array(y, dtype=np.float32)
+
+    def __len__(self): return len(self.X)
+    def __getitem__(self, idx): return self.X[idx], self.y[idx]
+
+
+class DataLoader:
+    def __init__(self, dataset, batch_size=2, shuffle=True):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+
+    def __iter__(self):
+        self.indices = np.arange(len(self.dataset))
+        if self.shuffle:
+            np.random.shuffle(self.indices)
+        self.idx = 0
+        return self
+
+    def __next__(self):
+        if self.idx >= len(self.dataset):
+            raise StopIteration
+        batch_idx = self.indices[self.idx : self.idx + self.batch_size]
+        self.idx += self.batch_size
+        X_batch = [self.dataset[i][0] for i in batch_idx]
+        y_batch = [self.dataset[i][1] for i in batch_idx]
+        return Tensor(X_batch), Tensor(y_batch)

vishtorch-0.1.0/Vishtorch/optim.py

@@ -0,0 +1,14 @@
+class SGD:
+    """ Stochastic Gradient Descent parameter weights manager """
+    def __init__(self, parameters, lr=0.01):
+        self.parameters = list(parameters)
+        self.lr = lr
+
+    def zero_grad(self):
+        for p in self.parameters:
+            if p.grad is not None:
+                p.grad.fill(0.0)
+
+    def step(self):
+        for p in self.parameters:
+            p.data -= self.lr * p.grad

vishtorch-0.1.0/Vishtorch/tensor.py

@@ -0,0 +1,115 @@
+import numpy as np
+
+class Tensor:
+    """ Core Autograd Tensor engine with multidimensional broadcasting support """
+    def __init__(self, data, requires_grad=False, _children=()):
+        self.data = np.array(data, dtype=np.float32)
+        self.requires_grad = requires_grad
+        self.grad = np.zeros_like(self.data) if requires_grad else None
+        self._backward = lambda: None
+        self._prev = set(_children)
+
+    @property
+    def shape(self):
+        return self.data.shape
+    @property
+    def ndim(self):
+        """ Returns the number of dimensions of the underlying data matrix """
+        return self.data.ndim
+
+    def __repr__(self):
+        return f"Tensor(shape={self.shape}, data=\n{self.data})"
+
+    def __add__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = Tensor(self.data + other.data, requires_grad=self.requires_grad or other.requires_grad, _children=(self, other))
+
+        def _backward():
+            if self.requires_grad:
+                grad_self = out.grad
+                # Collapse broadcasted dimensions for self
+                while grad_self.ndim > self.ndim:
+                    grad_self = grad_self.sum(axis=0)
+                for axis, size in enumerate(self.shape):
+                    if size == 1:
+                        grad_self = grad_self.sum(axis=axis, keepdims=True)
+                self.grad += grad_self
+
+            if other.requires_grad:
+                grad_other = out.grad
+                # Collapse broadcasted dimensions for other
+                while grad_other.ndim > other.ndim:
+                    grad_other = grad_other.sum(axis=0)
+                for axis, size in enumerate(other.shape):
+                    if size == 1:
+                        grad_other = grad_other.sum(axis=axis, keepdims=True)
+                other.grad += grad_other
+
+        out._backward = _backward
+        return out
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __matmul__(self, other):
+        assert isinstance(other, Tensor), "Matrix multiplication requires another Tensor"
+        out = Tensor(self.data @ other.data, requires_grad=self.requires_grad or other.requires_grad, _children=(self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += out.grad @ other.data.T
+            if other.requires_grad:
+                other.grad += self.data.T @ out.grad
+
+        out._backward = _backward
+        return out
+
+    def sum(self):
+        out = Tensor(np.sum(self.data), requires_grad=self.requires_grad, _children=(self,))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += out.grad * np.ones_like(self.data)
+
+        out._backward = _backward
+        return out
+
+    def relu(self):
+        out = Tensor(np.maximum(0, self.data), requires_grad=self.requires_grad, _children=(self,))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += out.grad * (self.data > 0)
+
+        out._backward = _backward
+        return out
+
+    def sigmoid(self):
+        clipped_data = np.clip(self.data, -500, 500)
+        out_data = 1.0 / (1.0 + np.exp(-clipped_data))
+        out = Tensor(out_data, requires_grad=self.requires_grad, _children=(self,))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += out.grad * (out.data * (1.0 - out.data))
+
+        out._backward = _backward
+        return out
+
+    def backward(self):
+        """ Dynamically sorts the graph topologially and executes the backward pass """
+        topo = []
+        visited = set()
+
+        def build_topo(v):
+            if v not in visited:
+                visited.add(v)
+                for child in v._prev:
+                    build_topo(child)
+                topo.append(v)
+
+        build_topo(self)
+        self.grad = np.ones_like(self.data)
+
+        for node in reversed(topo):
+            node._backward()

vishtorch-0.1.0/Vishtorch.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: Vishtorch
+Version: 0.1.0
+Summary: A deep learning framework built completely from scratch.
+Author-email: Vish <your_email@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0

vishtorch-0.1.0/Vishtorch.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+Vishtorch/__init__.py
+Vishtorch/nn.py
+Vishtorch/optim.py
+Vishtorch/tensor.py
+Vishtorch.egg-info/PKG-INFO
+Vishtorch.egg-info/SOURCES.txt
+Vishtorch.egg-info/dependency_links.txt
+Vishtorch.egg-info/requires.txt
+Vishtorch.egg-info/top_level.txt

vishtorch-0.1.0/Vishtorch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vishtorch-0.1.0/Vishtorch.egg-info/requires.txt

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

vishtorch-0.1.0/Vishtorch.egg-info/top_level.txt

@@ -0,0 +1 @@
+Vishtorch

vishtorch-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Vishtorch"
+version = "0.1.0"
+authors = [
+    { name="Vish", email="your_email@example.com" }
+]
+description = "A deep learning framework built completely from scratch."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.20.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

vishtorch-0.1.0/setup.cfg

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