🌌 Sorix

Sorix is a high-performance, minimalist deep learning library built on top of NumPy/CuPy. Designed for research and production environments where efficiency and a clean API matter. If you know PyTorch, you already know how to use Sorix.

📖 Read the Full Documentation

🚀 Key Features

• ⚡ High Performance: Run optimized neural networks on NumPy (CPU) or CuPy (GPU).
• 🧩 PyTorch-like API: Familiar and expressive syntax for a near-zero learning curve.
• 🍃 Lightweight: Minimal dependencies, ideal for resource-constrained environments.
• 🛠️ Production Ready: Straight path from prototype to real-world deployment.
• 📈 Autograd Engine: Simple yet powerful automatic differentiation.

📊 Benchmark Results

Sorix outpaces the giants in resource efficiency while matching them in speed. In our MNIST benchmark, Sorix demonstrates its extreme lightweight nature:

💡 Tip: Sorix is ~28x smaller than PyTorch for GPU support and ~13x smaller on CPU, making it the perfect choice for serverless environments (like AWS Lambda) and edge computing.

👉 Full Benchmark Report

📦 Installation

Choose your preferred package manager:

Using pip:

pip install sorix

Using uv:

uv add sorix

Using Poetry:

poetry add sorix

Note for GPU support: Install the CuPy extra using pip install "sorix[cp13]" (Requires CuPy v13 and CUDA).

⚡ Full Pipeline: Define, Train, Save & Load

Building a neural network, training it, and persisting it for later use is straightforward:

import numpy as np
from sorix import tensor, save, load
from sorix.nn import Sequential, Linear, ReLU, MSELoss
from sorix.optim import SGD

# 1. Prepare data (y = 3x^2 + 2)
X = np.linspace(-1, 1, 100).reshape(-1, 1)
y = 3 * X**2 + 2 + 0.1 * np.random.randn(*X.shape)
X_t, y_t = tensor(X), tensor(y)

# 2. Define a multi-layer model
model = Sequential(
    Linear(1, 10),
    ReLU(),
    Linear(10, 1)
)

# 3. Define loss and optimizer
criterion = MSELoss()
optimizer = SGD(model.parameters(), lr=0.01)

# 4. Training loop
for epoch in range(1000):
    y_pred = model(X_t)
    loss = criterion(y_pred, y_t)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 200 == 0:
        print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

# 5. Save the model
save(model, "model.sor")

# 6. Load and verify
model_loaded = load("model.sor")
test_val = tensor([[0.5]])
print(f"Prediction for 0.5: {model_loaded(test_val).item():.4f}")

📖 Learn & Examples

Learn Sorix through interactive notebooks. Open them directly in Google Colab:

Topic	Documentation	Colab
Tensor Basics	Tensors Guide
Autograd Engine	Autograd Guide
Module Basics	Module Guide
Linear Regression	Regression Guide
MNIST Classification	MNIST Guide

🛠️ Roadmap

• Core Autograd Engine (NumPy/CuPy backends)
• Basic Layers: Linear, ReLU, Sigmoid, Tanh, BatchNorm1D, Dropout
• Optimizers: SGD, Adam, RMSprop
• GPU Acceleration via CuPy
• Sequential API
• Convolutional Layers (Conv2d, MaxPool2d)
• Advanced Initializations (Kaiming, Orthogonal)
• Data Loaders & Datasets

🤝 Contribution

We appreciate any contribution from the community!

1. Report Bugs: Open an Issue.
2. Add Features: Submit a Pull Request.
3. Improve Docs: Help us make the documentation better.
4. Write Tests: Improve our code coverage.

📌 Links

• Documentation: mitchell-mirano.github.io/sorix
• PyPI Package: sorix
• Samples: examples/ folder

Made with ❤️ for the AI Community