leanpass 0.1.0__tar.gz

leanpass-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: leanpass
+Version: 0.1.0
+Summary: A lightweight, transparent alternative to PyTorch/TensorFlow built on NumPy.
+Author: LeanPass
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+# leanpass
+
+A minimal, transparent NumPy-based autograd library for small models.
+
+## Features
+
+- `Tensor` with reverse-mode autodiff
+- Operators: `+`, `-`, `*`, `/`, `**`, `@`
+- Activations: `relu`, `sigmoid`, `softmax`
+- `Linear` and `MLP` modules
+- `SGD` and `Adam` optimizers
+- Graph visualization via `Tensor.visualize_dot()`
+
+## Install
+
+```bash
+pip install .
+```
+
+## Quick start
+
+```python
+from leanpass import Tensor, nn, optim
+
+x = Tensor([[1.0, 2.0]], requires_grad=False)
+model = nn.MLP([2, 16, 3])
+logits = model(x)
+```
+
+## Run demo
+
+```bash
+python demo.py
+```
+
+## Publish to PyPI
+
+1. Update `version` in `pyproject.toml`.
+2. Install build tools:
+
+```bash
+python -m pip install --upgrade build twine
+```
+
+3. Build distribution files:
+
+```bash
+python -m build
+```
+
+4. Upload to PyPI:
+
+```bash
+python -m twine upload dist/*
+```

leanpass-0.1.0/README.md

@@ -0,0 +1,55 @@
+# leanpass
+
+A minimal, transparent NumPy-based autograd library for small models.
+
+## Features
+
+- `Tensor` with reverse-mode autodiff
+- Operators: `+`, `-`, `*`, `/`, `**`, `@`
+- Activations: `relu`, `sigmoid`, `softmax`
+- `Linear` and `MLP` modules
+- `SGD` and `Adam` optimizers
+- Graph visualization via `Tensor.visualize_dot()`
+
+## Install
+
+```bash
+pip install .
+```
+
+## Quick start
+
+```python
+from leanpass import Tensor, nn, optim
+
+x = Tensor([[1.0, 2.0]], requires_grad=False)
+model = nn.MLP([2, 16, 3])
+logits = model(x)
+```
+
+## Run demo
+
+```bash
+python demo.py
+```
+
+## Publish to PyPI
+
+1. Update `version` in `pyproject.toml`.
+2. Install build tools:
+
+```bash
+python -m pip install --upgrade build twine
+```
+
+3. Build distribution files:
+
+```bash
+python -m build
+```
+
+4. Upload to PyPI:
+
+```bash
+python -m twine upload dist/*
+```

leanpass-0.1.0/leanpass/__init__.py

@@ -0,0 +1,5 @@
+from .tensor import Tensor
+from . import nn
+from . import optim
+
+__all__ = ["Tensor", "nn", "optim"]

leanpass-0.1.0/leanpass/nn.py

@@ -0,0 +1,72 @@
+import numpy as np
+
+from .tensor import Tensor
+
+
+class Module:
+    """A base class for layers and model containers."""
+
+    def parameters(self):
+        """Collect all trainable Tensor parameters recursively."""
+        params = []
+        for value in self.__dict__.values():
+            if isinstance(value, Tensor) and value.requires_grad:
+                params.append(value)
+            elif isinstance(value, Module):
+                params.extend(value.parameters())
+        return params
+
+    def zero_grad(self):
+        """Reset gradients before each optimization step."""
+        for param in self.parameters():
+            param.grad = np.zeros_like(param.data)
+
+
+class Linear(Module):
+    """A single fully connected layer: y = x @ W + b."""
+
+    def __init__(self, in_features, out_features):
+        scale = 1.0 / np.sqrt(in_features)
+        self.weight = Tensor(
+            np.random.uniform(-scale, scale, size=(in_features, out_features)),
+            requires_grad=True,
+        )
+        self.bias = Tensor(np.zeros(out_features), requires_grad=True)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x @ self.weight + self.bias
+
+    def __call__(self, x: Tensor) -> Tensor:
+        return self.forward(x)
+
+
+class MLP(Module):
+    """A simple feedforward network with ReLU activations."""
+
+    def __init__(self, layer_sizes):
+        self.layers = []
+        for in_dim, out_dim in zip(layer_sizes[:-1], layer_sizes[1:]):
+            self.layers.append(Linear(in_dim, out_dim))
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Propagate the input through each layer and apply ReLU except last."""
+        for index, layer in enumerate(self.layers):
+            x = layer(x)
+            if index < len(self.layers) - 1:
+                x = x.relu()
+        return x
+
+    def __call__(self, x: Tensor) -> Tensor:
+        return self.forward(x)
+
+    def parameters(self):
+        """Return parameters from every Linear layer in the network."""
+        params = []
+        for layer in self.layers:
+            params.extend(layer.parameters())
+        return params
+
+
+def mse_loss(prediction: Tensor, target: Tensor) -> Tensor:
+    """Mean squared error loss used for regression training."""
+    return ((prediction - target) ** 2).mean()

leanpass-0.1.0/leanpass/optim.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+
+class SGD:
+    """Simple stochastic gradient descent optimizer."""
+
+    def __init__(self, params, lr=1e-2):
+        self.params = list(params)
+        self.lr = lr
+
+    def step(self):
+        """Apply a plain gradient descent update to each parameter."""
+        for param in self.params:
+            if param.grad is None:
+                continue
+            param.data = param.data - self.lr * param.grad
+
+    def zero_grad(self):
+        """Zero out gradients so the next backward pass starts clean."""
+        for param in self.params:
+            param.grad = np.zeros_like(param.data)
+
+
+class Adam:
+    """Adam optimizer with bias-corrected moment estimates."""
+
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8):
+        self.params = list(params)
+        self.lr = lr
+        self.b1, self.b2 = betas
+        self.eps = eps
+        self.m = [np.zeros_like(p.data) for p in self.params]
+        self.v = [np.zeros_like(p.data) for p in self.params]
+        self.t = 0
+
+    def step(self):
+        """Update each parameter using Adam's adaptive moment estimates."""
+        self.t += 1
+        for i, param in enumerate(self.params):
+            if param.grad is None:
+                continue
+            g = param.grad
+            self.m[i] = self.b1 * self.m[i] + (1 - self.b1) * g
+            self.v[i] = self.b2 * self.v[i] + (1 - self.b2) * (g ** 2)
+
+            m_hat = self.m[i] / (1 - self.b1 ** self.t)
+            v_hat = self.v[i] / (1 - self.b2 ** self.t)
+            param.data = param.data - self.lr * m_hat / (np.sqrt(v_hat) + self.eps)
+
+    def zero_grad(self):
+        """Zero out gradients for all tracked parameters."""
+        for param in self.params:
+            param.grad = np.zeros_like(param.data)

leanpass-0.1.0/leanpass/tensor.py

@@ -0,0 +1,530 @@
+import numpy as np
+
+
+def _ensure_array(data):
+    """Convert inputs to NumPy arrays so math is always numeric."""
+    if isinstance(data, Tensor):
+        return data.data
+    return np.array(data, dtype=np.float64)
+
+
+def _sum_to_shape(grad, shape):
+    """Reduce broadcasted gradients back to the shape of the original tensor."""
+    if grad.shape == shape:
+        return grad
+
+    while grad.ndim > len(shape):
+        grad = grad.sum(axis=0)
+
+    for axis, size in enumerate(shape):
+        if size == 1 and grad.shape[axis] != 1:
+            grad = grad.sum(axis=axis, keepdims=True)
+
+    return grad.reshape(shape)
+
+
+class Tensor:
+    """A tiny automatic differentiation tensor backed by NumPy."""
+
+    def __init__(self, data, requires_grad=False, name=None):
+        self.data = np.array(data, dtype=np.float64)
+        self.grad = np.zeros_like(self.data) if requires_grad else None
+        self.requires_grad = requires_grad
+        self._backward = lambda: None
+        self._prev = ()
+        self._op = ""
+        self._meta = {}
+        self.name = name
+
+    def __repr__(self):
+        name = f" name={self.name}" if self.name else ""
+        return f"Tensor(shape={self.data.shape}, requires_grad={self.requires_grad}{name})"
+
+    def _create_child(self, data, op, prev, name=None, meta=None):
+        out = Tensor(data, requires_grad=any(node.requires_grad for node in prev), name=name)
+        out._prev = tuple(prev)
+        out._op = op
+        out._meta = meta or {}
+        return out
+
+    def __add__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = self._create_child(self.data + other.data, "+", (self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad, self.data.shape)
+            if other.requires_grad:
+                other.grad += _sum_to_shape(out.grad, other.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __radd__(self, other):
+        return self + other
+
+    def __neg__(self):
+        out = self._create_child(-self.data, "neg", (self,))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(-out.grad, self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __sub__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = self._create_child(self.data - other.data, "-", (self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad, self.data.shape)
+            if other.requires_grad:
+                other.grad += _sum_to_shape(-out.grad, other.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __rsub__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        return other - self
+
+    def __mul__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = self._create_child(self.data * other.data, "*", (self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad * other.data, self.data.shape)
+            if other.requires_grad:
+                other.grad += _sum_to_shape(out.grad * self.data, other.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __rmul__(self, other):
+        return self * other
+
+    def __truediv__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = self._create_child(self.data / other.data, "/", (self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad / other.data, self.data.shape)
+            if other.requires_grad:
+                other.grad += _sum_to_shape(-out.grad * self.data / (other.data ** 2), other.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __pow__(self, exponent):
+        exponent = float(exponent)
+        out = self._create_child(self.data ** exponent, "**", (self,), meta={"exponent": exponent})
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad * exponent * self.data ** (exponent - 1), self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def exp(self):
+        out = self._create_child(np.exp(self.data), "exp", {self})
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad * out.data, self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def log(self):
+        out = self._create_child(np.log(self.data), "log", {self})
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad / self.data, self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def sigmoid(self):
+        out = self._create_child(1 / (1 + np.exp(-self.data)), "sigmoid", {self})
+
+        def _backward():
+            if self.requires_grad:
+                sigmoid_grad = out.data * (1 - out.data)
+                self.grad += _sum_to_shape(out.grad * sigmoid_grad, self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def softmax(self, axis=-1):
+        shifted = self.data - self.data.max(axis=axis, keepdims=True)
+        exp_values = np.exp(shifted)
+        probabilities = exp_values / exp_values.sum(axis=axis, keepdims=True)
+        out = self._create_child(probabilities, "softmax", {self})
+
+        def _backward():
+            if self.requires_grad:
+                grad = out.grad
+                sum_grad = (grad * out.data).sum(axis=axis, keepdims=True)
+                self.grad += _sum_to_shape(out.data * (grad - sum_grad), self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def __matmul__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other)
+        out = self._create_child(self.data @ other.data, "@", (self, other))
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += _sum_to_shape(out.grad @ other.data.T, self.data.shape)
+            if other.requires_grad:
+                other.grad += _sum_to_shape(self.data.T @ out.grad, other.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def relu(self):
+        out = self._create_child(np.maximum(0, self.data), "relu", {self})
+
+        def _backward():
+            if self.requires_grad:
+                grad_input = out.grad * (self.data > 0).astype(np.float64)
+                self.grad += _sum_to_shape(grad_input, self.data.shape)
+
+        out._backward = _backward
+        return out
+
+    def sum(self):
+        out = Tensor(self.data.sum(), requires_grad=self.requires_grad, name="sum")
+        out._prev = {self}
+        out._op = "sum"
+
+        def _backward():
+            if self.requires_grad:
+                self.grad += np.ones_like(self.data) * out.grad
+
+        out._backward = _backward
+        return out
+
+    def mean(self):
+        out = Tensor(self.data.mean(), requires_grad=self.requires_grad, name="mean")
+        out._prev = {self}
+        out._op = "mean"
+
+        def _backward():
+            if self.requires_grad:
+                scale = 1.0 / self.data.size
+                self.grad += np.ones_like(self.data) * out.grad * scale
+
+        out._backward = _backward
+        return out
+
+    def visualize(self):
+        """Return a simple text representation of the computation graph."""
+        nodes = []
+        edges = []
+        visited = set()
+
+        def build(v):
+            if v in visited:
+                return
+            visited.add(v)
+            label = v._op or "leaf"
+            if v.name:
+                label += f" ({v.name})"
+            nodes.append((id(v), label, v.data.shape))
+            for child in v._prev:
+                edges.append((id(child), id(v)))
+                build(child)
+
+        build(self)
+
+        lines = [f"Node {nid}: {label} shape={shape}" for nid, label, shape in nodes]
+        lines += [f"Edge {src} -> {dst}" for src, dst in edges]
+        return "\n".join(lines)
+
+    def visualize_dot(self):
+        """Return a Graphviz DOT representation of the computation graph."""
+        nodes, edges = self._graph_nodes()
+        lines = ["digraph computation_graph {", "  rankdir=LR;", "  node [shape=box, style=filled, fillcolor=lightgray];"]
+
+        for node in nodes:
+            label = node._op or "leaf"
+            if node.name:
+                label += f"\n{node.name}"
+            shape = "ellipse" if len(node._prev) == 0 else "box"
+            lines.append(f"  n{ id(node) } [label=\"{label}\", shape={shape}];")
+
+        for src, dst in edges:
+            lines.append(f"  n{src} -> n{dst};")
+
+        lines.append("}")
+        return "\n".join(lines)
+
+    def backward(self, gradient=None):
+        if gradient is None:
+            gradient = np.ones_like(self.data)
+        if self.grad is None:
+            self.grad = np.zeros_like(self.data)
+        self.grad = self.grad + np.array(gradient, dtype=np.float64)
+
+        topo = []
+        visited = set()
+
+        def build(v):
+            if v not in visited:
+                visited.add(v)
+                for child in v._prev:
+                    build(child)
+                topo.append(v)
+
+        build(self)
+
+        for node in topo:
+            if node.requires_grad and node.grad is None:
+                node.grad = np.zeros_like(node.data)
+
+        for node in reversed(topo):
+            node._backward()
+
+    def _graph_nodes(self):
+        nodes = []
+        edges = []
+        visited = set()
+
+        def build(v):
+            if v in visited:
+                return
+            visited.add(v)
+            nodes.append(v)
+            for child in v._prev:
+                edges.append((id(child), id(v)))
+                build(child)
+
+        build(self)
+        return nodes, edges
+
+    def grad_check(self, eps=1e-6, tol=1e-4):
+        """Compare backward gradients against finite differences."""
+        if not self.requires_grad:
+            raise ValueError("grad_check requires the output tensor to require gradients")
+
+        nodes, _ = self._graph_nodes()
+        numeric = {}
+
+        for node in nodes:
+            if not node.requires_grad:
+                continue
+            original = node.data.copy()
+            numeric_grad = np.zeros_like(node.data)
+            for idx in np.ndindex(node.data.shape):
+                node.data[idx] = original[idx] + eps
+                plus = self._eval_forward()
+                node.data[idx] = original[idx] - eps
+                minus = self._eval_forward()
+                node.data[idx] = original[idx]
+                numeric_grad[idx] = (np.sum(plus) - np.sum(minus)) / (2 * eps)
+
+            self.zero_grad_all()
+            self.backward()
+            numeric[node] = numeric_grad
+            node.data = original
+
+        errors = []
+        for node in nodes:
+            if not node.requires_grad:
+                continue
+            diff = np.max(np.abs(node.grad - numeric[node]))
+            if diff > tol:
+                errors.append((node, diff, node.grad, numeric[node]))
+
+        return errors
+
+    def _eval_forward(self):
+        """Evaluate the graph forward using current leaf values without mutating nodes."""
+        topo = []
+        visited = set()
+        values = {}
+
+        def build(v):
+            if v not in visited:
+                visited.add(v)
+                for child in v._prev:
+                    build(child)
+                topo.append(v)
+
+        build(self)
+
+        for node in topo:
+            if len(node._prev) == 0:
+                values[node] = node.data
+                continue
+
+            if node._op == "+":
+                values[node] = values[node._prev[0]] + values[node._prev[1]]
+            elif node._op == "-":
+                values[node] = values[node._prev[0]] - values[node._prev[1]]
+            elif node._op == "*":
+                values[node] = values[node._prev[0]] * values[node._prev[1]]
+            elif node._op == "/":
+                values[node] = values[node._prev[0]] / values[node._prev[1]]
+            elif node._op == "**":
+                exponent = node._meta.get("exponent", 2.0)
+                values[node] = values[node._prev[0]] ** exponent
+            elif node._op == "@":
+                values[node] = values[node._prev[0]] @ values[node._prev[1]]
+            elif node._op == "relu":
+                values[node] = np.maximum(0, values[node._prev[0]])
+            elif node._op == "exp":
+                values[node] = np.exp(values[node._prev[0]])
+            elif node._op == "log":
+                values[node] = np.log(values[node._prev[0]])
+            elif node._op == "sigmoid":
+                x = values[node._prev[0]]
+                values[node] = 1 / (1 + np.exp(-x))
+            elif node._op == "softmax":
+                x = values[node._prev[0]]
+                shifted = x - x.max(axis=-1, keepdims=True)
+                exp_values = np.exp(shifted)
+                values[node] = exp_values / exp_values.sum(axis=-1, keepdims=True)
+            elif node._op == "sum":
+                values[node] = values[node._prev[0]].sum()
+            elif node._op == "mean":
+                values[node] = values[node._prev[0]].mean()
+            elif node._op == "neg":
+                values[node] = -values[node._prev[0]]
+            else:
+                values[node] = node.data
+
+        return values[self]
+
+    def zero_grad_all(self):
+        """Zero all gradients in the current graph."""
+        nodes, _ = self._graph_nodes()
+        for node in nodes:
+            if node.requires_grad:
+                node.grad = np.zeros_like(node.data)
+
+    def _graph_nodes(self):
+        nodes = []
+        edges = []
+        visited = set()
+
+        def build(v):
+            if v in visited:
+                return
+            visited.add(v)
+            nodes.append(v)
+            for child in v._prev:
+                edges.append((id(child), id(v)))
+                build(child)
+
+        build(self)
+        return nodes, edges
+
+    def grad_check(self, eps=1e-6, tol=1e-4):
+        """Compare analytical gradients to numerical finite differences."""
+        if not self.requires_grad:
+            raise ValueError("grad_check requires the output tensor to require gradients")
+
+        nodes, _ = self._graph_nodes()
+        numeric = {}
+
+        def scalar_forward():
+            return float(self.data.sum()) if self.data.size == 1 else None
+
+        for node in nodes:
+            if not node.requires_grad:
+                continue
+            analytic = np.zeros_like(node.data)
+            numeric_grad = np.zeros_like(node.data)
+            original = node.data.copy()
+
+            it = np.nditer(node.data, flags=["multi_index"], op_flags=["readwrite"])
+            while not it.finished:
+                idx = it.multi_index
+                node.data[idx] = original[idx] + eps
+                plus = self._eval_forward()
+                node.data[idx] = original[idx] - eps
+                minus = self._eval_forward()
+                node.data[idx] = original[idx]
+                numeric_grad[idx] = (plus - minus) / (2 * eps)
+                it.iternext()
+
+            node.zero_grad_all()
+            self.backward()
+            analytic = node.grad.copy()
+            numeric[node] = numeric_grad
+            node.data = original
+
+        errors = []
+        for node in nodes:
+            if not node.requires_grad:
+                continue
+            diff = np.max(np.abs(node.grad - numeric[node]))
+            if diff > tol:
+                errors.append((node, diff, node.grad, numeric[node]))
+
+        return errors
+
+    def _eval_forward(self):
+        """Evaluate current graph data forward to this tensor using NumPy semantics."""
+        topo = []
+        visited = set()
+
+        def build(v):
+            if v not in visited:
+                visited.add(v)
+                for child in v._prev:
+                    build(child)
+                topo.append(v)
+
+        build(self)
+
+        for node in topo:
+            if node._op == "leaf":
+                continue
+            if node._op == "+":
+                node.data = list(node._prev)[0].data + list(node._prev)[1].data
+            elif node._op == "-":
+                node.data = list(node._prev)[0].data - list(node._prev)[1].data
+            elif node._op == "*":
+                node.data = list(node._prev)[0].data * list(node._prev)[1].data
+            elif node._op == "/":
+                node.data = list(node._prev)[0].data / list(node._prev)[1].data
+            elif node._op == "**":
+                node.data = list(node._prev)[0].data ** float(2)
+            elif node._op == "@":
+                node.data = list(node._prev)[0].data @ list(node._prev)[1].data
+            elif node._op == "relu":
+                node.data = np.maximum(0, list(node._prev)[0].data)
+            elif node._op == "exp":
+                node.data = np.exp(list(node._prev)[0].data)
+            elif node._op == "log":
+                node.data = np.log(list(node._prev)[0].data)
+            elif node._op == "sigmoid":
+                x = list(node._prev)[0].data
+                node.data = 1 / (1 + np.exp(-x))
+            elif node._op == "softmax":
+                x = list(node._prev)[0].data
+                shifted = x - x.max(axis=-1, keepdims=True)
+                exp_values = np.exp(shifted)
+                node.data = exp_values / exp_values.sum(axis=-1, keepdims=True)
+            elif node._op == "sum":
+                node.data = list(node._prev)[0].data.sum()
+            elif node._op == "mean":
+                node.data = list(node._prev)[0].data.mean()
+        return float(self.data) if np.isscalar(self.data) else self.data
+
+    def zero_grad_all(self):
+        """Zero all gradients in the current graph."""
+        nodes, _ = self._graph_nodes()
+        for node in nodes:
+            if node.requires_grad:
+                node.grad = np.zeros_like(node.data)

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

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: leanpass
+Version: 0.1.0
+Summary: A lightweight, transparent alternative to PyTorch/TensorFlow built on NumPy.
+Author: LeanPass
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+# leanpass
+
+A minimal, transparent NumPy-based autograd library for small models.
+
+## Features
+
+- `Tensor` with reverse-mode autodiff
+- Operators: `+`, `-`, `*`, `/`, `**`, `@`
+- Activations: `relu`, `sigmoid`, `softmax`
+- `Linear` and `MLP` modules
+- `SGD` and `Adam` optimizers
+- Graph visualization via `Tensor.visualize_dot()`
+
+## Install
+
+```bash
+pip install .
+```
+
+## Quick start
+
+```python
+from leanpass import Tensor, nn, optim
+
+x = Tensor([[1.0, 2.0]], requires_grad=False)
+model = nn.MLP([2, 16, 3])
+logits = model(x)
+```
+
+## Run demo
+
+```bash
+python demo.py
+```
+
+## Publish to PyPI
+
+1. Update `version` in `pyproject.toml`.
+2. Install build tools:
+
+```bash
+python -m pip install --upgrade build twine
+```
+
+3. Build distribution files:
+
+```bash
+python -m build
+```
+
+4. Upload to PyPI:
+
+```bash
+python -m twine upload dist/*
+```

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.cfg
+leanpass/__init__.py
+leanpass/nn.py
+leanpass/optim.py
+leanpass/tensor.py
+leanpass.egg-info/PKG-INFO
+leanpass.egg-info/SOURCES.txt
+leanpass.egg-info/dependency_links.txt
+leanpass.egg-info/entry_points.txt
+leanpass.egg-info/requires.txt
+leanpass.egg-info/top_level.txt
+tests/test_gradcheck.py
+tests/test_leanpass.py

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

@@ -0,0 +1 @@
+

leanpass-0.1.0/leanpass.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leanpass-demo = demo:main

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

@@ -0,0 +1 @@
+numpy

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

@@ -0,0 +1 @@
+leanpass

leanpass-0.1.0/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "leanpass"
+version = "0.1.0"
+description = "A lightweight, transparent alternative to PyTorch/TensorFlow built on NumPy."
+authors = [{ name = "LeanPass" }]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["numpy"]
+
+[project.scripts]
+leanpass-demo = "demo:main"

leanpass-0.1.0/setup.cfg

@@ -0,0 +1,13 @@
+[metadata]
+name = leanpass
+version = 0.1.0
+
+[flake8]
+max-line-length = 88
+ignore = E203, W503
+exclude = .git,__pycache__,build,dist,.venv
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

leanpass-0.1.0/tests/test_gradcheck.py

@@ -0,0 +1,81 @@
+import numpy as np
+
+from leanpass import Tensor
+
+
+def finite_difference_grad(f, x, eps=1e-6):
+    orig = x.data.copy()
+    grad = np.zeros_like(x.data)
+    for idx in np.ndindex(x.data.shape):
+        x.data[idx] = orig[idx] + eps
+        plus = f().data.copy()
+        x.data[idx] = orig[idx] - eps
+        minus = f().data.copy()
+        x.data[idx] = orig[idx]
+        grad[idx] = (plus - minus).sum() / (2 * eps)
+    return grad
+
+
+def test_grad_check_add():
+    x = Tensor([1.0, 2.0], requires_grad=True)
+    y = Tensor([3.0, 4.0], requires_grad=True)
+    z = (x + y).sum()
+    z.backward()
+
+    assert np.allclose(x.grad, [1.0, 1.0])
+    assert np.allclose(y.grad, [1.0, 1.0])
+
+
+def test_grad_check_power():
+    x = Tensor([2.0, 3.0], requires_grad=True)
+    z = (x ** 3).sum()
+    z.backward()
+
+    assert np.allclose(x.grad, [12.0, 27.0])
+
+
+def test_grad_check_sigmoid():
+    x = Tensor([0.5, -0.5], requires_grad=True)
+    z = x.sigmoid().sum()
+    z.backward()
+
+    numeric = finite_difference_grad(lambda: x.sigmoid(), x)
+    assert np.allclose(x.grad, numeric, atol=1e-4)
+
+
+def test_grad_check_exp_log():
+    x = Tensor([0.5, 1.0], requires_grad=True)
+    z = x.exp().log().sum()
+    z.backward()
+
+    numeric = finite_difference_grad(lambda: x.exp().log(), x)
+    assert np.allclose(x.grad, numeric, atol=1e-4)
+
+
+def test_grad_check_softmax():
+    x = Tensor([[1.0, 2.0, 3.0]], requires_grad=True)
+    z = x.softmax().sum()
+    z.backward()
+
+    numeric = finite_difference_grad(lambda: x.softmax(), x)
+    assert np.allclose(x.grad, numeric, atol=1e-4)
+
+
+def test_grad_check_graph_visualizer():
+    x = Tensor([1.0, 2.0], requires_grad=True, name="input")
+    y = (x * x + x.sigmoid()).sum()
+    graph = y.visualize()
+
+    assert "softmax" not in graph
+    assert "relu" not in graph
+    assert "input" in graph
+
+
+def test_visualize_dot():
+    x = Tensor([1.0, 2.0], requires_grad=True, name="input")
+    y = (x * x + x.sigmoid()).sum()
+    dot = y.visualize_dot()
+
+    assert dot.startswith("digraph")
+    assert "->" in dot
+    assert "input" in dot

leanpass-0.1.0/tests/test_leanpass.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from leanpass import Tensor, nn, optim
+
+
+def test_tensor_basic_arithmetic():
+    x = Tensor([1.0, 2.0], requires_grad=True)
+    y = Tensor([3.0, 4.0], requires_grad=True)
+
+    z = x * y + x
+    z_sum = z.sum()
+    z_sum.backward()
+
+    assert np.allclose(x.grad, [4.0, 5.0])
+    assert np.allclose(y.grad, [1.0, 2.0])
+
+
+def test_linear_forward_backward():
+    layer = nn.Linear(2, 1)
+    x = Tensor([[1.0, 2.0]], requires_grad=False)
+    y = layer(x)
+    loss = y.sum()
+    loss.backward()
+
+    assert layer.weight.grad.shape == layer.weight.data.shape
+    assert layer.bias.grad.shape == layer.bias.data.shape
+
+
+def test_mlp_training_step():
+    model = nn.MLP([2, 4, 1])
+    optimizer = optim.SGD(model.parameters(), lr=0.1)
+
+    x = Tensor([[1.0, 1.0]], requires_grad=False)
+    y_true = Tensor([[2.0]], requires_grad=False)
+
+    pred = model(x)
+    loss = nn.mse_loss(pred, y_true)
+    model.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    assert all(param.grad is not None for param in model.parameters())
+    assert any(np.any(param.data != 0) for param in model.parameters())