neuralfabric 0.1.0.dev2__tar.gz → 0.1.0.dev3__tar.gz

{neuralfabric-0.1.0.dev2/src/neuralfabric.egg-info → neuralfabric-0.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralfabric
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: A from-scratch machine learning and deep learning framework, from linear regression to transformers.
 Author-email: Aryan Patel <aryanpatel2906.ap@gmail.com>
 License: MIT License
@@ -61,12 +61,12 @@ Dynamic: license-file
 
 # NeuralFabric
 
-A from-scratch machine learning and deep learning framework, from linear regression to transformers.
+A from-scratch machine learning and deep learning framework, from tensors to transformers.
 
 ## Installation
 
 ```bash
-pip install neuralfabric
+pip install -U neuralfabric
 # or, for local development:
 pip install -e ".[dev]"
 ```

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/README.md

@@ -1,11 +1,11 @@
 # NeuralFabric
 
-A from-scratch machine learning and deep learning framework, from linear regression to transformers.
+A from-scratch machine learning and deep learning framework, from tensors to transformers.
 
 ## Installation
 
 ```bash
-pip install neuralfabric
+pip install -U neuralfabric
 # or, for local development:
 pip install -e ".[dev]"
 ```

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuralfabric"
-version = "0.1.0.dev2"
+version = "0.1.0.dev3"
 description = "A from-scratch machine learning and deep learning framework, from linear regression to transformers."
 readme = "README.md"
 requires-python = ">=3.9"

neuralfabric-0.1.0.dev3/src/neuralfabric/base.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Any, Self
+
+
+class BaseEstimator:
+    def get_params(self) -> dict[str, Any]:
+        return {
+            key: value for key, value in self.__dict__.items() if not key.endswith("_")
+        }
+
+    def set_params(self, **params: Any) -> Self:
+        for key, value in params.items():
+            setattr(self, key, value)
+
+        return self
+
+
+class RegressorMixin:
+    @abstractmethod
+    def predict(self, X):
+        raise NotImplementedError
+
+    def score(self, X, y) -> float:
+        from neuralfabric.metrics.regression import r2_score
+
+        return r2_score(
+            y,
+            self.predict(X),
+        )
+
+
+class ClassifierMixin:
+    @abstractmethod
+    def predict(self, X):
+        raise NotImplementedError
+
+    def score(self, X, y) -> float:
+        from neuralfabric.metrics.classification import accuracy_score
+
+        return accuracy_score(
+            y,
+            self.predict(X),
+        )
+
+
+class TransformerMixin:
+    @abstractmethod
+    def fit(self, X, y=None):
+        raise NotImplementedError
+
+    @abstractmethod
+    def transform(self, X):
+        raise NotImplementedError
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y).transform(X)

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/src/neuralfabric/config.py

@@ -10,4 +10,5 @@ def set_seed(seed: int) -> None:
     global RANDOM_SEED
     RANDOM_SEED = seed
     import numpy as np
+
     np.random.seed(seed)

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/src/neuralfabric/core/tensor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import numpy as np
 
+
 class Tensor:
     __slots__ = ("data", "grad", "requires_grad", "_prev", "_op", "_backward")
 
@@ -229,6 +230,29 @@ class Tensor:
         out._backward = _backward
         return out
 
+    def clip(
+        self,
+        min_value: float,
+        max_value: float,
+    ) -> Tensor:
+        out = Tensor(
+            np.clip(self.data, min_value, max_value),
+            requires_grad=self.requires_grad,
+            _children=(self,),
+            _op="clip",
+        )
+
+        def _backward() -> None:
+            if self.requires_grad:
+                mask = ((self.data >= min_value) & (self.data <= max_value)).astype(
+                    self.data.dtype
+                )
+
+                self._accumulate(out.grad * mask)
+
+        out._backward = _backward
+        return out
+
     def relu(self):
         out = Tensor(
             np.maximum(self.data, 0),

neuralfabric-0.1.0.dev3/src/neuralfabric/linear_model/__init__.py

@@ -0,0 +1,7 @@
+from .linear_regression import LinearRegression
+from .logistic_regression import LogisticRegression
+
+__all__ = [
+    "LinearRegression",
+    "LogisticRegression",
+]

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/src/neuralfabric/linear_model/linear_regression.py

@@ -1,11 +1,17 @@
 from __future__ import annotations
 
+from typing import Self
+
+from neuralfabric.base import BaseEstimator, RegressorMixin
 from neuralfabric.core.tensor import Tensor
 
 
-class LinearRegression:
+class LinearRegression(
+    BaseEstimator,
+    RegressorMixin,
+):
     """
-    Ordinary Least Squares Linear Regression
+    Ordinary Least Squares (OLS) Linear Regression
     optimized using Gradient Descent.
     """
 
@@ -24,16 +30,16 @@ class LinearRegression:
         self,
         X: Tensor,
         y: Tensor,
-    ) -> "LinearRegression":
+    ) -> Self:
         n_features = X.shape[1]
 
         self.weight = Tensor(
-            [[0.0]] * n_features,
+            [[0.0] for _ in range(n_features)],
             requires_grad=True,
         )
 
         self.bias = Tensor(
-            [0.0],
+            0.0,
             requires_grad=True,
         )
 
@@ -47,50 +53,34 @@ class LinearRegression:
 
             loss.backward()
 
-            self.weight.data -= (
-                self.lr * self.weight.grad
-            )
-
-            self.bias.data -= (
-                self.lr * self.bias.grad
-            )
+            weight_grad = self.weight.grad
+            bias_grad = self.bias.grad
 
-        return self
+            assert weight_grad is not None
+            assert bias_grad is not None
 
-    def predict(self, X: Tensor) -> Tensor:
-        if self.weight is None or self.bias is None:
-            raise RuntimeError(
-                "LinearRegression must be fitted before prediction."
-            )
+            self.weight.data -= self.lr * weight_grad
+            self.bias.data -= self.lr * bias_grad
 
-        return X @ self.weight + self.bias
+        return self
 
-    def score(
+    def predict(
         self,
         X: Tensor,
-        y: Tensor,
-    ) -> float:
-        predictions = self.predict(X)
-
-        ss_res = ((y - predictions) ** 2).sum().item()
-
-        ss_tot = (
-            ((y - y.mean()) ** 2)
-            .sum()
-            .item()
-        )
+    ) -> Tensor:
+        if self.weight is None or self.bias is None:
+            raise RuntimeError("LinearRegression must be fitted before prediction.")
 
-        return 1.0 - (ss_res / ss_tot)
+        return X @ self.weight + self.bias
 
     def parameters(self) -> list[Tensor]:
         if self.weight is None or self.bias is None:
             return []
 
-        return [self.weight, self.bias]
+        return [
+            self.weight,
+            self.bias,
+        ]
 
     def __repr__(self) -> str:
-        return (
-            f"LinearRegression("
-            f"lr={self.lr}, "
-            f"epochs={self.epochs})"
-        )
+        return f"LinearRegression(" f"lr={self.lr}, " f"epochs={self.epochs})"

neuralfabric-0.1.0.dev3/src/neuralfabric/linear_model/logistic_regression.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Self
+
+from neuralfabric.base import BaseEstimator, ClassifierMixin
+from neuralfabric.core.tensor import Tensor
+
+
+class LogisticRegression(
+    BaseEstimator,
+    ClassifierMixin,
+):
+    """
+    Binary Logistic Regression
+    optimized using Gradient Descent.
+    """
+
+    def __init__(
+        self,
+        lr: float = 0.01,
+        epochs: int = 1000,
+    ) -> None:
+        self.lr = lr
+        self.epochs = epochs
+
+        self.weight: Tensor | None = None
+        self.bias: Tensor | None = None
+
+    def fit(
+        self,
+        X: Tensor,
+        y: Tensor,
+    ) -> Self:
+        n_features = X.shape[1]
+
+        self.weight = Tensor(
+            [[0.0] for _ in range(n_features)],
+            requires_grad=True,
+        )
+
+        self.bias = Tensor(
+            0.0,
+            requires_grad=True,
+        )
+
+        for _ in range(self.epochs):
+            logits = X @ self.weight + self.bias
+
+            predictions = logits.sigmoid().clip(
+                1e-7,
+                1 - 1e-7,
+            )
+
+            loss = -(y * predictions.log() + (1 - y) * (1 - predictions).log()).mean()
+
+            self.weight.zero_grad()
+            self.bias.zero_grad()
+
+            loss.backward()
+
+            weight_grad = self.weight.grad
+            bias_grad = self.bias.grad
+
+            assert weight_grad is not None
+            assert bias_grad is not None
+
+            self.weight.data -= self.lr * weight_grad
+            self.bias.data -= self.lr * bias_grad
+
+        return self
+
+    def predict_proba(
+        self,
+        X: Tensor,
+    ) -> Tensor:
+        if self.weight is None or self.bias is None:
+            raise RuntimeError("LogisticRegression must be fitted before prediction.")
+
+        logits = X @ self.weight + self.bias
+
+        return logits.sigmoid()
+
+    def predict(
+        self,
+        X: Tensor,
+        threshold: float = 0.5,
+    ) -> Tensor:
+        probabilities = self.predict_proba(X)
+
+        return Tensor((probabilities.data >= threshold).astype(float))
+
+    def parameters(self) -> list[Tensor]:
+        if self.weight is None or self.bias is None:
+            return []
+
+        return [
+            self.weight,
+            self.bias,
+        ]
+
+    def __repr__(self) -> str:
+        return f"LogisticRegression(" f"lr={self.lr}, " f"epochs={self.epochs})"

neuralfabric-0.1.0.dev3/src/neuralfabric/metrics/__init__.py

@@ -0,0 +1,7 @@
+from .classification import accuracy_score
+from .regression import r2_score
+
+__all__ = [
+    "accuracy_score",
+    "r2_score",
+]

neuralfabric-0.1.0.dev3/src/neuralfabric/metrics/classification.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from neuralfabric.core.tensor import Tensor
+
+
+def accuracy_score(
+    y_true: Tensor,
+    y_pred: Tensor,
+) -> float:
+    correct = (y_true.data == y_pred.data).sum()
+
+    return float(correct / y_true.data.shape[0])

neuralfabric-0.1.0.dev3/src/neuralfabric/metrics/regression.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from neuralfabric.core.tensor import Tensor
+
+
+def r2_score(
+    y_true: Tensor,
+    y_pred: Tensor,
+) -> float:
+    y_true_data = y_true.data
+    y_pred_data = y_pred.data
+
+    ss_res = ((y_true_data - y_pred_data) ** 2).sum()
+    ss_tot = ((y_true_data - y_true_data.mean()) ** 2).sum()
+
+    if ss_tot == 0:
+        return 0.0
+
+    return float(1.0 - (ss_res / ss_tot))

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/src/neuralfabric/model_selection/__init__.py

@@ -1,3 +1,3 @@
 from .train_test_split import train_test_split
 
-__all__ = ["train_test_split"]
+__all__ = ["train_test_split"]

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3}/src/neuralfabric/model_selection/train_test_split.py

@@ -12,15 +12,17 @@ def train_test_split(
     shuffle: bool = True,
     random_state: int | None = None,
 ) -> tuple[Tensor, Tensor, Tensor, Tensor]:
+    """
+    Split arrays or tensors into random train and test subsets.
+    """
+
     if not 0 < test_size < 1:
         raise ValueError("test_size must be between 0 and 1.")
 
     n_samples = X.shape[0]
 
     if y.shape[0] != n_samples:
-        raise ValueError(
-            "X and y must contain the same number of samples."
-        )
+        raise ValueError("X and y must contain the same number of samples.")
 
     indices = np.arange(n_samples)
 
@@ -39,4 +41,9 @@ def train_test_split(
     y_train = Tensor(y.data[train_idx])
     y_test = Tensor(y.data[test_idx])
 
-    return X_train, X_test, y_train, y_test
+    return (
+        X_train,
+        X_test,
+        y_train,
+        y_test,
+    )

{neuralfabric-0.1.0.dev2 → neuralfabric-0.1.0.dev3/src/neuralfabric.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralfabric
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: A from-scratch machine learning and deep learning framework, from linear regression to transformers.
 Author-email: Aryan Patel <aryanpatel2906.ap@gmail.com>
 License: MIT License
@@ -61,12 +61,12 @@ Dynamic: license-file
 
 # NeuralFabric
 
-A from-scratch machine learning and deep learning framework, from linear regression to transformers.
+A from-scratch machine learning and deep learning framework, from tensors to transformers.
 
 ## Installation
 
 ```bash
-pip install neuralfabric
+pip install -U neuralfabric
 # or, for local development:
 pip install -e ".[dev]"
 ```

neuralfabric-0.1.0.dev2/src/neuralfabric/base.py

@@ -1,43 +0,0 @@
-"""BaseEstimator and Mixins (RegressorMixin, ClassifierMixin, TransformerMixin)
-shared by every classical estimator in LevelGraphs.
-"""
-
-
-class BaseEstimator:
-    """Base class for all estimators.
-
-    Provides ``get_params`` / ``set_params`` (sklearn-style) so every model
-    is introspectable and plugs into model_selection utilities (e.g. grid
-    search) without extra boilerplate.
-    """
-
-    def get_params(self) -> dict:
-        return {k: v for k, v in self.__dict__.items() if not k.endswith("_")}
-
-    def set_params(self, **params):
-        for key, value in params.items():
-            setattr(self, key, value)
-        return self
-
-
-class RegressorMixin:
-    """Marks an estimator as a regressor; adds a default R^2 `score`."""
-
-    def score(self, X, y):
-        from .metrics.regression import r2_score
-        return r2_score(y, self.predict(X))
-
-
-class ClassifierMixin:
-    """Marks an estimator as a classifier; adds a default accuracy `score`."""
-
-    def score(self, X, y):
-        from .metrics.classification import accuracy_score
-        return accuracy_score(y, self.predict(X))
-
-
-class TransformerMixin:
-    """Adds `fit_transform` for free, given `fit` and `transform`."""
-
-    def fit_transform(self, X, y=None):
-        return self.fit(X, y).transform(X)

neuralfabric-0.1.0.dev2/src/neuralfabric/exceptions.py

@@ -1,13 +0,0 @@
-"""Library-specific exception types."""
-
-
-class LevelGraphsError(Exception):
-    """Base class for all NeuralFabric exceptions."""
-
-
-class NotFittedError(LevelGraphsError):
-    """Raised when a method needs a fitted estimator that hasn't been fit yet."""
-
-
-class ShapeMismatchError(LevelGraphsError):
-    """Raised when input shapes are incompatible with the requested operation."""

neuralfabric-0.1.0.dev2/src/neuralfabric/linear_model/__init__.py

@@ -1,3 +0,0 @@
-from .linear_regression import LinearRegression
-
-__all__ = ["LinearRegression"]

neuralfabric-0.1.0.dev2/src/neuralfabric/linear_model/logistic_regression.py

@@ -1 +0,0 @@
-"""Binary/multiclass logistic regression classifier. TODO: implement."""

neuralfabric-0.1.0.dev2/src/neuralfabric/metrics/__init__.py

@@ -1 +0,0 @@
-"""Evaluation metrics for regression, classification, and clustering."""

neuralfabric-0.1.0.dev2/src/neuralfabric/metrics/classification.py

@@ -1 +0,0 @@
-"""Accuracy, precision, recall, F1, ROC-AUC, confusion matrix. TODO: implement."""

neuralfabric-0.1.0.dev2/src/neuralfabric/metrics/regression.py

@@ -1 +0,0 @@
-"""MSE, RMSE, MAE, R^2 and other regression metrics. TODO: implement."""