matrixflowers 0.1.0__tar.gz

matrixflowers-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: matrixflowers
+Version: 0.1.0
+Summary: A lightweight deep learning framework built from scratch
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+
+# matrixflowers
+
+A lightweight deep learning framework built from scratch.

matrixflowers-0.1.0/README.md

@@ -0,0 +1,3 @@
+# matrixflowers
+
+A lightweight deep learning framework built from scratch.

matrixflowers-0.1.0/matrixflowers.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: matrixflowers
+Version: 0.1.0
+Summary: A lightweight deep learning framework built from scratch
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+
+# matrixflowers
+
+A lightweight deep learning framework built from scratch.

matrixflowers-0.1.0/matrixflowers.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+pyproject.toml
+matrixflowers.egg-info/PKG-INFO
+matrixflowers.egg-info/SOURCES.txt
+matrixflowers.egg-info/dependency_links.txt
+matrixflowers.egg-info/requires.txt
+matrixflowers.egg-info/top_level.txt
+model/__init__.py
+model/linears.py
+model/loss.py
+model/optimizers.py
+model/parameter.py
+nn/__init__.py
+nn/activations.py
+nn/layers.py
+tools/activation.py
+train/__init__.py
+train/losses.py
+train/optimizers.py
+train/tape.py
+train/trainer.py
+type/matrix/py_implementation/bench.py
+type/matrix/py_implementation/matrix.py
+type/matrix/py_implementation/test.py

matrixflowers-0.1.0/matrixflowers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

matrixflowers-0.1.0/matrixflowers.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.24
+
+[dev]
+pytest>=7

matrixflowers-0.1.0/matrixflowers.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+model
+nn
+tools
+train
+type

matrixflowers-0.1.0/model/__init__.py

@@ -0,0 +1,4 @@
+from .parameter import Parameter
+from .optimizers import SGD, Adam
+from .loss import mse, mse_grad, cross_entropy, cross_entropy_grad, binary_cross_entropy, binary_cross_entropy_grad
+from .linears import Linear

matrixflowers-0.1.0/model/linears.py

@@ -0,0 +1,54 @@
+import numpy as np
+from .parameter import Parameter
+from type.matrix.py_implementation.matrix import Matrix
+
+
+class Linear:
+    """
+    Fully connected layer: y = x @ W + b
+
+    Supports forward and backward passes for gradient-based training.
+    """
+
+    def __init__(self, in_features: int, out_features: int):
+        # He initialization for better gradient flow
+        scale = np.sqrt(2.0 / in_features)
+        self.W = Parameter(np.random.randn(in_features, out_features).astype(np.float32) * scale)
+        self.b = Parameter(np.zeros((1, out_features), dtype=np.float32))
+
+        self._x_cache: np.ndarray | None = None
+
+    def forward(self, x: Matrix) -> Matrix:
+        self._x_cache = x.data
+        out = x.data @ self.W.data + self.b.data
+        return Matrix(out)
+
+    def backward(self, grad_output: Matrix) -> Matrix:
+        """
+        Backpropagates the gradient through this layer.
+
+        Args:
+            grad_output: Gradient w.r.t. the output of this layer (dL/dy).
+
+        Returns:
+            Gradient w.r.t. the input of this layer (dL/dx).
+        """
+        if self._x_cache is None:
+            raise RuntimeError("backward() called before forward(). Run forward() first.")
+
+        g = grad_output.data  # (batch, out_features)
+
+        self.W.grad += self._x_cache.T @ g          # (in_features, out_features)
+        self.b.grad += g.sum(axis=0, keepdims=True)  # (1, out_features)
+
+        grad_input = g @ self.W.data.T               # (batch, in_features)
+        return Matrix(grad_input)
+
+    def parameters(self) -> list[Parameter]:
+        return [self.W, self.b]
+
+    def __repr__(self) -> str:
+        return (
+            f"Linear(in_features={self.W.data.shape[0]}, "
+            f"out_features={self.W.data.shape[1]})"
+        )

matrixflowers-0.1.0/model/loss.py

@@ -0,0 +1,76 @@
+import numpy as np
+from type.matrix.py_implementation.matrix import Matrix
+
+
+def _validate_shapes(pred: Matrix, target: Matrix) -> None:
+    if pred.data.shape != target.data.shape:
+        raise ValueError(
+            f"Shape mismatch: pred={pred.data.shape}, target={target.data.shape}"
+        )
+
+
+# ── MSE ──────────────────────────────────────────────────────────────────────
+
+def mse(pred: Matrix, target: Matrix) -> float:
+    """Mean Squared Error loss."""
+    _validate_shapes(pred, target)
+    diff = pred.data - target.data
+    return float(np.mean(diff ** 2))
+
+
+def mse_grad(pred: Matrix, target: Matrix) -> Matrix:
+    """Gradient of MSE w.r.t. predictions: dL/dpred = 2*(pred - target) / N"""
+    _validate_shapes(pred, target)
+    n = pred.data.size
+    grad = (2.0 / n) * (pred.data - target.data)
+    return Matrix(grad.astype(np.float32))
+
+
+# ── Cross Entropy ─────────────────────────────────────────────────────────────
+
+def cross_entropy(pred: Matrix, target: Matrix) -> float:
+    """
+    Categorical cross-entropy loss.
+    Expects `pred` to be softmax probabilities and `target` to be one-hot encoded.
+    """
+    _validate_shapes(pred, target)
+    eps = 1e-9
+    batch_size = pred.data.shape[0]
+    clipped = np.clip(pred.data, eps, 1.0 - eps)
+    return float(-np.sum(target.data * np.log(clipped)) / batch_size)
+
+
+def cross_entropy_grad(pred: Matrix, target: Matrix) -> Matrix:
+    """
+    Gradient for softmax + cross-entropy (combined, numerically stable).
+    dL/dlogits = (pred - target) / batch_size
+    """
+    _validate_shapes(pred, target)
+    batch_size = pred.data.shape[0]
+    grad = (pred.data - target.data) / batch_size
+    return Matrix(grad.astype(np.float32))
+
+
+# ── Binary Cross Entropy ──────────────────────────────────────────────────────
+
+def binary_cross_entropy(pred: Matrix, target: Matrix) -> float:
+    """
+    Binary cross-entropy loss for sigmoid outputs.
+    Expects values in (0, 1).
+    """
+    _validate_shapes(pred, target)
+    eps = 1e-9
+    p = np.clip(pred.data, eps, 1.0 - eps)
+    t = target.data
+    return float(-np.mean(t * np.log(p) + (1.0 - t) * np.log(1.0 - p)))
+
+
+def binary_cross_entropy_grad(pred: Matrix, target: Matrix) -> Matrix:
+    """Gradient of BCE w.r.t. predictions."""
+    _validate_shapes(pred, target)
+    eps = 1e-9
+    p = np.clip(pred.data, eps, 1.0 - eps)
+    t = target.data
+    n = pred.data.size
+    grad = (-(t / p) + (1.0 - t) / (1.0 - p)) / n
+    return Matrix(grad.astype(np.float32))

matrixflowers-0.1.0/model/optimizers.py

@@ -0,0 +1,102 @@
+import numpy as np
+from .parameter import Parameter
+
+
+class SGD:
+    """
+    Stochastic Gradient Descent with optional momentum.
+
+    Update rule (no momentum):
+        p = p - lr * grad
+
+    Update rule (with momentum):
+        v = momentum * v - lr * grad
+        p = p + v
+    """
+
+    def __init__(self, parameters: list[Parameter], lr: float = 0.01, momentum: float = 0.0):
+        self.parameters = parameters
+        self.lr = lr
+        self.momentum = momentum
+        self._velocity = [np.zeros_like(p.data) for p in parameters]
+
+    def step(self) -> None:
+        for p, v in zip(self.parameters, self._velocity):
+            if self.momentum:
+                v[:] = self.momentum * v - self.lr * p.grad
+                p.data += v
+            else:
+                p.data -= self.lr * p.grad
+
+    def zero_grad(self) -> None:
+        for p in self.parameters:
+            p.zero_grad()
+
+    def __repr__(self) -> str:
+        return f"SGD(lr={self.lr}, momentum={self.momentum})"
+
+
+class Adam:
+    """
+    Adam optimizer (Adaptive Moment Estimation).
+
+    Reference: Kingma & Ba, 2015 — https://arxiv.org/abs/1412.6980
+
+    Update rule:
+        m = beta1 * m + (1 - beta1) * grad          # 1st moment
+        v = beta2 * v + (1 - beta2) * grad²         # 2nd moment
+        m̂ = m / (1 - beta1^t)                       # bias correction
+        v̂ = v / (1 - beta2^t)
+        p = p - lr * m̂ / (sqrt(v̂) + eps)
+    """
+
+    def __init__(
+        self,
+        parameters: list[Parameter],
+        lr: float = 1e-3,
+        beta1: float = 0.9,
+        beta2: float = 0.999,
+        eps: float = 1e-8,
+        weight_decay: float = 0.0,
+    ):
+        self.parameters = parameters
+        self.lr = lr
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.weight_decay = weight_decay
+
+        self._t = 0
+        self._m = [np.zeros_like(p.data) for p in parameters]
+        self._v = [np.zeros_like(p.data) for p in parameters]
+
+    def step(self) -> None:
+        self._t += 1
+        b1, b2, t = self.beta1, self.beta2, self._t
+
+        bc1 = 1.0 - b1 ** t   # bias correction factor 1
+        bc2 = 1.0 - b2 ** t   # bias correction factor 2
+
+        for p, m, v in zip(self.parameters, self._m, self._v):
+            g = p.grad
+
+            if self.weight_decay:
+                g = g + self.weight_decay * p.data
+
+            m[:] = b1 * m + (1.0 - b1) * g
+            v[:] = b2 * v + (1.0 - b2) * (g ** 2)
+
+            m_hat = m / bc1
+            v_hat = v / bc2
+
+            p.data -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps)
+
+    def zero_grad(self) -> None:
+        for p in self.parameters:
+            p.zero_grad()
+
+    def __repr__(self) -> str:
+        return (
+            f"Adam(lr={self.lr}, beta1={self.beta1}, "
+            f"beta2={self.beta2}, eps={self.eps})"
+        )

matrixflowers-0.1.0/model/parameter.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+
+class Parameter:
+    """
+    Wraps a numpy array as a trainable parameter with gradient tracking.
+    """
+
+    def __init__(self, data):
+        self.data = np.array(data, dtype=np.float32)
+        self.grad = np.zeros_like(self.data)
+
+    def zero_grad(self):
+        self.grad.fill(0.0)
+
+    def __repr__(self):
+        return f"Parameter(shape={self.data.shape}, dtype={self.data.dtype})"

matrixflowers-0.1.0/nn/__init__.py

@@ -0,0 +1,2 @@
+from .layers import Dense, Dropout, Sequential
+from .activations import relu, sigmoid, tanh, softmax, leaky_relu, elu, linear

matrixflowers-0.1.0/nn/activations.py

@@ -0,0 +1,159 @@
+"""
+matrixflowers.nn.activations
+======================
+Funções de ativação que funcionam com Tensor (autograd) E com Matrix (legado).
+
+As funções originais de tools/activation.py são preservadas como
+*_matrix(x) para compatibilidade. As versões padrão aqui aceitam Tensor
+e propagam gradientes automaticamente.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from tensor import Tensor
+from type.matrix.py_implementation.matrix import Matrix
+
+
+# ------------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------------
+
+def _to_tensor(x) -> Tensor:
+    if isinstance(x, Tensor):
+        return x
+    if isinstance(x, Matrix):
+        return Tensor(x, requires_grad=False)
+    return Tensor(np.array(x, dtype=np.float32))
+
+
+# ------------------------------------------------------------------
+# Ativações com autograd
+# ------------------------------------------------------------------
+
+def relu(x: Tensor | Matrix) -> Tensor:
+    """ReLU: max(0, x)"""
+    t = _to_tensor(x)
+    mask = (t.data > 0).astype(np.float32)
+    out = Tensor(t.data * mask, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        t._accumulate_grad(g * mask)
+
+    out._backward_fn = _bwd
+    return out
+
+def manu(x: Tensor | Matrix) -> Tensor:
+    """Activation: f(x) = x * sin(x)"""
+
+    t = _to_tensor(x)
+
+    out_data = t.data * np.sin(t.data)
+    out = Tensor(out_data, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        # f'(x) = sin(x) + x*cos(x)
+        grad_input = g * (np.sin(t.data) + t.data * np.cos(t.data))
+        t._accumulate_grad(grad_input)
+
+    out._backward_fn = _bwd
+    return out
+
+def sigmoid(x: Tensor | Matrix) -> Tensor:
+    """Sigmoid: 1 / (1 + e^-x)"""
+    t = _to_tensor(x)
+    s = 1.0 / (1.0 + np.exp(-t.data))
+    out = Tensor(s, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        t._accumulate_grad(g * s * (1.0 - s))
+
+    out._backward_fn = _bwd
+    return out
+
+
+def tanh(x: Tensor | Matrix) -> Tensor:
+    """Tanh: maps to [-1, 1]"""
+    t = _to_tensor(x)
+    th = np.tanh(t.data)
+    out = Tensor(th, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        t._accumulate_grad(g * (1.0 - th ** 2))
+
+    out._backward_fn = _bwd
+    return out
+
+
+def softmax(x: Tensor | Matrix) -> Tensor:
+    """Softmax (numericamente estável). Sem backward próprio — use com cross_entropy."""
+    t = _to_tensor(x)
+    shifted = t.data - t.data.max(axis=1, keepdims=True)
+    e = np.exp(shifted)
+    s = e / e.sum(axis=1, keepdims=True)
+    # Nota: backward do softmax sozinho é O(n²); na prática combina-se com
+    # cross_entropy e o gradiente combinado é simplesmente (pred - target)/batch.
+    return Tensor(s, requires_grad=t.requires_grad, _parents=(t,))
+
+
+def leaky_relu(x: Tensor | Matrix, alpha: float = 0.01) -> Tensor:
+    """Leaky ReLU: permite gradiente pequeno nos negativos."""
+    t = _to_tensor(x)
+    out_data = np.where(t.data > 0, t.data, alpha * t.data)
+    out = Tensor(out_data, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        t._accumulate_grad(g * np.where(t.data > 0, 1.0, alpha))
+
+    out._backward_fn = _bwd
+    return out
+
+
+def elu(x: Tensor | Matrix, alpha: float = 1.0) -> Tensor:
+    """ELU: Exponential Linear Unit."""
+    t = _to_tensor(x)
+    out_data = np.where(t.data > 0, t.data, alpha * (np.exp(t.data) - 1.0))
+    out = Tensor(out_data, requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        d = np.where(t.data > 0, 1.0, alpha * np.exp(t.data))
+        t._accumulate_grad(g * d)
+
+    out._backward_fn = _bwd
+    return out
+
+
+def linear(x: Tensor | Matrix) -> Tensor:
+    """Identidade (sem transformação)."""
+    t = _to_tensor(x)
+    out = Tensor(t.data.copy(), requires_grad=t.requires_grad, _parents=(t,))
+
+    def _bwd(g):
+        t._accumulate_grad(g)
+
+    out._backward_fn = _bwd
+    return out
+
+
+# ------------------------------------------------------------------
+# Mapa de nomes → função (útil para Sequential/Dense)
+# ------------------------------------------------------------------
+
+ACTIVATIONS: dict[str, callable] = {
+    "relu":       relu,
+    "sigmoid":    sigmoid,
+    "tanh":       tanh,
+    "softmax":    softmax,
+    "leaky_relu": leaky_relu,
+    "elu":        elu,
+    "linear":     linear,
+    "none":       linear,
+    "manu":       manu,
+}
+
+
+def get(name: str) -> callable:
+    """Retorna a função de ativação pelo nome."""
+    if name not in ACTIVATIONS:
+        raise ValueError(f"Ativação desconhecida: '{name}'. Disponíveis: {list(ACTIVATIONS)}")
+    return ACTIVATIONS[name]