gradforge 2.0.1__tar.gz

gradforge-2.0.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: gradforge
+Version: 2.0.1
+Summary: Machinelearning library
+Author-email: insane-machines <forshnikita2@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nikitaforsh/gradforge
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pytest>=9.1.1
+Provides-Extra: cuda
+Requires-Dist: cupy; extra == "cuda"
+
+<h1 align="center">
+  <img src="https://github.com/insane-machines/fsh/blob/main/fsh/fsh.egg-info/logo.jpg"></img>
+</h1>
+<h1 align="center">
+  <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&pause=1000&color=00FFAA&center=true&vCenter=true&width=500&lines=Hi,+I'm+nikitaforsh!;Welcome+to++our+machinelearning+library;named+GradForge!" alt="Typing SVG" />
+</h1>
+
+<p align="center">
+  <a href="https://t.me/insane_machines" target="_blank">
+    <img src="https://img.shields.io/badge/Insane%20Machines-Telegram-blue?style=for-the-badge&logo=telegram" alt="Telegram link" />
+  </a>
+</p>
+Features
+
+Linear model with: 
+• **Callbacks**
+• **Metrics** 
+• **Preprocessing functions**
+• **Simple integration**  
+
+---
+
+Quick Start
+
+```python
+import fsh
+
+X = [[1, 2], [3, 4]]
+y = [[5], [6]]
+
+#array converting is integrated! but you can do it yourself!
+X = fsh.fsh.preprocessing.to_array(X)
+y = fsh.fsh.preprocessing.to_array(y)
+
+callback = fsh.fsh.callbacks.History()
+model = fsh.fsh.Linear(n_features=2, lr=0.01)
+
+# Training
+model.train(X, y, epochs=100, callbacks=[callback], loss_fn=fsh.fsh.metrics.mse)
+model.predict(X)

gradforge-2.0.1/README.md

@@ -0,0 +1,40 @@
+<h1 align="center">
+  <img src="https://github.com/insane-machines/fsh/blob/main/fsh/fsh.egg-info/logo.jpg"></img>
+</h1>
+<h1 align="center">
+  <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&pause=1000&color=00FFAA&center=true&vCenter=true&width=500&lines=Hi,+I'm+nikitaforsh!;Welcome+to++our+machinelearning+library;named+GradForge!" alt="Typing SVG" />
+</h1>
+
+<p align="center">
+  <a href="https://t.me/insane_machines" target="_blank">
+    <img src="https://img.shields.io/badge/Insane%20Machines-Telegram-blue?style=for-the-badge&logo=telegram" alt="Telegram link" />
+  </a>
+</p>
+Features
+
+Linear model with: 
+• **Callbacks**
+• **Metrics** 
+• **Preprocessing functions**
+• **Simple integration**  
+
+---
+
+Quick Start
+
+```python
+import fsh
+
+X = [[1, 2], [3, 4]]
+y = [[5], [6]]
+
+#array converting is integrated! but you can do it yourself!
+X = fsh.fsh.preprocessing.to_array(X)
+y = fsh.fsh.preprocessing.to_array(y)
+
+callback = fsh.fsh.callbacks.History()
+model = fsh.fsh.Linear(n_features=2, lr=0.01)
+
+# Training
+model.train(X, y, epochs=100, callbacks=[callback], loss_fn=fsh.fsh.metrics.mse)
+model.predict(X)

gradforge-2.0.1/gradforge/_exceptions/__init__.py

@@ -0,0 +1,4 @@
+from _errors import DataError, MatchError, ProcessError
+__all__ = ["DataError", "MatchError", "ProcessError"]
+
+

gradforge-2.0.1/gradforge/_exceptions/_errors.py

@@ -0,0 +1,6 @@
+class DataError(Exception):
+    pass
+class MatchError(Exception):
+    pass
+class ProcessError(Exception):
+    pass

gradforge-2.0.1/gradforge/_tests/profiling_stats.py

@@ -0,0 +1,6 @@
+import pstats
+
+stats = pstats.Stats("profile.prof")
+
+stats.sort_stats("cumtime")
+stats.print_stats(30)

gradforge-2.0.1/gradforge/_tests/test_linear.py

@@ -0,0 +1,47 @@
+from gradforge.core.tensor import Tensor
+from gradforge.optimizers.sgd import SGD
+from gradforge.autograd.standard_engine import StandardEngine
+from gradforge.backend.backend_manager import BackendManager
+from gradforge.training.layers.linear import Linear
+import tracemalloc
+
+#tracemalloc.start()
+    
+def train(model, x, y, epochs):
+    engine = StandardEngine()
+    optimizer = SGD(learning_rate=1e-3)
+    for epoch in range(epochs):
+        y_pred  = model.predict(x)
+        error   = y - y_pred
+        loss    = error ** 2
+
+        optimizer.zero_grad(model.params)
+        engine.backward(loss)
+        print('eror grad: ', error.grad)
+        try:
+            optimizer.step(model.params)
+        except Exception as e:
+            print('Error: ', e)
+
+    print(x.data @ model.w.data)
+
+x       = Tensor([[4], [8], [9]])
+y       = Tensor([[8], [16], [18]])
+test    = Tensor([[40], [60]])
+assert x.data.shape == y.data.shape
+
+#before = tracemalloc.take_snapshot()
+
+model = Linear(1, 1)
+train(model, x, y, epochs=10000)
+# after = tracemalloc.take_snapshot()
+
+print(test.data @ model.w.data)
+# print(model.w.data.shape)
+
+# stats = after.compare_to(before, "lineno")
+# for result in stats[:50]:
+#     print(result)
+
+# 0.757 seconds
+# Backend allocations needs to optimize

gradforge-2.0.1/gradforge/_tests/test_operation.py

@@ -0,0 +1,11 @@
+import timeit
+
+setup = "from gradforge.core.tensor import Tensor; a = Tensor([5]); b = Tensor([6])"
+
+result = timeit.repeat("c = a + b", setup=setup, number=100000, repeat=10)
+
+best_time = min(result)         
+time_per_op = best_time / 100_000
+print(time_per_op * 1000000)
+
+#0.8082507399922179

gradforge-2.0.1/gradforge/autograd/__init__.py

@@ -0,0 +1,2 @@
+from .operation import Operation
+__all__ = ["Operation"]

gradforge-2.0.1/gradforge/autograd/_operations/add.py

@@ -0,0 +1,20 @@
+from ...autograd.operation import Operation
+
+class Add(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+
+    def forward(self, a, b):
+        
+        result = self._backend.add(a, b)
+        
+        return result 
+
+    
+    def backward(self, result_grad) -> tuple:
+
+        a_grad = result_grad
+        b_grad = result_grad
+
+        return (a_grad, b_grad)
+        

gradforge-2.0.1/gradforge/autograd/_operations/div.py

@@ -0,0 +1,23 @@
+from ...autograd.operation import Operation
+
+class Div(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+        self.parent_data = (0, 0)
+
+    def forward(self, a, b):
+        
+        result = self._backend.div(a, b)
+        self.parent_data = (a, b)
+
+        return result 
+
+    
+    def backward(self, result_grad) -> tuple:
+        a_data, b_data = self.parent_data
+
+        a_grad = result_grad / b_data if b_data != 0 else 0 
+        b_grad = (- a_data / b_data ^ 2) * result_grad if b_data != 0 else 0 
+
+        return (a_grad, b_grad)
+        

gradforge-2.0.1/gradforge/autograd/_operations/matmul.py

@@ -0,0 +1,22 @@
+from ...autograd.operation import Operation
+class Matmul(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+        self.parent_data = (0, 0)
+
+    def forward(self, a, b):
+
+        self.parent_data = (a, b)
+        result = self._backend.matmul(a, b)
+    
+        return result 
+
+    
+    def backward(self, result_grad) -> tuple:
+
+        a_data, b_data = self.parent_data
+        
+        a_grad = result_grad @ self._backend.transpose(b_data) 
+        b_grad = self._backend.transpose(a_data) @ result_grad 
+
+        return (a_grad, b_grad)

gradforge-2.0.1/gradforge/autograd/_operations/mul.py

@@ -0,0 +1,25 @@
+from ...autograd.operation import Operation
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ...core.tensor import Tensor
+class Mul(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+        self.parent_data = (0, 0)
+
+    def forward(self, a, b):
+
+        self.parent_data = (a, b)
+        result = self._backend.mul(a, b)
+
+        return result 
+
+    
+    def backward(self, result_grad) -> tuple:
+        a_data, b_data = self.parent_data
+
+        a_grad = b_data * result_grad
+        b_grad = a_data * result_grad
+
+        return (a_grad, b_grad)
+        

gradforge-2.0.1/gradforge/autograd/_operations/pow.py

@@ -0,0 +1,26 @@
+from ...autograd.operation import Operation
+class Pow(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+        self.n = 0
+        self.parent_data = 0
+
+    def forward(self, x, n):
+
+        self.parent_data = x
+        self.n = n
+
+        result = x ** n
+
+        return result 
+
+    
+    def backward(self, result_grad) -> list:
+        x_data = self.parent_data
+        n = self.n
+        
+        x_grad = result_grad * n * x_data**(n - 1)
+
+        return [x_grad]
+
+        

gradforge-2.0.1/gradforge/autograd/_operations/sub.py

@@ -0,0 +1,19 @@
+from ...autograd.operation import Operation
+class Sub(Operation):
+    def __init__(self, backend) -> None:
+        super().__init__(backend)
+
+    def forward(self, a, b):
+        
+        result = self._backend.sub(a.data, b.data)
+
+        return result 
+
+    
+    def backward(self, result_grad) -> tuple:
+
+        a_grad = result_grad
+        b_grad = -result_grad
+
+        return (a_grad, b_grad)
+        

gradforge-2.0.1/gradforge/autograd/engine.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from ..backend.backend_manager import BackendManager
+
+class Engine(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+        self._backend = BackendManager.get_backend()
+
+    @abstractmethod
+    def _prepare_root_grad():
+        pass
+
+    @abstractmethod
+    def _tensor_backward():
+        pass
+    
+    @abstractmethod
+    def _start_backward_recursion():
+        pass
+
+    @abstractmethod
+    def backward():
+        pass

gradforge-2.0.1/gradforge/autograd/operation.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from ..backend.backend import Backend
+class Operation(ABC):
+    def __init__(self, backend: Backend) -> None:
+        super().__init__()
+        self._backend: Backend = backend
+
+    @abstractmethod
+    def forward(self, a, b):
+        pass 
+
+    @abstractmethod
+    def backward(self, result_grad) -> tuple:
+        pass 

gradforge-2.0.1/gradforge/autograd/standard_engine.py

@@ -0,0 +1,35 @@
+from .engine import Engine
+from ..core.tensor import Tensor
+
+class StandardEngine(Engine):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def _prepare_root_grad(self, tensor: Tensor):
+        root_grad = self._backend.ones_like(tensor.data)
+        return root_grad
+
+    def _tensor_backward(self, tensor: Tensor, grad):
+        if tensor.grad_fn is None:
+            return ()
+        
+        parents = tensor.grad_fn[0]
+        grads = tensor.grad_fn[1].backward(grad)
+
+
+        return zip(parents, grads)
+        
+    def _start_backward_recursion(self, tensor_backward):
+        for parent, parent_grad in tensor_backward:
+            if parent.requires_grad:
+                parent.grad += parent_grad
+
+            if parent.grad_fn is not None:  
+                self.backward(parent, parent.grad)
+
+    def backward(self, tensor: Tensor, grad=None):
+        if grad is None:
+            grad = self._prepare_root_grad(tensor)
+
+        tensor_backward = self._tensor_backward(tensor, grad)
+        self._start_backward_recursion(tensor_backward)

gradforge-2.0.1/gradforge/backend/__init__.py

@@ -0,0 +1,5 @@
+from .backend_manager import BackendManager
+from .backend import Backend
+from .numpy_backend import numpy_backend
+
+__all__ = ["BackendManager", "Backend", "numpy_backend"]

gradforge-2.0.1/gradforge/backend/backend.py

@@ -0,0 +1,85 @@
+from abc import ABC, abstractmethod
+class Backend(ABC):
+
+    @abstractmethod
+    def convert(self, data):
+        return data
+
+    #Binary operations
+    @abstractmethod
+    def add(self, a, b):
+        pass
+
+    @abstractmethod
+    def div(self, a, b):
+        pass
+
+    @abstractmethod
+    def mul(self, a, b):
+        pass
+
+    @abstractmethod
+    def sub(self, a, b):
+        pass
+
+    #Matrix operations
+    @abstractmethod
+    def matmul(self, a, b):
+        pass
+
+    @abstractmethod
+    def transpose(self, matrix):
+        return matrix
+
+    #Unary operations
+    @abstractmethod
+    def relu(self, x):
+        return x
+
+    @abstractmethod
+    def sigmoid(self, x):
+        return x
+
+    @abstractmethod
+    def tanh(self, x):
+        return x
+
+    @abstractmethod
+    def softmax(self, x):
+        return x
+
+    @abstractmethod
+    def mean(self, array):
+        return array
+
+    @abstractmethod
+    def std(self, array):
+        return array
+
+    @abstractmethod
+    def abs(self, array):
+        return array
+
+    @abstractmethod
+    def zeros_like(self, array):
+        return array
+
+    @abstractmethod
+    def ones_like(self, array):
+        return array
+
+    @abstractmethod
+    def array_zeros(self, shape):
+        return shape
+
+    @abstractmethod
+    def array_ones(self, shape):
+        return shape
+
+    @abstractmethod
+    def is_native(self, data) -> bool:
+        pass
+
+
+
+    

gradforge-2.0.1/gradforge/backend/backend_manager.py

@@ -0,0 +1,13 @@
+from .backend import Backend
+from .numpy_backend.numpy_backend import NumpyBackend
+class BackendManager():
+    _backend: Backend = NumpyBackend()
+
+    @staticmethod
+    def set_backend(backend_adapter: Backend):
+        BackendManager._backend = backend_adapter
+
+    @staticmethod
+    def get_backend() -> Backend:
+        return BackendManager._backend
+        

gradforge-2.0.1/gradforge/backend/cupy_backend/cuda_backend.py

@@ -0,0 +1,4 @@
+from backend import Backend
+
+class CupyBackend(Backend):
+    pass

gradforge-2.0.1/gradforge/backend/numpy_backend/numpy_backend.py

@@ -0,0 +1,72 @@
+from ..backend import Backend
+import numpy as np
+
+class NumpyBackend(Backend):
+
+    def convert(self, data) -> np.ndarray:
+        if not self.is_native(data):
+            return np.array(data, dtype=np.float32)
+
+        return data
+
+    #Binary operations
+    def add(self, a, b):
+        return np.add(a, b)
+
+    def div(self, a, b):
+        return np.divide(a, b)
+
+    def mul(self, a, b):
+        return np.multiply(a, b)
+
+    def sub(self, a, b):
+        return np.subtract(a, b)
+
+    #Matrix operations
+    def matmul(self, a, b):
+        return np.matmul(a, b)
+
+    def transpose(self, matrix):
+        return matrix.T
+
+    #Unary operations
+    def relu(self, x):
+        return max(0, x)
+
+    def sigmoid(self, x):
+        pass
+
+    def tanh(self, x):
+        pass
+
+    def softmax(self, x):
+        pass
+
+    def mean(self, array):
+        return np.mean(array)
+
+    def std(self, array):
+        return np.std(array)
+
+    def abs(self, array):
+        return np.abs(array)
+
+    def zeros_like(self, array):
+        return np.zeros_like(array)
+
+    def ones_like(self, array):
+        return np.ones_like(array)
+
+    def array_zeros(self, shape):
+        return np.zeros(shape)
+
+    def array_ones(self, shape):
+        return np.ones(shape)
+
+    def is_native(self, data) -> bool:
+        if type(data) is np.ndarray:
+            return True
+        else: 
+            return False
+        
+    

gradforge-2.0.1/gradforge/core/tensor.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from ..backend.backend_manager import BackendManager
+from ..backend.backend import Backend
+from ..autograd._operations import mul, matmul, sub, div, add, pow
+from typing import Optional
+
+class Tensor():
+    __slots__ = ['data', 'requires_grad', 'grad', 'grad_fn', 'backend']
+    
+    def __init__(self, data, requires_grad: bool = False):
+        self.requires_grad: bool = requires_grad
+        self.grad = 0
+        self.grad_fn: Optional[list] = None
+        self.backend: Backend = BackendManager.get_backend()
+        self.data = self.backend.convert(data)
+
+    def __mul__(self, other): 
+        mul_op = mul.Mul(self.backend)
+        mul_forward = mul_op.forward(self.data, other.data)
+
+        result = Tensor(mul_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self, other], mul_op]
+
+        return result
+
+    def __matmul__(self, other: Tensor):
+        mat_mul_op = matmul.Matmul(self.backend)
+        mul_forward = mat_mul_op.forward(self.data, other.data)
+
+        result = Tensor(mul_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self, other], mat_mul_op]
+
+        return result
+
+    def __add__(self, other: Tensor):
+        add_op = add.Add(self.backend)
+        add_forward = add_op.forward(self.data, other.data)
+
+        result = Tensor(add_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self, other], add_op]
+
+        return result
+
+    def __sub__(self, other: Tensor):
+        sub_op = sub.Sub(self.backend)
+        sub_forward = sub_op.forward(self.data, other.data)
+
+        result = Tensor(sub_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self, other], sub_op]
+
+        return result
+
+    def __truediv__(self, other):
+        div_op = div.Div(self.backend)
+        div_forward = div_op.forward(self.data, other.data)
+
+        result = Tensor(div_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self, other], div_op]
+
+        return result
+
+    def __pow__(self, other):
+        pow_op = pow.Pow(self.backend)
+        pow_forward = pow_op.forward(self.data, other)
+
+        result = Tensor(pow_forward, requires_grad=self.requires_grad or other.requires_grad)
+        result.grad_fn = [[self], pow_op]
+
+        return result
+
+        

gradforge-2.0.1/gradforge/data/preprocessing/__init__.py

@@ -0,0 +1,2 @@
+from .preprocess import preprocessing
+__all__ = ["preprocessing"]

gradforge-2.0.1/gradforge/data/preprocessing/preprocess.py

@@ -0,0 +1,22 @@
+from ..._exceptions._errors import DataError
+from ...backend.backend_manager import BackendManager
+class preprocessing():
+
+    @staticmethod
+    def normalize(array, mean=None, std=None):
+        backend = BackendManager.get_backend()
+        if mean is not None and std is not None:
+            arr_mean = mean
+            arr_std = std
+        elif (mean is None and std is not None) or (mean is not None and std is None):
+            raise DataError('one of the normalize components is none, and another is not none')
+        else:
+            arr_mean    = backend.mean(array)
+            arr_std     = backend.std(array)
+        arr_norm    = (array-arr_mean)/arr_std
+        return arr_norm, arr_mean, arr_std
+    @staticmethod
+
+    def denormalize(normalized, mean, std):
+        array = normalized * std + mean
+        return array

gradforge-2.0.1/gradforge/metrics/__init__.py

@@ -0,0 +1,4 @@
+from .std_metrics import metrics
+__all__ = ["metrics"]
+
+

gradforge-2.0.1/gradforge/metrics/std_metrics.py

@@ -0,0 +1,34 @@
+from math import sqrt
+from ..backend.backend_manager import BackendManager
+class metrics():
+
+    @staticmethod
+    def mse(y, y_pred, training=False):
+        backend = BackendManager.get_backend()
+        y       = backend.convert(y)
+        y_pred  = backend.convert(y_pred)
+        
+        loss = backend.mean((y.flatten()-y_pred.flatten())**2)
+        if not training:
+            print(f'MSE: {loss}')
+        return loss
+
+    @staticmethod
+    def rmse(y, y_pred, training=False):
+        y       = BackendManager.get_backend().convert(y)
+        y_pred  = BackendManager.get_backend().convert(y_pred)
+
+        loss = sqrt(metrics.mse(y, y_pred, training=True))
+        if not training:
+            print(f'RMSE: {loss}')
+        return loss
+
+    @staticmethod
+    def mae(y, y_pred, training=False):
+        backend = BackendManager.get_backend()
+        mae = backend.mean(backend.abs(y - y_pred))
+
+        if not training:
+            print('MAE:', mae)
+
+        return mae

gradforge-2.0.1/gradforge/optimizers/optimizer.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+class Optimizer(ABC):
+    def __init__(self, learning_rate=1e-3) -> None:
+        super().__init__()
+        self.learning_rate = learning_rate
+            
+    @abstractmethod
+    def step():
+        pass
+
+    @abstractmethod
+    def zero_grad():
+        pass

gradforge-2.0.1/gradforge/optimizers/sgd.py

@@ -0,0 +1,13 @@
+from .optimizer import Optimizer
+from ..core.tensor import Tensor
+class SGD(Optimizer):
+    def __init__(self, learning_rate=0.001) -> None:
+        super().__init__(learning_rate)
+
+    def step(self, params: list[Tensor]):
+        for param in params:
+            param.data -= param.grad * self.learning_rate
+
+    def zero_grad(self, params: list[Tensor]):
+        for param in params:
+            param.grad = param.backend.zeros_like(param.data)   

gradforge-2.0.1/gradforge/training/callbacks/__init__.py

@@ -0,0 +1,2 @@
+from .std_callbacks import callbacks
+__all__ = ["callbacks"]

gradforge-2.0.1/gradforge/training/callbacks/std_callbacks.py

@@ -0,0 +1,38 @@
+class callbacks():
+    
+    class EarlyStop():
+        def __init__(self, patience=10, delta=1e-3):
+            self.best_loss = None
+            self.delta = delta
+            self.patience = patience
+            self.wait = 0
+        def __call__(self, model, log):
+            val_loss = log.get('val_loss')
+            if val_loss is None:
+                return
+
+            if self.best_loss is None:
+                self.best_loss = val_loss
+            
+            else:
+                if val_loss < self.best_loss - self.delta:
+                    self.best_loss = val_loss
+                    self.wait = 0
+                else:
+                    self.wait += 1
+
+            if self.wait >= self.patience:
+                model.stop_training = True
+            else:
+                model.stop_training = False
+
+    class History():
+        def __init__(self):
+            self.history = {'epoch': [], 'loss': [], 'val_loss': []}
+        def __call__(self, model, log):
+            epoch = log.get('epoch')
+            loss = log.get('loss')
+            val_loss = log.get('val_loss')
+            self.history['epoch'].append(epoch)
+            self.history['loss'].append(loss)
+            self.history['val_loss'].append(val_loss)

gradforge-2.0.1/gradforge/training/layers/layer.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+class Layer(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def predict():
+        pass
+
+    @abstractmethod
+    def params() -> list:
+        pass
+
+    

gradforge-2.0.1/gradforge/training/layers/linear.py

@@ -0,0 +1,17 @@
+from .layer import Layer
+from ...core.tensor import Tensor
+from ...backend.backend_manager import BackendManager
+class Linear(Layer):
+    def __init__(self, in_shape, out_shape) -> None:
+        super().__init__()      
+        self._backend = BackendManager.get_backend()
+        self.w: Tensor = Tensor(self._backend.array_zeros((in_shape, out_shape)), requires_grad=True)
+        
+    def predict(self, x: Tensor) -> Tensor:
+        return x @ self.w
+
+    @property
+    def params(self) -> list[Tensor]:
+        return [attr_val\
+                    for attr_val in self.__dict__.values()\
+                        if (type(attr_val) is Tensor and attr_val.requires_grad)]

gradforge-2.0.1/gradforge/training/models/sequential.py

@@ -0,0 +1,10 @@
+from ..layers.layer import Layer
+from ...core.tensor import Tensor
+class Sequential:
+    def __init__(self, *layers: list[Layer]):
+        self.layers: list[Layer] = layers
+    
+    @property
+    def params(self):
+        for layer in self.layers:
+            yield layer.params

gradforge-2.0.1/gradforge/training/trainer.py

@@ -0,0 +1,2 @@
+class Trainer:
+    pass

gradforge-2.0.1/gradforge.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: gradforge
+Version: 2.0.1
+Summary: Machinelearning library
+Author-email: insane-machines <forshnikita2@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nikitaforsh/gradforge
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pytest>=9.1.1
+Provides-Extra: cuda
+Requires-Dist: cupy; extra == "cuda"
+
+<h1 align="center">
+  <img src="https://github.com/insane-machines/fsh/blob/main/fsh/fsh.egg-info/logo.jpg"></img>
+</h1>
+<h1 align="center">
+  <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&pause=1000&color=00FFAA&center=true&vCenter=true&width=500&lines=Hi,+I'm+nikitaforsh!;Welcome+to++our+machinelearning+library;named+GradForge!" alt="Typing SVG" />
+</h1>
+
+<p align="center">
+  <a href="https://t.me/insane_machines" target="_blank">
+    <img src="https://img.shields.io/badge/Insane%20Machines-Telegram-blue?style=for-the-badge&logo=telegram" alt="Telegram link" />
+  </a>
+</p>
+Features
+
+Linear model with: 
+• **Callbacks**
+• **Metrics** 
+• **Preprocessing functions**
+• **Simple integration**  
+
+---
+
+Quick Start
+
+```python
+import fsh
+
+X = [[1, 2], [3, 4]]
+y = [[5], [6]]
+
+#array converting is integrated! but you can do it yourself!
+X = fsh.fsh.preprocessing.to_array(X)
+y = fsh.fsh.preprocessing.to_array(y)
+
+callback = fsh.fsh.callbacks.History()
+model = fsh.fsh.Linear(n_features=2, lr=0.01)
+
+# Training
+model.train(X, y, epochs=100, callbacks=[callback], loss_fn=fsh.fsh.metrics.mse)
+model.predict(X)

gradforge-2.0.1/gradforge.egg-info/SOURCES.txt

@@ -0,0 +1,45 @@
+README.md
+pyproject.toml
+gradforge.egg-info/PKG-INFO
+gradforge.egg-info/SOURCES.txt
+gradforge.egg-info/dependency_links.txt
+gradforge.egg-info/requires.txt
+gradforge.egg-info/top_level.txt
+gradforge/_exceptions/__init__.py
+gradforge/_exceptions/_errors.py
+gradforge/_tests/profiling_stats.py
+gradforge/_tests/test_linear.py
+gradforge/_tests/test_operation.py
+gradforge/autograd/__init__.py
+gradforge/autograd/engine.py
+gradforge/autograd/operation.py
+gradforge/autograd/standard_engine.py
+gradforge/autograd/_operations/add.py
+gradforge/autograd/_operations/div.py
+gradforge/autograd/_operations/matmul.py
+gradforge/autograd/_operations/mul.py
+gradforge/autograd/_operations/pow.py
+gradforge/autograd/_operations/sub.py
+gradforge/backend/__init__.py
+gradforge/backend/backend.py
+gradforge/backend/backend_manager.py
+gradforge/backend/cupy_backend/cuda_backend.py
+gradforge/backend/numpy_backend/numpy_backend.py
+gradforge/core/tensor.py
+gradforge/data/preprocessing/__init__.py
+gradforge/data/preprocessing/preprocess.py
+gradforge/metrics/__init__.py
+gradforge/metrics/std_metrics.py
+gradforge/optimizers/__init__.py
+gradforge/optimizers/adam.py
+gradforge/optimizers/optimizer.py
+gradforge/optimizers/sgd.py
+gradforge/training/__init__.py
+gradforge/training/trainer.py
+gradforge/training/callbacks/__init__.py
+gradforge/training/callbacks/std_callbacks.py
+gradforge/training/layers/__init__.py
+gradforge/training/layers/layer.py
+gradforge/training/layers/linear.py
+gradforge/training/models/model.py
+gradforge/training/models/sequential.py

gradforge-2.0.1/gradforge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gradforge-2.0.1/gradforge.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+pytest>=9.1.1
+
+[cuda]
+cupy

gradforge-2.0.1/gradforge.egg-info/top_level.txt

@@ -0,0 +1 @@
+gradforge

gradforge-2.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gradforge" 
+version = "2.0.1"
+description = "Machinelearning library"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "insane-machines", email = "forshnikita2@gmail.com"}]
+requires-python = ">=3.11"
+dependencies = [
+    "numpy",
+    "pytest>=9.1.1",
+] 
+
+[project.urls]
+Homepage = "https://github.com/nikitaforsh/gradforge"
+
+[project.optional-dependencies]
+cuda = [
+    "cupy"
+]
+
+[tool.setuptools.packages.find]
+include = ["gradforge*"]
+
+[dependency-groups]
+dev = [
+    "memray>=1.20.0",
+    "mypy>=2.3.0",
+    "pytest>=9.1.1",
+    "ruff>=0.15.22",
+]

gradforge-2.0.1/setup.cfg

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