gradforge 2.0.1__py3-none-any.whl

gradforge/_exceptions/__init__.py

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

gradforge/_exceptions/_errors.py

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

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/_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/_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/autograd/__init__.py

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

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/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/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/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/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/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/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/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/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/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/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/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/backend/cupy_backend/cuda_backend.py

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

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/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/data/preprocessing/__init__.py

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

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/metrics/__init__.py

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

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/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/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/training/callbacks/__init__.py

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

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/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/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/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/training/trainer.py

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

gradforge-2.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,42 @@
+gradforge/_exceptions/__init__.py,sha256=LtRrFhT5HtNY26bJ6nLUEehTv-OWoC4SiPxOQ3P18_s,116
+gradforge/_exceptions/_errors.py,sha256=KsMfZqaMmgk1lYLzhMOsRPvsxg0ol9iaH_Su1_6X4_M,121
+gradforge/_tests/profiling_stats.py,sha256=Xv1BDXfRDWnHh0cqIlJqXRV9UYoXImpetGIUvTq1em4,102
+gradforge/_tests/test_linear.py,sha256=Z3rMx4ba9XSbJxxbdJG3VDRPptTQtQNffEMJlXvw2LY,1276
+gradforge/_tests/test_operation.py,sha256=StwDlxEizx8FfX70kTo9eOnHbwG87ykMpwYsIDmOObY,294
+gradforge/autograd/__init__.py,sha256=F98aOrZZmLxzVZeR51XnIMGidAv72y-YT-5jXuldBQw,56
+gradforge/autograd/engine.py,sha256=3iFUx0FAe-ygV6NTh5eXWifPouiG6lGSwZ71Oe0KAPU,475
+gradforge/autograd/operation.py,sha256=nd2y9OofeLYlhA6_j11cLm8Va9vXY6UhegKZbPiFRNU,394
+gradforge/autograd/standard_engine.py,sha256=nFchbdkcSYkkEW0xzyVCsaVakBOLkiBbB7CxOolOcQE,1068
+gradforge/autograd/_operations/add.py,sha256=1bNpCs7aQSlAnDdj1-7VhkpFWRs4dtHrmt6x8lRTFs8,406
+gradforge/autograd/_operations/div.py,sha256=EZ2IkIKe6wv5GNSwkDSJx_oXtH-80qfgIfEX2Jj6NTs,589
+gradforge/autograd/_operations/matmul.py,sha256=TOz-yX0rMYR27B8TkPI_rpXk5y8Q-aG1g_wQ-T-whWo,579
+gradforge/autograd/_operations/mul.py,sha256=yZz9cW3PU-XjcUkVl_IGsXkssTSH6CZJUE3dCOk1iG8,606
+gradforge/autograd/_operations/pow.py,sha256=zY4FFDKWBri7hp7lxWKFxUkpHt3SIKy2Ohbn23IA8i8,515
+gradforge/autograd/_operations/sub.py,sha256=n543ZqspB99EB3YP6ccHFrMFT8VOK3v0-5oxEnWj9tA,408
+gradforge/backend/__init__.py,sha256=pkTWhqZ7U9fLeUIa36vEdUKkoPA79D4hJno8xC9g5ro,171
+gradforge/backend/backend.py,sha256=_Z6Tkx-_9ModqJyl0uEuJxrbwcbT7DMH8thhcHoym9c,1404
+gradforge/backend/backend_manager.py,sha256=_IO9Pp8MHyWQ-7WpXxbMI524oLceX8dw8RfMbR6ed0U,362
+gradforge/backend/cupy_backend/cuda_backend.py,sha256=SKwM4W96FvmBVp5665DtlNWtmiBI0BHEdjXpycwV6TY,65
+gradforge/backend/numpy_backend/numpy_backend.py,sha256=zpSvBVqi8w5fEbF-9C7umSV5h_I32MJsnqg2WO_CaUc,1407
+gradforge/core/tensor.py,sha256=wLkhUvlSTFDPT6xlq7Kha-tYrQFYIeIHpEkXk8IjqY0,2496
+gradforge/data/preprocessing/__init__.py,sha256=gBoGfS38ZaSRBpgdYFayKEhiNIkzQiKIM26HgPqtaAg,65
+gradforge/data/preprocessing/preprocess.py,sha256=scp38nnvgkZyQeT2SMQuhRReaZns0Xk2DQblPTBYGI0,860
+gradforge/metrics/__init__.py,sha256=GqFRSHuvlP-5feyRqZzMPWR_DbEFiGiTlJ3kBepbpg4,61
+gradforge/metrics/std_metrics.py,sha256=G6qqrvql415LfG_Fzmgz1OwDVonk70uDY16HIPvpY1c,1016
+gradforge/optimizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gradforge/optimizers/adam.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gradforge/optimizers/optimizer.py,sha256=ceuydMqwgOvSUWPGNMcPCOlo-QigO0hvfatAqEU0nnA,298
+gradforge/optimizers/sgd.py,sha256=Oazimj6oBrNc1YiOA4nqk1XRoOh6f8CYvaoqYFgXi_A,452
+gradforge/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gradforge/training/trainer.py,sha256=7glIrU3FZJXDViB8TRoSiUblmmu8pF4kPVJTnvB_9Ls,23
+gradforge/training/callbacks/__init__.py,sha256=8jUNKZaX0RRYCFYaa3knWpxa6OjcfTW8V401ClXY1QE,60
+gradforge/training/callbacks/std_callbacks.py,sha256=S-XxqVT31wQQwlziyuZe-QhcKxS0knqrqRATOp-5vKg,1283
+gradforge/training/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gradforge/training/layers/layer.py,sha256=xXo3u8vmIydFddHwlE-aUwkWc3V9JKUYSr5GigDMnYo,232
+gradforge/training/layers/linear.py,sha256=QIqmlrZ0qc1V5EGm2IsdvUlNsBr6NfshniXrPb09RbU,674
+gradforge/training/models/model.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gradforge/training/models/sequential.py,sha256=vmIyMMriQMPnO3TRPkfwI4RmEIyX3d8WWMyYZXb5aUA,278
+gradforge-2.0.1.dist-info/METADATA,sha256=KhOf7goGlV5FD1pxp2oZ5alNWSrNsuOeLYYEyUJBqEg,1529
+gradforge-2.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+gradforge-2.0.1.dist-info/top_level.txt,sha256=TPldOw70ltnRhalaxduzn67NgsiDip_VRbLqiscrUlI,10
+gradforge-2.0.1.dist-info/RECORD,,

gradforge-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gradforge-2.0.1.dist-info/top_level.txt

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