learngrad 0.1.0__tar.gz

learngrad-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dev Parikh
+
+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.

learngrad-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: learngrad
+Version: 0.1.0
+Summary: A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes.
+Author-email: Dev Parikh <dev.dpparikh@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Dev Parikh
+        
+        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/devparikh0506/learngrad
+Keywords: autograd,neural-network,deep-learning,education,optimizers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Dynamic: license-file
+
+# learngrad
+
+A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes. Inspired by [micrograd](https://github.com/karpathy/micrograd).
+
+## Install
+
+```bash
+pip install learngrad
+```
+
+## What's inside
+
+- **`Value`** — scalar with automatic differentiation via backprop
+- **`MLP`** — multi-layer perceptron built on top of `Value`
+- **Optimizers** — `SGD`, `SGDMomentum`, `RMSProp`, `Adam`
+
+## Quick example
+
+```python
+from learngrad.engine import Value
+from learngrad.nn import  MLP
+from learngrad.optimizers import Adam
+
+# Autograd
+x = Value(2.0)
+y = x ** 2 + x * 3
+y.backward()
+print(x.grad)  # dy/dx = 2x + 3 = 7.0
+
+# Neural net
+model = MLP(2, [4, 4, 1])
+opt = Adam(model.parameters(), lr=1e-3)
+
+x = [Value(1.0), Value(0.5)]
+out = model(x)
+out.backward()
+opt.step()
+```
+
+## Requirements
+
+- Python >= 3.10
+- numpy

learngrad-0.1.0/README.md

@@ -0,0 +1,43 @@
+# learngrad
+
+A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes. Inspired by [micrograd](https://github.com/karpathy/micrograd).
+
+## Install
+
+```bash
+pip install learngrad
+```
+
+## What's inside
+
+- **`Value`** — scalar with automatic differentiation via backprop
+- **`MLP`** — multi-layer perceptron built on top of `Value`
+- **Optimizers** — `SGD`, `SGDMomentum`, `RMSProp`, `Adam`
+
+## Quick example
+
+```python
+from learngrad.engine import Value
+from learngrad.nn import  MLP
+from learngrad.optimizers import Adam
+
+# Autograd
+x = Value(2.0)
+y = x ** 2 + x * 3
+y.backward()
+print(x.grad)  # dy/dx = 2x + 3 = 7.0
+
+# Neural net
+model = MLP(2, [4, 4, 1])
+opt = Adam(model.parameters(), lr=1e-3)
+
+x = [Value(1.0), Value(0.5)]
+out = model(x)
+out.backward()
+opt.step()
+```
+
+## Requirements
+
+- Python >= 3.10
+- numpy

learngrad-0.1.0/learngrad/__init__.py

@@ -0,0 +1 @@
+

learngrad-0.1.0/learngrad/engine.py

@@ -0,0 +1,109 @@
+import numpy as np
+class Value:
+  """
+    stores a singal scalar value and its gradient
+  """
+  def __init__(self, data, children=(), op=''):
+    
+    # payload 
+    self.data = data
+    
+    # children and op used to obtain this value 
+    self._prev  = set(children)
+    self._op = op
+
+    #inital grad for a value = 0
+    self.grad = 0
+    self._backward = lambda : None   
+
+  def __add__(self, other):
+    other = other if isinstance(other, Value) else Value(other)
+    out = Value(self.data + other.data, (self, other), '+')
+    def backward():
+      self.grad += out.grad
+      other.grad += out.grad
+    out._backward = backward
+    return out
+  
+  def __mul__(self, other):
+    other = other if isinstance(other, Value) else Value(other)
+    out = Value(self.data * other.data, (self, other), '*')
+    def backward():
+      self.grad += other.data * out.grad
+      other.grad += self.data * out.grad
+    
+    out._backward = backward
+    return out
+  
+  def __neg__(self):
+    return self * -1
+
+  def __sub__ (self, other):
+    return self + (-other) 
+  
+  def __pow__(self, other):
+    assert isinstance(other, (int, float)), "only supporting int/float powers for now"
+    out = Value(self.data**other, (self,), f'**{other}')
+
+    def backward():
+      self.grad += out.grad * (other * self.data ** (other -1))
+    
+    out._backward = backward
+    return out
+  
+  def __truediv__(self, other):
+    return self * other**-1
+
+  def __rmul__(self, other):
+    return self * other
+  
+  def __radd__(self, other):
+    return self + other
+
+  def __rsub__(self, other):
+    return other + (-self)
+
+  def __repr__(self): 
+    return f"Value(data={self.data}, grad={self.grad})"
+  
+  def __rtruediv__(self, other):
+        return other * self**-1
+
+  def exp(self):
+    out  = Value(np.exp(self.data), (self,), 'exp')
+
+    def backward():
+      self.grad += out.data * out.grad
+    
+    out._backward = backward
+    return out
+  
+
+  def relu(self):
+        out = Value(0 if self.data < 0 else self.data, (self,), 'ReLU')
+
+        def _backward():
+            self.grad += (out.data > 0) * out.grad
+        out._backward = _backward
+
+        return out
+
+
+  def backward(self):
+    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 = 1
+    for val in reversed(topo):
+      val._backward()
+
+def __repr__(self):
+    return f"Value(data={self.data}, grad={self.grad})"
+  

learngrad-0.1.0/learngrad/nn.py

@@ -0,0 +1,69 @@
+import numpy as np
+import random
+from itertools import groupby
+from .engine import Value
+
+
+class Module():
+    def parameters(self): return []
+
+    def zero_grad(self):
+        for p in self.parameters():
+            p.grad = 0
+
+
+class Neuron(Module):
+
+    def __init__(self, nin, nonlin=True) -> None:
+        super().__init__()
+        self.w = [Value(random.uniform(-1, 1)) for _ in range(nin)]
+        self.b = Value(random.uniform(-1, 1))
+        self.nonlin = nonlin
+
+    def __call__(self, x):
+        act = (sum((wi*xi for wi, xi in zip(self.w, x)), self.b))
+        return act.relu() if self.nonlin else act
+
+    def parameters(self):
+        return self.w + [self.b]
+
+    def __repr__(self):
+        return f"{'ReLU' if self.nonlin else 'Linear'}Neuron({len(self.w)})"
+
+
+class Layer(Module):
+    def __init__(self, nin, nout, **kwargs) -> None:
+        super().__init__()
+        self.neurons = [Neuron(nin, **kwargs) for _ in range(nout)]
+
+    def __call__(self, x):
+        out = [n(x) for n in self.neurons]
+        return out[0] if len(out) == 1 else out
+
+    def parameters(self):
+        return [p for n in self.neurons for p in n.parameters()]
+
+    def __repr__(self) -> str:
+        result = []
+        for key, group in groupby(self.neurons, key=str):
+            count = sum(1 for _ in group)
+            result.append(f"{count} x {key}" if count > 1 else key)
+        return f"Layer({", ".join(result)})"
+
+
+class MLP(Module):
+    def __init__(self, nin, nouts) -> None:
+        sz = [nin] + nouts
+        self.layers = [Layer(nin=sz[i], nout=sz[i+1], nonlin=i !=
+                             len(nouts)-1) for i in range(len(nouts))]
+
+    def __call__(self, x):
+        for layer in self.layers:
+            x = layer(x)
+            return x
+
+    def parameters(self):
+        return [p for layer in self.layers for p in layer.parameters()]
+
+    def __repr__(self):
+        return f"MLP(\n{',\n'.join(str(layer) for layer in self.layers)}\n)"

learngrad-0.1.0/learngrad/optimizers.py

@@ -0,0 +1,72 @@
+class SGD:
+    def __init__(self, parameters, lr=0.01):
+        self.lr = lr
+        self.parameters = parameters
+    
+    def step(self):
+        for p in self.parameters:
+            p.data -= self.lr * p.grad
+    
+    def zero_grad(self):
+        for p in self.parameters:
+            p.grad = 0
+
+
+class SGDMomentum:
+  def __init__(self, parameters, lr=0.01, beta=0.9):
+        self.lr = lr
+        self.parameters = parameters
+        self.beta = beta
+        self.v = [0] * len(parameters)
+    
+  def step(self):
+      for i, p in enumerate(self.parameters):
+          self.v[i] = self.v[i] * self.beta + p.grad
+          p.data -= self.lr * self.v[i]
+  
+  def zero_grad(self):
+      for p in self.parameters:
+          p.grad = 0
+
+class RMSProp:
+  def __init__(self, parameters, lr=0.01, beta=0.9, eps = 1e-9) -> None:
+     self.parameters = parameters
+     self.lr = lr
+     self.beta = beta
+     self.eps = eps
+     self.s = [0] * len(parameters)
+
+  def step(self):
+    for i, p in enumerate(self.parameters):
+          self.s[i] = self.beta * self.s[i] + (1 - self.beta) * p.grad**2
+          p.data -= self.lr * (p.grad / (self.s[i] ** 0.5 + self.eps))
+  def zero_grad(self):
+      for p in self.parameters:
+          p.grad = 0
+
+
+class Adam:
+    def __init__(self, parameters, lr=1e-3, beta1=0.9, beta2=0.999, eps=1e-8):
+        self.parameters = parameters
+        self.lr = lr
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.m = [0.0 for _ in parameters]
+        self.v = [0.0 for _ in parameters]
+        self.t = 0
+
+    def zero_grad(self):
+        for p in self.parameters:
+            p.grad = 0
+
+    def step(self):
+        self.t += 1
+        for i, p in enumerate(self.parameters):
+            self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * p.grad
+            self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * p.grad**2
+            
+            m_hat = self.m[i] / (1 - self.beta1**self.t)
+            v_hat = self.v[i] / (1 - self.beta2**self.t)
+            
+            p.data -= self.lr * m_hat / (v_hat**0.5 + self.eps)

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

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: learngrad
+Version: 0.1.0
+Summary: A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes.
+Author-email: Dev Parikh <dev.dpparikh@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Dev Parikh
+        
+        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/devparikh0506/learngrad
+Keywords: autograd,neural-network,deep-learning,education,optimizers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Dynamic: license-file
+
+# learngrad
+
+A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes. Inspired by [micrograd](https://github.com/karpathy/micrograd).
+
+## Install
+
+```bash
+pip install learngrad
+```
+
+## What's inside
+
+- **`Value`** — scalar with automatic differentiation via backprop
+- **`MLP`** — multi-layer perceptron built on top of `Value`
+- **Optimizers** — `SGD`, `SGDMomentum`, `RMSProp`, `Adam`
+
+## Quick example
+
+```python
+from learngrad.engine import Value
+from learngrad.nn import  MLP
+from learngrad.optimizers import Adam
+
+# Autograd
+x = Value(2.0)
+y = x ** 2 + x * 3
+y.backward()
+print(x.grad)  # dy/dx = 2x + 3 = 7.0
+
+# Neural net
+model = MLP(2, [4, 4, 1])
+opt = Adam(model.parameters(), lr=1e-3)
+
+x = [Value(1.0), Value(0.5)]
+out = model(x)
+out.backward()
+opt.step()
+```
+
+## Requirements
+
+- Python >= 3.10
+- numpy

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+learngrad/__init__.py
+learngrad/engine.py
+learngrad/nn.py
+learngrad/optimizers.py
+learngrad.egg-info/PKG-INFO
+learngrad.egg-info/SOURCES.txt
+learngrad.egg-info/dependency_links.txt
+learngrad.egg-info/requires.txt
+learngrad.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+learngrad

learngrad-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "learngrad"
+version = "0.1.0"
+description = "A minimal scalar-valued autograd engine with neural network primitives, built for learning purposes."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [{ name = "Dev Parikh", email = "dev.dpparikh@gmail.com" }]
+dependencies = ["numpy>=1.24"]
+keywords = ["autograd", "neural-network", "deep-learning", "education", "optimizers"]
+
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+     "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/devparikh0506/learngrad"
+
+[tool.setuptools.packages.find]
+include = ["learngrad*"]

learngrad-0.1.0/setup.cfg

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