simplegrad 0.0.2__tar.gz

simplegrad-0.0.2/MANIFEST.in

@@ -0,0 +1,5 @@
+include MANIFEST.md
+include py-simplegrad/simplegrad-dev/simplegrad.pyi
+include py-simplegrad/simplegrad-dev/py.typed
+include py-simplegrad/simplegrad-dev/__init__.py
+include py-simplegrad/simplegrad-dev/simplegrad.cpython-312-x86_64-linux-gnu.so

simplegrad-0.0.2/MANIFEST.md

@@ -0,0 +1,78 @@
+# SimpleGrad
+
+SimpleGrad is a lightweight automatic differentiation library written in C++ with Python bindings.
+
+### Compatible Operating Systems:
+- Linux (x86_64 architecture only)
+
+## Installation
+```bash
+pip install simplegrad
+```
+
+## Features
+
+- Multi-layer perceptron (MLP) which can be used for regression and classification tasks
+- Supports basic arithmetic operations
+- Lightweight and easy to use
+- Gradient computation
+- Backpropagation
+- Numpy compatibility
+
+
+## Usage
+
+Here's a quick example of how to use MLP in SimpleGrad:
+
+```python
+from simplegrad import MLP, Node
+from sklearn import datasets
+
+# Define the model
+X, y = datasets.make_classification(
+        n_samples=1000,
+        n_features=10,
+        n_classes=2,
+        random_state=42,  # for reproducibility
+    )
+lr = 0.01
+batch_size = 16
+epochs = 10
+
+# Define the model
+model = MLP(
+    10, [16, 1]
+)  # 2 input nodes, 2 hidden layers with arbitrary sizes, 1 output node
+
+# Training data
+n_batches = (len(X) + batch_size - 1) // batch_size  # Ceiling division
+
+for epoch in range(epochs):
+    epoch_loss = 0.0
+    for i in range(0, len(X), batch_size):
+        batch_X = X[i : i + batch_size]
+        batch_y = y[i : i + batch_size]
+        current_batch_size = len(batch_X)  # Handle last batch
+
+        batch_loss = 0.0
+        #model.zero_grad()  # gradients are automatically reset after step function
+
+        # Accumulate gradients over batch
+        for x, y_true in zip(batch_X, batch_y):
+            y_hat = model(x)[0]
+            y_true = Node(y_true)
+            loss = (y_hat - y_true) ** 2
+            loss = loss * (1.0 / current_batch_size)  # Normalize loss
+            batch_loss += loss.data()
+            loss.backward()
+
+        model.step(lr)  # Update weights using accumulated gradients
+        del loss, y_hat, y_true  # Clean up
+        epoch_loss += batch_loss
+
+    # Average loss over all batches
+    print(f"Epoch {epoch+1}, Average Loss: {epoch_loss/n_batches:.3f}")
+```
+
+
+

simplegrad-0.0.2/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: simplegrad
+Version: 0.0.2
+Summary: Automatic differentiation library for basic arithmetic operations
+Home-page: https://github.com/deniztemur00/simplegrad.git
+Author: Deniz
+Author-email: deniztemur00@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# SimpleGrad
+
+SimpleGrad is a lightweight automatic differentiation library written in C++ with Python bindings.
+
+### Compatible Operating Systems:
+- Linux (x86_64 architecture only)
+
+## Installation
+```bash
+pip install simplegrad
+```
+
+## Features
+
+- Multi-layer perceptron (MLP) which can be used for regression and classification tasks
+- Supports basic arithmetic operations
+- Lightweight and easy to use
+- Gradient computation
+- Backpropagation
+- Numpy compatibility
+
+
+## Usage
+
+Here's a quick example of how to use MLP in SimpleGrad:
+
+```python
+from simplegrad import MLP, Node
+from sklearn import datasets
+
+# Define the model
+X, y = datasets.make_classification(
+        n_samples=1000,
+        n_features=10,
+        n_classes=2,
+        random_state=42,  # for reproducibility
+    )
+lr = 0.01
+batch_size = 16
+epochs = 10
+
+# Define the model
+model = MLP(
+    10, [16, 1]
+)  # 2 input nodes, 2 hidden layers with arbitrary sizes, 1 output node
+
+# Training data
+n_batches = (len(X) + batch_size - 1) // batch_size  # Ceiling division
+
+for epoch in range(epochs):
+    epoch_loss = 0.0
+    for i in range(0, len(X), batch_size):
+        batch_X = X[i : i + batch_size]
+        batch_y = y[i : i + batch_size]
+        current_batch_size = len(batch_X)  # Handle last batch
+
+        batch_loss = 0.0
+        #model.zero_grad()  # gradients are automatically reset after step function
+
+        # Accumulate gradients over batch
+        for x, y_true in zip(batch_X, batch_y):
+            y_hat = model(x)[0]
+            y_true = Node(y_true)
+            loss = (y_hat - y_true) ** 2
+            loss = loss * (1.0 / current_batch_size)  # Normalize loss
+            batch_loss += loss.data()
+            loss.backward()
+
+        model.step(lr)  # Update weights using accumulated gradients
+        del loss, y_hat, y_true  # Clean up
+        epoch_loss += batch_loss
+
+    # Average loss over all batches
+    print(f"Epoch {epoch+1}, Average Loss: {epoch_loss/n_batches:.3f}")
+```
+
+
+

simplegrad-0.0.2/README.md

@@ -0,0 +1,105 @@
+# SimpleGrad
+
+SimpleGrad is a lightweight automatic differentiation library written in C++ with Python bindings.
+
+## Prerequisites
+
+- Python 3.10 or higher
+- g++/gcc with C++17 support
+- CMake 3.12 or higher
+- pybind11
+
+## Build & Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/deniztemur00/simplegrad.git
+cd simplegrad
+```
+2. Build with makefile:
+```bash
+make build-release
+```
+## Features
+
+- Multi-layer perceptron (MLP) which can be used for regression and classification tasks
+- Supports basic arithmetic operations
+- Lightweight and easy to use
+- Gradient computation
+- Backpropagation
+- Numpy compatibility
+
+
+## Usage
+
+Here's a quick example of how to use MLP in SimpleGrad:
+
+```python
+from simplegrad import MLP, Node
+from sklearn import datasets
+
+# Define the model
+X, y = datasets.make_classification(
+        n_samples=1000,
+        n_features=10,
+        n_classes=2,
+        random_state=42,  # for reproducibility
+    )
+
+
+lr = 0.01
+batch_size = 16
+epochs = 10
+
+# Define the model
+model = MLP(
+    10, [12, 1]
+)  # 2 input nodes, 2 hidden layers with arbitrary sizes, 1 output node
+
+# Training data
+n_batches = (len(X) + batch_size - 1) // batch_size  # Ceiling division
+
+for epoch in range(epochs):
+    epoch_loss = 0.0
+    for i in range(0, len(X), batch_size):
+        batch_X = X[i : i + batch_size]
+        batch_y = y[i : i + batch_size]
+        current_batch_size = len(batch_X)  # Handle last batch
+
+        batch_loss = 0.0
+        #model.zero_grad()  # gradients are automatically reset after step function
+
+        # Accumulate gradients over batch
+        for x, y_true in zip(batch_X, batch_y):
+            y_hat = model(x)[0]
+            y_true = Node(y_true)
+            loss = (y_hat - y_true) ** 2
+            loss = loss * (1.0 / current_batch_size)  # Normalize loss
+            batch_loss += loss.data()
+            loss.backward()
+
+        model.step(lr)  # Update weights using accumulated gradients
+        epoch_loss += batch_loss
+
+    # Average loss over all batches
+    print(f"Epoch {epoch+1}, Average Loss: {epoch_loss/n_batches:.3f}")
+```
+You can execute the above code by running the following command:
+```bash
+make run
+```
+
+## Testing
+Tests are written to ensure the correctness of the Node class. Thus making sure MLP works as expected. You can run tests with following command:
+```bash
+make test
+```
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgements
+
+This project was inspired by the [micrograd](https://github.com/karpathy/micrograd) project by Andrej Karpathy. 
+
+

simplegrad-0.0.2/py-simplegrad/simplegrad-dev/__init__.py

@@ -0,0 +1,3 @@
+from .simplegrad import Node, MLP
+
+__all__ = ["Node", "MLP"]

simplegrad-0.0.2/py-simplegrad/simplegrad-dev/simplegrad.pyi

@@ -0,0 +1,262 @@
+from typing import List, Union
+
+class Node:
+    def __init__(self, value: float) -> None:
+        """
+        Initializes a new node with the given value.
+
+        Parameters:
+            value (float): The numeric value to store in the node.
+        """
+        ...
+
+    def data(self) -> float:
+        """
+        Retrieves the data stored in the node.
+
+        Returns:
+            float: The data value of the node.
+        """
+        ...
+
+    def grad(self) -> float:
+        """
+        Retrieves the gradient associated with the node.
+
+        Returns:
+            float: The gradient value of the node.
+        """
+        ...
+
+    def backward(self) -> None:
+        """
+        Performs backpropagation to compute gradients of all nodes in the computational graph.
+        """
+        ...
+
+    def relu(self) -> "Node":
+        """
+        Applies the ReLU activation function to the node.
+
+        Returns:
+            Node: A new node after applying the ReLU function.
+        """
+        ...
+
+    def __add__(self, other: Union["Node", float]) -> "Node":
+        """
+        Adds this node with another node or scalar.
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to add.
+
+        Returns:
+            Node: The result of the addition.
+        """
+        ...
+
+    def __radd__(self, other: Union["Node", float]) -> "Node":
+        """
+        Adds another node or scalar to this node (reversed operands).
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to add.
+
+        Returns:
+            Node: The result of the addition.
+        """
+        ...
+
+    def __mul__(self, other: Union["Node", float]) -> "Node":
+        """
+        Multiplies this node with another node or scalar.
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to multiply.
+
+        Returns:
+            Node: The result of the multiplication.
+        """
+        ...
+
+    def __rmul__(self, other: Union["Node", float]) -> "Node":
+        """
+        Multiplies another node or scalar with this node (reversed operands).
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to multiply.
+
+        Returns:
+            Node: The result of the multiplication.
+        """
+        ...
+
+    def __sub__(self, other: Union["Node", float]) -> "Node":
+        """
+        Subtracts another node or scalar from this node.
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to subtract.
+
+        Returns:
+            Node: The result of the subtraction.
+        """
+        ...
+
+    def __rsub__(self, other: Union["Node", float]) -> "Node":
+        """
+        Subtracts this node from another node or scalar (reversed operands).
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to subtract from.
+
+        Returns:
+            Node: The result of the subtraction.
+        """
+        ...
+
+    def __truediv__(self, other: Union["Node", float]) -> "Node":
+        """
+        Divides this node by another node or scalar.
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to divide by.
+
+        Returns:
+            Node: The result of the division.
+        """
+        ...
+
+    def __rtruediv__(self, other: Union["Node", float]) -> "Node":
+        """
+        Divides another node or scalar by this node (reversed operands).
+
+        Parameters:
+            other (Union[Node, float]): The node or scalar to divide.
+
+        Returns:
+            Node: The result of the division.
+        """
+        ...
+
+class Module:
+    def zero_grad(self) -> None:
+        """
+        Resets the gradients of all parameters to zero.
+        """
+        ...
+
+    def parameters(self) -> List[Node]:
+        """
+        Retrieves all parameter nodes within the module.
+
+        Returns:
+            List[Node]: A list of parameter nodes.
+        """
+        ...
+
+class Neuron(Module):
+    def __init__(self, nin: int, nonlin: bool = True) -> None:
+        """
+        Initializes a neuron with a specified number of inputs.
+
+        Parameters:
+            nin (int): Number of input features.
+            nonlin (bool): If True, applies a non-linear activation function (ReLU).
+        """
+        ...
+
+    def __call__(self, x: List[Node]) -> Node:
+        """
+        Performs the forward pass of the neuron.
+
+        Parameters:
+            x (List[Node]): A list of input nodes.
+
+        Returns:
+            Node: The output node after applying weights, bias, and activation.
+        """
+        ...
+
+    def parameters(self) -> List[Node]:
+        """
+        Retrieves the parameters (weights and bias) of the neuron.
+
+        Returns:
+            List[Node]: A list containing the weight nodes and bias node.
+        """
+        ...
+
+class Layer(Module):
+    def __init__(self, nin: int, nout: int) -> None:
+        """
+        Initializes a layer composed of multiple neurons.
+
+        Parameters:
+            nin (int): Number of input features.
+            nout (int): Number of neurons in the layer.
+        """
+        ...
+
+    def __call__(self, x: List[Node]) -> List[Node]:
+        """
+        Performs the forward pass of the layer.
+
+        Parameters:
+            x (List[Node]): A list of input nodes.
+
+        Returns:
+            List[Node]: A list of output nodes from each neuron in the layer.
+        """
+        ...
+
+    def parameters(self) -> List[Node]:
+        """
+        Retrieves the parameters from all neurons in the layer.
+
+        Returns:
+            List[Node]: A list of parameter nodes from all neurons.
+        """
+        ...
+
+class MLP(Module):
+    def __init__(self, nin: int, nouts: List[int]) -> None:
+        """
+        Initializes a Multi-Layer Perceptron (MLP) model.
+
+        Parameters:
+            nin (int): Number of input features.
+            nouts (List[int]): A list specifying the number of neurons in each layer.
+        """
+        ...
+
+    def __call__(self, x: Union[List[Node], List[float]]) -> List[Node]:
+        """
+        Performs the forward pass of the MLP.
+
+        Parameters:
+            x (Union[List[Node], List[float]]): Input data as a list of nodes or raw values.
+
+        Returns:
+            List[Node]: Output nodes after passing through the network.
+        """
+        ...
+
+    def parameters(self) -> List[Node]:
+        """
+        Retrieves the parameters from all layers of the MLP.
+
+        Returns:
+            List[Node]: A list of parameter nodes from all layers.
+        """
+        ...
+
+    def step(self, lr: float) -> None:
+        """
+        Updates the parameters using gradient descent.
+
+        Parameters:
+            lr (float): The learning rate for parameter updates.
+        """
+        ...
+

simplegrad-0.0.2/setup.cfg

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

simplegrad-0.0.2/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup
+
+
+setup(
+    name="simplegrad",
+    version="0.0.2",
+    description="Automatic differentiation library for basic arithmetic operations",
+    author="Deniz",
+    url="https://github.com/deniztemur00/simplegrad.git",
+    long_description=open("MANIFEST.md").read(),
+    long_description_content_type="text/markdown",
+    package_dir={"simplegrad": "py-simplegrad/simplegrad-dev"},
+    packages=["simplegrad"],
+    package_data={
+        "simplegrad": ["*.pyi", "py.typed", "*.so", "__init__.py"],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",  # Fixed classifier syntax
+        "Operating System :: POSIX :: Linux", 
+    ],
+    license="MIT",
+    author_email="deniztemur00@gmail.com",
+    python_requires=">=3.6",
+    options={"bdist_wheel": {"universal": True}},
+)

simplegrad-0.0.2/simplegrad.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: simplegrad
+Version: 0.0.2
+Summary: Automatic differentiation library for basic arithmetic operations
+Home-page: https://github.com/deniztemur00/simplegrad.git
+Author: Deniz
+Author-email: deniztemur00@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# SimpleGrad
+
+SimpleGrad is a lightweight automatic differentiation library written in C++ with Python bindings.
+
+### Compatible Operating Systems:
+- Linux (x86_64 architecture only)
+
+## Installation
+```bash
+pip install simplegrad
+```
+
+## Features
+
+- Multi-layer perceptron (MLP) which can be used for regression and classification tasks
+- Supports basic arithmetic operations
+- Lightweight and easy to use
+- Gradient computation
+- Backpropagation
+- Numpy compatibility
+
+
+## Usage
+
+Here's a quick example of how to use MLP in SimpleGrad:
+
+```python
+from simplegrad import MLP, Node
+from sklearn import datasets
+
+# Define the model
+X, y = datasets.make_classification(
+        n_samples=1000,
+        n_features=10,
+        n_classes=2,
+        random_state=42,  # for reproducibility
+    )
+lr = 0.01
+batch_size = 16
+epochs = 10
+
+# Define the model
+model = MLP(
+    10, [16, 1]
+)  # 2 input nodes, 2 hidden layers with arbitrary sizes, 1 output node
+
+# Training data
+n_batches = (len(X) + batch_size - 1) // batch_size  # Ceiling division
+
+for epoch in range(epochs):
+    epoch_loss = 0.0
+    for i in range(0, len(X), batch_size):
+        batch_X = X[i : i + batch_size]
+        batch_y = y[i : i + batch_size]
+        current_batch_size = len(batch_X)  # Handle last batch
+
+        batch_loss = 0.0
+        #model.zero_grad()  # gradients are automatically reset after step function
+
+        # Accumulate gradients over batch
+        for x, y_true in zip(batch_X, batch_y):
+            y_hat = model(x)[0]
+            y_true = Node(y_true)
+            loss = (y_hat - y_true) ** 2
+            loss = loss * (1.0 / current_batch_size)  # Normalize loss
+            batch_loss += loss.data()
+            loss.backward()
+
+        model.step(lr)  # Update weights using accumulated gradients
+        del loss, y_hat, y_true  # Clean up
+        epoch_loss += batch_loss
+
+    # Average loss over all batches
+    print(f"Epoch {epoch+1}, Average Loss: {epoch_loss/n_batches:.3f}")
+```
+
+
+

simplegrad-0.0.2/simplegrad.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+MANIFEST.in
+MANIFEST.md
+README.md
+setup.py
+py-simplegrad/simplegrad-dev/__init__.py
+py-simplegrad/simplegrad-dev/py.typed
+py-simplegrad/simplegrad-dev/simplegrad.cpython-312-x86_64-linux-gnu.so
+py-simplegrad/simplegrad-dev/simplegrad.pyi
+simplegrad.egg-info/PKG-INFO
+simplegrad.egg-info/SOURCES.txt
+simplegrad.egg-info/dependency_links.txt
+simplegrad.egg-info/top_level.txt

simplegrad-0.0.2/simplegrad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simplegrad-0.0.2/simplegrad.egg-info/top_level.txt

@@ -0,0 +1 @@
+simplegrad