gradforge 2.0.1__tar.gz → 2.0.2__tar.gz

{gradforge-2.0.1 → gradforge-2.0.2}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: gradforge
-Version: 2.0.1
+Version: 2.0.2
 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: colorama>=0.4.6
 Requires-Dist: numpy
 Requires-Dist: pytest>=9.1.1
 Provides-Extra: cuda

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/_tests/test_linear.py

@@ -17,11 +17,9 @@ def train(model, x, y, epochs):
 
         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('eror grad: ', error.grad)
+        optimizer.step(model.params)
+        print("Bias grad: ", model.b.grad, "Bias data: ", model.b.data)
 
     print(x.data @ model.w.data)
 
@@ -33,6 +31,7 @@ assert x.data.shape == y.data.shape
 #before = tracemalloc.take_snapshot()
 
 model = Linear(1, 1)
+print(model.b.data)
 train(model, x, y, epochs=10000)
 # after = tracemalloc.take_snapshot()
 

gradforge-2.0.2/gradforge/_utils/colored_logger.py

@@ -0,0 +1,35 @@
+import logging
+
+from colorama import Fore, Style, init
+
+
+class ColoredFormatter(logging.Formatter):
+
+    COLORS = {  
+        logging.DEBUG: Fore.CYAN,
+        logging.INFO: Fore.GREEN,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.RED + Style.BRIGHT
+    }
+
+    def format(self, record):
+        color = self.COLORS.get(record.levelno, Fore.WHITE)
+ 
+        fmt = f"{Fore.LIGHTBLACK_EX}%(asctime)s {color}[%(levelname)s]{Style.RESET_ALL} %(message)s"
+        
+        formatter = logging.Formatter(fmt, datefmt='%H:%M:%S')
+        return formatter.format(record)
+
+class Logger:
+    def __init__(self):
+        init(autoreset=True)
+        self.logger = logging.getLogger("AppLogger")
+        self.logger.setLevel(logging.DEBUG)
+
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(ColoredFormatter())
+        self.logger.addHandler(console_handler)
+
+    def get_logger(self):
+        return self.logger

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/autograd/_operations/add.py

@@ -1,5 +1,6 @@
 from ...autograd.operation import Operation
 
+
 class Add(Operation):
     def __init__(self, backend) -> None:
         super().__init__(backend)

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/autograd/engine.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
+
 from ..backend.backend_manager import BackendManager
 
+
 class Engine(ABC):
     def __init__(self) -> None:
         super().__init__()

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/autograd/standard_engine.py

@@ -27,6 +27,7 @@ class StandardEngine(Engine):
             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)

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/backend/backend.py

@@ -80,6 +80,10 @@ class Backend(ABC):
     def is_native(self, data) -> bool:
         pass
 
+    @abstractmethod
+    def sum_array(self, data, axis: tuple):
+        pass
+
 
 
     

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/backend/numpy_backend/numpy_backend.py

@@ -64,9 +64,17 @@ class NumpyBackend(Backend):
         return np.ones(shape)
 
     def is_native(self, data) -> bool:
-        if type(data) is np.ndarray:
-            return True
-        else: 
-            return False
+        return type(data) is np.ndarray
+
+    def sum_array(self, data, axis: tuple):
+        if(axis[0]):
+            data = self.convert([sum(data)])
+
+        if(axis[1]):
+            data = self.convert([sum(string) for string in data])
+
+        return data
+
+
         
     

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/core/tensor.py

@@ -5,14 +5,18 @@ from ..autograd._operations import mul, matmul, sub, div, add, pow
 from typing import Optional
 
 class Tensor():
-    __slots__ = ['data', 'requires_grad', 'grad', 'grad_fn', 'backend']
+    __slots__ = ['data', 'requires_grad', 'grad', 'grad_fn', 'backend', 'grad_sum_axes']
     
-    def __init__(self, data, requires_grad: bool = False):
+    def __init__(self, data, requires_grad: bool = False, grad_sum_axes: tuple = (0, 0)):
         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)
+        self.grad_sum_axes = grad_sum_axes
+
+    def sum_grads(self):
+        self.grad = self.backend.sum_array(self.grad, self.grad_sum_axes)
 
     def __mul__(self, other): 
         mul_op = mul.Mul(self.backend)

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/optimizers/sgd.py

@@ -6,8 +6,10 @@ class SGD(Optimizer):
 
     def step(self, params: list[Tensor]):
         for param in params:
+            if param.data.shape != param.grad.shape:
+                param.sum_grads()
             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)   
+            param.grad = 0  

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge/training/layers/linear.py

@@ -6,9 +6,11 @@ class Linear(Layer):
         super().__init__()      
         self._backend = BackendManager.get_backend()
         self.w: Tensor = Tensor(self._backend.array_zeros((in_shape, out_shape)), requires_grad=True)
+        self.b: Tensor = Tensor(self._backend.array_ones((1,)), requires_grad=True, grad_sum_axes=(1, 1))
+
         
     def predict(self, x: Tensor) -> Tensor:
-        return x @ self.w
+        return x @ self.w + self.b
 
     @property
     def params(self) -> list[Tensor]:

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: gradforge
-Version: 2.0.1
+Version: 2.0.2
 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: colorama>=0.4.6
 Requires-Dist: numpy
 Requires-Dist: pytest>=9.1.1
 Provides-Extra: cuda

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ gradforge/_exceptions/_errors.py
 gradforge/_tests/profiling_stats.py
 gradforge/_tests/test_linear.py
 gradforge/_tests/test_operation.py
+gradforge/_utils/colored_logger.py
 gradforge/autograd/__init__.py
 gradforge/autograd/engine.py
 gradforge/autograd/operation.py

{gradforge-2.0.1 → gradforge-2.0.2}/gradforge.egg-info/requires.txt

@@ -1,3 +1,4 @@
+colorama>=0.4.6
 numpy
 pytest>=9.1.1
 

{gradforge-2.0.1 → gradforge-2.0.2}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gradforge" 
-version = "2.0.1"
+version = "2.0.2"
 description = "Machinelearning library"
 readme = "README.md"
 license = {text = "MIT"}
 authors = [{name = "insane-machines", email = "forshnikita2@gmail.com"}]
 requires-python = ">=3.11"
 dependencies = [
+    "colorama>=0.4.6",
     "numpy",
     "pytest>=9.1.1",
 ]