ntk-ml 1.0.0__py3-none-any.whl

neuraltoolkit/CLI.py

@@ -0,0 +1,19 @@
+import sys
+
+def progress_bar(frac, bar_length=40, front_str="", end_str=""):
+    filled_length = int(bar_length * frac)
+
+    # block character unicode escape: \u2588
+    bar = "\u2588" * filled_length + "-" * (bar_length - filled_length)
+    sys.stdout.write(f"\r{front_str} |{bar}| {end_str}")
+    sys.stdout.flush()
+
+def epoch_summary(config, metrics, epoch):
+    # accepts training config
+    sys.stdout.write((f"\rEpoch: {epoch} / {config.epochs} "
+                      f"- Loss: {metrics.loss:.5f} "))
+    
+    if metrics.val_loss != None:
+        sys.stdout.write(f"- Validation Loss: {metrics.val_loss:.5f}")
+    
+    sys.stdout.write(" " * 100 + "\n")

neuraltoolkit/__init__.py

@@ -0,0 +1,30 @@
+# Copyright (C) 2026  <Your Name or Organization>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://gnu.org>.
+
+__version__ = "1.0.0"
+
+from .modules import *
+
+from .data import *
+from .core import *
+from .modules.layers import *
+from .loss import *
+from .optimizers import *
+from .initializers import *
+from .training import Trainer
+from . import datasets
+
+
+print("Neural Tool Kit loaded!")

neuraltoolkit/core/__init__.py

@@ -0,0 +1,6 @@
+from .tensor import Tensor
+from .parameter import Parameter
+from .dtype import Dtype ,PYTHON_TYPE_TO_DTYPE
+from .device import Device
+from .tensor_ops import conv2d
+from .no_grad import no_grad

neuraltoolkit/core/device.py

@@ -0,0 +1,5 @@
+from enum import Enum, auto
+
+class Device(Enum):
+    CPU = auto()
+    GPU = auto()

neuraltoolkit/core/dtype.py

@@ -0,0 +1,18 @@
+from enum import Enum, auto
+import numpy as np
+
+class Dtype(Enum):
+    FLOAT32 = auto()
+    FLOAT64 = auto()
+    INT32 = auto()
+    INT64 = auto()
+
+# Converts python and numpy types into dtypes -> DTYPE
+PYTHON_TYPE_TO_DTYPE = {
+    int: Dtype.INT64,
+    float: Dtype.FLOAT64,
+    np.int32: Dtype.INT32,
+    np.int64: Dtype.INT64,
+    np.float32: Dtype.FLOAT32,
+    np.float64: Dtype.FLOAT64,
+}

neuraltoolkit/core/no_grad.py

@@ -0,0 +1,9 @@
+from .tensor import Tensor
+
+class no_grad:
+    def __enter__(self):
+        self.previous = Tensor.grad_enabled
+        Tensor.grad_enabled = False
+
+    def __exit__(self, exc_type, exc, tb):
+        Tensor.grad_enabled = self.previous

neuraltoolkit/core/parameter.py

@@ -0,0 +1,12 @@
+from .tensor import Tensor
+from .device import Device
+
+class Parameter(Tensor):
+    """
+    Tensor for learnable values
+    
+    Parameters always have gradients
+    """
+    def __init__(self, data):
+        super().__init__(data, requires_grad=True)
+        self.name = "Parameter"

neuraltoolkit/core/tensor.py

@@ -0,0 +1,354 @@
+import numpy as np
+from .dtype import Dtype
+from .device import Device
+
+class Tensor:
+    """
+    Standard multidemsional datastorage
+
+    Args:
+        data (numpy array or list): Tensor data (lists are converted to numpy arrays)
+        requires_grad (bool): Whether the tensor tracks gradients (defaults to False)
+        
+    """
+    data: np.ndarray
+    shape: tuple[int, ...]
+    dtype: Dtype
+
+    grad_enabled=True
+
+    def __init__(self, data, requires_grad=False):
+        self._parents = set()
+        self._backward_fn = None
+
+        self.data = self._init_data(data)
+
+        self.shape = self.data.shape
+
+        if self.data.dtype != np.float32:
+            self.data = self.data.astype(np.float32)
+        self.dtype = self.data.dtype
+        
+        self.requires_grad = requires_grad
+
+        self.grad = np.zeros(shape=self.shape, dtype=np.float32) if requires_grad else None
+
+        self.name = "Tensor"
+
+    def _init_data(self, d):
+        data = None
+        if isinstance(d, np.ndarray):
+            data = d
+        elif isinstance(d, list):
+            data = np.array(d)
+        else:
+            data = np.array([d])
+
+        if not np.issubdtype(data.dtype, np.number):
+            raise TypeError("Tensor data must be numeric")
+        
+        return data
+    
+    def clear_grad(self):
+        if self.requires_grad and Tensor.grad_enabled:
+            self.grad *= 0
+
+    def backward(self):
+        topo = []
+        visited = set()
+
+        self.grad = np.ones_like(self.data)
+
+        def build(node):
+            if node not in visited:
+                visited.add(node)
+
+                for parent in node._parents:
+                    build(parent)
+                topo.append(node)
+
+        build(self)
+
+
+        for node in reversed(topo):
+            if node._backward_fn:
+                node._backward_fn()
+                self._clear_links()
+
+    def _clear_links(self):
+        self._parents = set()
+        self._backward_fn = None
+
+    @property
+    def T(self):
+        out = Tensor(self.data.T, requires_grad=self.requires_grad)
+
+        if self.requires_grad and Tensor.grad_enabled:
+            def _transpose_backward():
+                self.grad += out.grad.T
+
+            out._parents = {self}
+            out._backward_fn = _transpose_backward
+
+        return out
+    
+    @staticmethod
+    def _reduce_broadcast(grad, shape):
+        # Remove extra leading dims
+        while grad.ndim > len(shape):
+            grad = grad.sum(axis=0)
+
+        # Collapse broadcasted axes
+        for axis, size in enumerate(shape):
+            if size == 1:
+                grad = grad.sum(axis=axis, keepdims=True)
+
+        return grad
+
+    def __repr__(self):
+        return f"Tensor:\n {self.data} \n"
+    
+    def _Tensor_wrapper(self, other):
+        return other if isinstance(other, Tensor) else Tensor(other)
+    
+    def __getitem__(self, idx):
+        sliced_data = self.data[idx]
+
+        out = Tensor(sliced_data, requires_grad=self.requires_grad)
+
+        def _slice_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                self.grad[idx] += out.grad
+
+            out._parents = {self}
+            out._backward_fn = _slice_backward
+
+        return out
+    
+    def __add__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data + other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _add_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad.copy()
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+            
+            if other.requires_grad:
+                grad_other = out.grad.copy()
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+        
+        out._backward_fn = _add_backward
+        return out
+    
+    def __radd__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data + self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _add_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad.copy()
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+            
+            if other.requires_grad:
+                grad_other = out.grad.copy()
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _add_backward
+        return out
+    
+    def __sub__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data - other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _sub_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad.copy()
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+            
+            if other.requires_grad:
+                grad_other = out.grad.copy()
+                other.grad -= self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _sub_backward
+        return out
+    
+    def __rsub__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data - self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _sub_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad.copy()
+                self.grad -= self._reduce_broadcast(grad_self, self.shape)
+            
+            if other.requires_grad:
+                grad_other = out.grad.copy()
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _sub_backward
+        return out
+    
+    def __mul__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data * other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _mul_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad * other.data
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = out.grad * self.data
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _mul_backward
+        return out
+    
+    def __rmul__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data * self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _mul_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad * other.data
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = out.grad * self.data
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _mul_backward
+        return out
+    
+    def __truediv__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data / other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _div_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = out.grad / other.data
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = -out.grad * self.data / (other.data ** 2)
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _div_backward
+        return out
+    
+    def __rtruediv__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data / self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _div_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = -out.grad * other.data / (self.data ** 2)
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = out.grad / self.data
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _div_backward
+        return out
+    
+    def __pow__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data ** other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _pow_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = other.data * (self.data ** (other.data - 1)) * out.grad
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = np.log(self.data) * (self.data ** other.data) * out.grad
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _pow_backward
+        return out
+    
+    def __rpow__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data ** self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _pow_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                grad_self = np.log(other.data) * (other.data ** self.data) * out.grad
+                self.grad += self._reduce_broadcast(grad_self, self.shape)
+
+            if other.requires_grad:
+                grad_other = self.data * (other.data ** (self.data - 1)) * out.grad
+                other.grad += self._reduce_broadcast(grad_other, other.shape)
+
+        out._backward_fn = _pow_backward
+        return out
+    
+    def __matmul__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data @ other.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _matmul_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                self.grad += out.grad @ other.data.T
+
+            if other.requires_grad:
+                other.grad += self.data.T @ out.grad
+
+        out._backward_fn = _matmul_backward
+        return out
+    
+    def __rmatmul__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data @ self.data, requires_grad=True)
+
+        out._parents = {self, other}
+
+        def _matmul_backward():
+            if self.requires_grad and Tensor.grad_enabled:
+                self.grad += other.data.T @ out.grad
+
+            if other.requires_grad:
+                other.grad += out.grad @ self.data.T
+
+        out._backward_fn = _matmul_backward
+        return out
+
+    def __floordiv__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data // other.data)
+    
+    def __rfloordiv__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data // self.data)
+    
+    def __mod__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(self.data % other.data)
+    
+    def __rmod__(self, other):
+        other = self._Tensor_wrapper(other)
+        out = Tensor(other.data % self._unwrap)

neuraltoolkit/core/tensor_ops.py

@@ -0,0 +1,173 @@
+from .tensor import Tensor
+from ..ops.image_processing import *
+import numpy as np
+
+
+def conv2d(x, kernel, stride, pad, flat_index_map) -> Tensor:
+    """
+    Performs a convolutional operation on a batch of images.
+    --------------------------------------------------------
+
+    Arguments:
+        x (tensor (N, C_in, H, W)): Batch of input images.
+        kernel (parameter (C_out, C_in, K, K)): kernel/filter weights.
+        stride (int or tuple): The number pixels the kernel/filter moves at each step. Defaults to 1.
+        pad (int or tuple): The number of filler pixels (0s) to be inserted around the borders of the images.
+        flat_index_map: output from get_im2col_indices(). must match complete conv output shape
+    ------------------------------------------------------------------------------------------------
+
+    Returns:
+        Tensor(N, C_out, out_height, out_width)
+    """
+
+    stride_h, stride_w = split_2d_param(stride)
+    pad_h, pad_w = split_2d_param(pad)
+
+    C_out = kernel.shape[0]
+    K_h = kernel.shape[2] # kernel/filter height
+    K_w = kernel.shape[3] # kernel/filter width
+
+    N, C_in, H, W = x.shape
+
+    if pad_h > 0 or pad_w > 0:
+        x_padded = np.pad(x.data, ((0, 0), (0, 0), (pad_h, pad_h), (pad_w, pad_w)), mode="constant")
+    else:
+        x_padded = x.data
+    out_height, out_width = output_image_size(H, W, (K_h, K_w), stride, pad)
+
+    kernel_flat = np.reshape(kernel.data, shape=(C_out, C_in * K_h * K_w))
+
+    img_patches = im2col_fast(x_padded, flat_index_map)
+
+    out_flat = img_patches @ kernel_flat.T # shape (N, H_out * W_out, C_out)
+    
+    out = out_flat.reshape((N, out_height, out_width, C_out))
+    out = out.transpose(0, 3, 1, 2).copy()
+    out = Tensor(out, requires_grad=True)
+
+    def _conv2d_backward():
+        if x.requires_grad and Tensor.grad_enabled:
+            grad_x = out.grad.copy() # (N, C_out, H_out, W_out)
+            flat_grad_x = grad_x.reshape(N, C_out, out_height * out_width)
+            flat_grad_x = flat_grad_x.transpose(0, 2, 1).copy()
+            dx_col = flat_grad_x @ kernel_flat
+
+            dx = col2im_fast(dx_col, flat_index_map, x_padded.shape)
+
+            if pad_h > 0 or pad_w > 0:
+                x.grad += unpad(dx, ((0, 0), (0, 0), (pad_h, pad_h), (pad_w, pad_w)))
+            else:
+                x.grad += dx
+        
+        if kernel.requires_grad and Tensor.grad_enabled:
+            grad = out.grad.copy() # (N, C_out, H_out, W_out)
+            grad_reshaped = grad.reshape((N, C_out, out_height * out_width))
+
+            # (N, C_out, H_out*W_out) @ (N H_out*W_out, C_in*Kh*kw) = (N, C_out, C_int*Kh*Kw)
+            dw_batches = grad_reshaped @ img_patches
+
+            # summed acrossed batches and set to original kernel shape
+            dw = np.sum(dw_batches, axis=0).reshape(C_out, C_in, K_h, K_w) 
+            
+            kernel.grad += dw
+
+    out._parents = {x, kernel}
+    out._backward_fn = _conv2d_backward
+    return out
+
+def reshape(x, shape):
+    x_shape = x.shape
+    data = x.data.copy()
+    out = np.reshape(data, shape=shape)
+    out = Tensor(out, requires_grad=True)
+
+    out._parents = {x}
+
+    def _reshape_backward():
+        if x.requires_grad and Tensor.grad_enabled:
+            grad_x = out.grad.copy()
+            x.grad += np.reshape(grad_x, shape=x_shape)
+    
+    out._backward_fn = _reshape_backward
+    return out
+
+def max_pool2d(
+        x:Tensor,
+        kernel_size:int|tuple,
+        stride:int|tuple,
+        pad:int|tuple,
+        flat_index_map
+):
+    """
+    Performs a max pooling operation on a batch of images.
+    -----------------------------------------------------
+
+    Arguments:
+        x (tensor of shape: (N, C_in, H, W)): A batch of input images.
+        kernel_size (int or tuple): The size of kernel/filter.
+        stride (int or tuple): The number pixels the kernel/filter moves at each step. Defaults to 1.
+        pad (int or tuple): The number of filler pixels (0s) to be inserted around the borders of the images.
+        flat_index_map: output from get_im2col_indices(). must match complete max_pool output shape      
+    Returns:
+        scaled down numpy array of max values
+    """
+
+
+    kh, kw = split_2d_param(kernel_size)
+    kernel_area = kh * kw
+
+    N, C, H, W = x.shape # N: samples, C: channels, H: height, W: width
+    pad_h, pad_w = split_2d_param(pad)
+
+    if pad_h > 0 or pad_w > 0:
+        padded_x = np.pad(x.data, ((0, 0), (0, 0), (pad_h, pad_h), (pad_w, pad_w)), mode="constant")
+    else:
+        padded_x = x.data
+    H_out, W_out = output_image_size(H, W, kernel_size, stride, pad)
+
+    HW_out = H_out*W_out
+
+
+    patches_flat = im2col_fast(padded_x, flat_index_map) # Shape (N, H*W, C*K*K)
+    patches_flat = np.reshape(patches_flat, shape=(N, HW_out, C, kernel_area))
+    #patches_flat = patches_flat.transpose(0, 2, 1, 3) # Shape (N, C, HW_out, K*K)
+
+    max_val_indices = np.argmax(patches_flat, axis=-1, keepdims=True) # Shape (N, HW_out, C, 1)
+    max_pool = np.take_along_axis(patches_flat, max_val_indices, axis=-1) # Shape (N, HW_out, C, 1)
+    max_pool = np.squeeze(max_pool, axis=-1) # Shape (N, HW_out C,)
+    max_pool = max_pool.transpose(0, 2, 1).copy()
+    max_pool = max_pool.reshape(N, C, H_out, W_out)
+
+    out = Tensor(max_pool, requires_grad=True)
+
+    out._parents = {x}
+
+    def _max_pool2d_backward():
+        if x.requires_grad and Tensor.grad_enabled:
+            max_indices = max_val_indices.squeeze(-1) # (N, HW_out, C)
+
+            n_idx = np.arange(N)[:, None, None]
+            hw_idx = np.arange(HW_out)[None, :, None]
+            c_idx = np.arange(C)[None, None, :]
+
+            flat_index_map_reshaped = flat_index_map.reshape(N, HW_out, C, kernel_area)
+
+            # Shape (N, HW_out, C) - Advanced indexing
+            im_index_map = flat_index_map_reshaped[n_idx, hw_idx, c_idx, max_indices]
+
+            # Shape (N, C, HW_out)
+            im_index_map = im_index_map.transpose(0, 2, 1).copy()
+
+            grad_reshaped = out.grad.reshape((N, C, HW_out))
+            
+            dx_flat = np.bincount(im_index_map.ravel(), grad_reshaped.ravel(), minlength=np.prod(padded_x.shape))
+            dx = dx_flat.reshape(N, C, H, W)
+
+            if pad_h > 0 or pad_w > 0:
+                x.grad += unpad(dx, ((0, 0), (0, 0), (pad_h, pad_h), (pad_w, pad_w)))
+            else:
+                x.grad += dx
+
+
+    out._backward_fn = _max_pool2d_backward
+    return out

neuraltoolkit/data/__init__.py

@@ -0,0 +1,3 @@
+from .dataset import Dataset
+from .dataloader import Dataloader
+from .subset import Subset