pyzapo 1.0.0__py3-none-any.whl

pyzapo/__init__.py

@@ -0,0 +1,4 @@
+from .layers import Linear, Sigmoid, ReLU, Sequential, Module
+from .losses import MSELoss, BCELoss
+
+__all__ = ['Linear', 'Sigmoid', 'ReLU', 'Sequential', 'Module', 'MSELoss', 'BCELoss']

pyzapo/layers.py

@@ -0,0 +1,145 @@
+import numpy as np
+
+class Linear:
+    def __init__(self, in_features, out_features):
+        self.W = np.random.randn(in_features, out_features) * 0.1
+        self.b = np.zeros((1, out_features))
+
+        self.m_W, self.m_b = np.zeros_like(self.W), np.zeros_like(self.b)
+        self.v_W, self.v_b = np.zeros_like(self.W), np.zeros_like(self.b)
+        self.t = 0
+
+    def forward(self, x):
+        self.x = x
+
+        return np.dot(x, self.W) + self.b
+
+    def backward(self, delta):
+        self.dW = np.dot(self.x.T, delta)
+        self.db = np.sum(delta, axis=0, keepdims=True)
+
+        next_delta = np.dot(delta, self.W.T)
+
+        return next_delta
+
+    def step(self, lr, beta1=0.9, beta2=0.999, eps=1e-8):
+        self.t += 1
+
+        self.m_W = beta1 * self.m_W + (1 - beta1) * self.dW
+        self.m_b = beta1 * self.m_b + (1 - beta1) * self.db
+
+        self.v_W = beta2 * self.v_W + (1 - beta2) * (self.dW ** 2)
+        self.v_b = beta2 * self.v_b + (1 - beta2) * (self.db ** 2)
+
+        m_W_corrected = self.m_W / (1 - beta1 ** self.t)
+        m_b_corrected = self.m_b / (1 - beta1 ** self.t)
+        v_W_corrected = self.v_W / (1 - beta2 ** self.t)
+        v_b_corrected = self.v_b / (1 - beta2 ** self.t)
+
+        self.W -= lr * m_W_corrected / (np.sqrt(v_W_corrected) + eps)
+        self.b -= lr * m_b_corrected / (np.sqrt(v_b_corrected) + eps)
+
+    def __call__(self, x):
+        return self.forward(x)
+
+class Sigmoid:
+    def forward(self, x):
+        self.y_pred = 1 / (1 + np.exp(-x))
+        
+        return self.y_pred
+
+    def backward(self, delta):
+        return delta * (self.y_pred * (1 - self.y_pred))
+
+    def __call__(self, x):
+        return self.forward(x)
+
+class Sequential:
+    def __init__(self, layers_list):
+        self.layers = layers_list
+
+    def forward(self, x):
+        out = x
+        for layer in self.layers:
+            out = layer.forward(out)
+
+        return out
+
+    def backward(self, loss_gradient):
+        delta = loss_gradient
+        for layer in reversed(self.layers):
+            delta = layer.backward(delta)
+
+        return delta
+
+    def step(self, lr):
+        for layer in self.layers:
+            if hasattr(layer, 'step'):
+                layer.step(lr)
+
+    def save_weight(self, filepath: str):
+        weight_dict = {}
+        for idx, layer in enumerate(self.layers):
+            if hasattr(layer, 'W'):
+                weight_dict[f'layer_{idx}_W'] = layer.W
+                weight_dict[f'layer_{idx}_b'] = layer.b
+
+        np.savez(filepath, **weight_dict)
+
+    def load_weight(self, filepath: str):
+        try:
+            data = np.load(filepath)
+            for idx, layer in enumerate(self.layers):
+                if hasattr(layer, 'W'):
+                    w_key = f'layer_{idx}_W'
+                    b_key = f'layer_{idx}_b'
+
+                    if w_key in data and b_key in data:
+                        layer.W = data[w_key]
+                        layer.b = data[b_key]
+
+        except FileNotFoundError:
+            print(f"❌ Файл {filepath} не найден! Проверь путь.")
+
+class ReLU:
+    def forward(self, x):
+        self.x = x
+
+        return np.maximum(0, x)
+
+    def backward(self, delta):
+        return delta * (self.x > 0)
+
+    def __call__(self, x):
+        return self.forward(x)
+
+class Module:
+    def __init__(self):
+        pass
+
+    def __call__(self, x):
+        return self.forward(x)
+
+    def step(self, lr):
+        for attr in vars(self).values():
+            if hasattr(attr, 'step'):
+                attr.step(lr)
+
+    def save_weights(self, filepath: str):
+        weights_dict = {}
+        for name, attr in vars(self).items():
+            if hasattr(attr, 'W'):
+                weights_dict[f"{name}_W"] = attr.W
+                weights_dict[f"{name}_b"] = attr.b
+        np.savez(filepath, **weights_dict)
+
+    def load_weights(self, filepath: str):
+        try:
+            data = np.load(filepath)
+            for name, attr in vars(self).items():
+                if hasattr(attr, 'W'):
+                    if f"{name}_W" in data and f"{name}_b" in data:
+                        attr.W = data[f"{name}_W"]
+                        attr.b = data[f"{name}_b"]
+        except FileNotFoundError:
+            print(f"❌ Файл {filepath} не найден!")

pyzapo/losses.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+class MSELoss:
+    def forward(self, y_pred, y_true):
+        self.y_pred = y_pred
+        self.y_true = y_true
+
+        return np.mean((y_pred - y_true) ** 2)
+
+    def backward(self):
+        return self.y_pred - self.y_true
+
+    def __call__(self, y_pred, y_true):
+        return self.forward(y_pred, y_true)
+
+class BCELoss:
+    def forward(self, y_pred, y_true):
+        y_pred = np.clip(y_pred, 1e-15, 1 - 1e-15)
+        loss = -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
+
+        self.y_pred = y_pred
+        self.y_true = y_true
+
+        return np.mean(loss)
+
+    def backward(self):
+        grad = (self.y_pred - self.y_true) / (self.y_pred * (1 - self.y_pred)) / len(self.y_true)
+
+        return grad
+
+    def __call__(self, y_pred, y_true):
+        return self.forward(y_pred, y_true)

pyzapo-1.0.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pyzapo
+Version: 1.0.0
+Summary: Модульный ООП фреймворк для глубокого обучения на чистом NumPy в стиле PyTorch с оптимизатором Adam
+Author-email: wiffy <melnikarthur280912@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+
+# PyZapo 🚀
+
+**PyZapo** is a lightweight, object-oriented Deep Learning framework written completely from scratch using **pure NumPy** (without PyTorch) [ML / AI Engineering: PyTorch]. 
+
+It features an in-built adaptive **Adam optimizer** right inside the layers, making neural network training fast, clean, and highly efficient without any extra boilerplate code [ML / AI Engineering: PyTorch].
+
+## Features ✨
+* **PyTorch-Style Syntax:** Built-in `__call__` allows you to invoke models and layers like functions (`model(X)`) [ML / AI Engineering: PyTorch].
+* **OOP Architecture:** Inherit from `Module` to build complex custom neural networks [ML / AI Engineering: PyTorch].
+* **Built-in Adam Optimizer:** Adaptive learning rate for each weight out of the box.
+* **Modern Activations:** High-performance `ReLU` and `Sigmoid` layers.
+* **Loss Functions:** `MSELoss` and binary cross-entropy (`BCELoss`) with clipping safety.
+* **Weights Management:** Save and load your trained models instantly with `.npz` binary files.
+
+## Installation 📦
+```bash
+pip install pyzapo
+```
+
+## Quick Start 💻
+```python
+import numpy as np
+import pyzapo as pz
+
+# 1. Define your custom architecture
+class MyCoolAi(pz.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = pz.Linear(2, 8)
+        self.relu = pz.ReLU()
+        self.fc2 = pz.Linear(8, 1)
+        self.sigmoid = pz.Sigmoid()
+
+    def forward(self, x):
+        out = self.fc1(x)
+        out = self.relu(out)
+        out = self.fc2(out)
+        out = self.sigmoid(out)
+        return out
+
+    def backward(self, loss_gradient):
+        delta = self.sigmoid.backward(loss_gradient)
+        delta = self.fc2.backward(delta)
+        delta = self.relu.backward(delta)
+        delta = self.fc1.backward(delta)
+        return delta
+
+# 2. Train and Save
+X = np.array([[5.0, 1.0], [1.0, 50.0]])
+y = np.array([[1.0], [0.0]])
+
+model = MyCoolAi()
+criterion = pz.BCELoss()
+
+for epoch in range(1000):
+    pred = model(X)
+    loss = criterion(pred, y)
+    
+    loss_grad = criterion.backward()
+    model.backward(loss_grad)
+    model.step(lr=0.01)
+
+model.save_weights("my_model.npz")
+```

pyzapo-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyzapo/__init__.py,sha256=vea0apox4gTgNB-0ndenAiEFYe8GDjEQejyW0xu0VdI,188
+pyzapo/layers.py,sha256=_NRrBSjDuGi_2lQ8nTmz0KrZFN-IhhxpDG1psTA7hfM,4433
+pyzapo/losses.py,sha256=9-49k0YhwJAfa3fyO3xCF3ahaoVTJr4J6KfIp2sddyU,870
+pyzapo-1.0.0.dist-info/METADATA,sha256=ncnXW5VKouqynCV1cT2xifOhileaWA8WcrW-tVeDtHI,2741
+pyzapo-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyzapo-1.0.0.dist-info/top_level.txt,sha256=p-YIvgySYK0JdhFEqSxl1PY0t2NU91wHS2nrUCmyI78,7
+pyzapo-1.0.0.dist-info/RECORD,,

pyzapo-1.0.0.dist-info/WHEEL

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

pyzapo-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyzapo