PyZapo

PyZapo is a lightweight, modular, object-oriented deep learning framework built completely from scratch using only NumPy. It mimics the intuitive style of PyTorch, making it perfect for understanding modern neural network mechanics under the hood. 

🚀 Features

• Computer Vision & CNN Support (New in 1.2.0): Introduces a native Conv2D layer built completely from scratch using pure NumPy vector operations. Supports customizable input/output channels, kernel sizes, strides, and padding along with integrated backpropagation.
• Advanced Activations: Fully supports LeakyReLU with configurable alpha parameters to effectively prevent the "dying ReLU" problem and stabilize deep neural architectures (like GANs).
• Custom Autograd & Tensor Engine: Supports computational graphs with automated backward passes for seamless gradient tracking via Tensor and evaluation controls via no_grad.
• Object-Oriented Architecture: Build clean pipelines using Sequential blocks and custom Module classes.
• Robust Built-in Optimization: Layers come equipped with an integrated Adam optimizer right out of the box.
• Gradient Saturation Protection: Custom math safety controls (including vector clipping) in activations like Sigmoid to prevent gradient death.
• Advanced Loss Functions: Supports MSELoss, BCELoss (with automatic stabilization), and full multi-class CrossEntropyLoss (Fused Softmax + CE).

📦 Installation

Install the package directly from PyPI: 

bash

pip install pyzapo

Используйте код с осторожностью.

🛠️ Quick Start: Multi-Class Digit Classification (0-9)

Here is how easily you can build, train, and test a deep neural network using PyZapo 1.2.0 to classify inputs into 10 different categories (perfectly suited for datasets like MNIST): 

python

import numpy as np import pyzapo as pz

1. Generate synthetic dataset (e.g., 5 flattened 28x28 images)

X = np.random.rand(5, 784)

One-hot encoded labels for 10 distinct classes (digits 0-9)

y = np.eye(10)[:5]

2. Define deep network architecture with LeakyReLU (Clean OOP Style without .forward())

model = pz.Sequential([ pz.Linear(784, 32), pz.LeakyReLU(alpha=0.2), # Advanced activation handling negative gradients pz.Linear(32, 10) ])

criterion = pz.CrossEntropyLoss()

3. Training Loop with automated backpropagation and Adam steps

print('Training the model...') for epoch in range(1501): logits = model(X) # Clean call syntax loss = criterion(logits, y) # Fused Softmax + CrossEntropy

loss_grad = criterion.backward()
model.backward(loss_grad)
model.step(lr=0.01)

if epoch % 300 == 0:
    print(f'Epoch {epoch:4d} | Loss: {loss:.6f}')

4. Inference and Evaluation using no_grad context

with pz.no_grad(): test_logits = model(X)

shift_logits = test_logits - np.max(test_logits, axis=-1, keepdims=True) probs = np.exp(shift_logits) / np.sum(np.exp(shift_logits), axis=-1, keepdims=True)

predictions = np.argmax(probs, axis=-1) true_classes = np.argmax(y, axis=-1)

print(f'True Labels: {true_classes.tolist()}') print(f'Predictions: {predictions.tolist()}')