sorix 1.0.0__tar.gz

sorix-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Mitchell-Mirano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sorix-1.0.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: sorix
+Version: 1.0.0
+Summary: A minimalistic framework for building neural networks in Python.
+Author-email: Mitchell Mirano <mitchellmirano25@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Provides-Extra: cp13
+Requires-Dist: cupy-cuda13x>=13.0; extra == "cp13"
+Requires-Dist: numpy<3.0,>=2.0; extra == "cp13"
+Dynamic: license-file
+
+
+# **Sorix**
+
+sorix: is a library  of Artificial Intelligence for
+beginners.
+
+![sorix Clustering Image](https://storage.googleapis.com/open-projects-data/allison/training_animation.gif)
+
+It provides a **NumPy/CuPy-based backend** for handling tensors on both **CPU and GPU**, making it ideal for beginners who want to learn how frameworks like PyTorch work internally.
+
+---
+
+## **Install**
+- With pip
+```bash
+pip install sorix
+```
+
+Or with [Poetry](https://python-poetry.org/):
+
+```bash
+poetry add sorix
+```
+
+Or with [UV](https://docs.astral.sh/uv/guides/install-python/)
+```bash
+uv add sorix
+```
+
+---
+
+## ⚡ **Quick Start**
+
+
+### Autograd Example
+
+```python
+from sorix import tensor
+
+# Create tensors with gradient tracking
+x = tensor([2.0], requires_grad=True)
+w = tensor([3.0], requires_grad=True)
+b = tensor([1.0], requires_grad=True)
+
+# Define a simple function: y = w*x + b
+y = w * x + b
+
+# Compute gradients via backpropagation
+y.backward()
+
+print("dy/dx:", x.grad)   # → should be w = 3
+print("dy/dw:", w.grad)   # → should be x = 2
+print("dy/db:", b.grad)   # → should be 1
+```
+---
+
+### 🔢 Linear Regression Example
+
+```python
+import numpy as np
+from sorix import tensor
+from sorix.nn import Linear, MSELoss
+from sorix.optim import SGD
+
+# 🎯 Generate synthetic data (y = 3x + 2 + noise)
+X = np.linspace(-1, 1, 100).reshape(-1, 1)
+y = 3 * X + 2 + 0.1 * np.random.randn(*X.shape)
+
+# Convert to sorix tensors (CPU, use device="cuda" for GPU)
+X_tensor = tensor(X, device="cpu")
+y_tensor = tensor(y, device="cpu")
+
+# Define model, loss, and optimizer
+features, outputs = 1, 1
+model = Linear(features, outputs)
+criterion = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.1)
+
+# 🏋️ Training loop
+for epoch in range(200):
+    # Forward pass
+    y_pred = model(X_tensor)
+    loss = criterion(y_pred, y_tensor)
+
+    # Backward pass
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    # Print progress every 20 epochs
+    if (epoch + 1) % 20 == 0:
+        print(f"Epoch [{epoch+1}/200] - Loss: {loss.item():.4f}")
+
+# ✅ Final learned parameters
+print("Learned weight:", model.coef_)
+print("Learned bias:", model.intercept_)
+```
+
+---
+
+## 📖 **Documentation & Examples**
+
+Explore the interactive examples:
+
+* [1 - Tensor Basics](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/basics/1-tensor.ipynb)
+* [2 - Regression](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/nn/1-regression.ipynb)
+* [3 - Neural Network Layers](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/basics/2-layers.ipynb)
+
+👉 More examples available in the [examples folder](https://github.com/Mitchell-Mirano/sorix/tree/main/examples).
+
+---
+
+## 🛠️ **Project Status**
+
+sorix is **under active development** 🚧.
+New features are being added frequently, including:
+
+* More neural network layers.
+* Better GPU support.
+* Extended autograd functionality.
+
+You can contribute by:
+
+* Reporting issues
+* Adding new features
+* Improving documentation
+* Writing tests
+
+---
+
+## 📌 **Links**
+
+* [PyPI Package](https://pypi.org/project/sorix/)
+* [GitHub Repository](https://github.com/Mitchell-Mirano/sorix)
+
+---

sorix-1.0.0/README.md

@@ -0,0 +1,136 @@
+
+# **Sorix**
+
+sorix: is a library  of Artificial Intelligence for
+beginners.
+
+![sorix Clustering Image](https://storage.googleapis.com/open-projects-data/allison/training_animation.gif)
+
+It provides a **NumPy/CuPy-based backend** for handling tensors on both **CPU and GPU**, making it ideal for beginners who want to learn how frameworks like PyTorch work internally.
+
+---
+
+## **Install**
+- With pip
+```bash
+pip install sorix
+```
+
+Or with [Poetry](https://python-poetry.org/):
+
+```bash
+poetry add sorix
+```
+
+Or with [UV](https://docs.astral.sh/uv/guides/install-python/)
+```bash
+uv add sorix
+```
+
+---
+
+## ⚡ **Quick Start**
+
+
+### Autograd Example
+
+```python
+from sorix import tensor
+
+# Create tensors with gradient tracking
+x = tensor([2.0], requires_grad=True)
+w = tensor([3.0], requires_grad=True)
+b = tensor([1.0], requires_grad=True)
+
+# Define a simple function: y = w*x + b
+y = w * x + b
+
+# Compute gradients via backpropagation
+y.backward()
+
+print("dy/dx:", x.grad)   # → should be w = 3
+print("dy/dw:", w.grad)   # → should be x = 2
+print("dy/db:", b.grad)   # → should be 1
+```
+---
+
+### 🔢 Linear Regression Example
+
+```python
+import numpy as np
+from sorix import tensor
+from sorix.nn import Linear, MSELoss
+from sorix.optim import SGD
+
+# 🎯 Generate synthetic data (y = 3x + 2 + noise)
+X = np.linspace(-1, 1, 100).reshape(-1, 1)
+y = 3 * X + 2 + 0.1 * np.random.randn(*X.shape)
+
+# Convert to sorix tensors (CPU, use device="cuda" for GPU)
+X_tensor = tensor(X, device="cpu")
+y_tensor = tensor(y, device="cpu")
+
+# Define model, loss, and optimizer
+features, outputs = 1, 1
+model = Linear(features, outputs)
+criterion = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.1)
+
+# 🏋️ Training loop
+for epoch in range(200):
+    # Forward pass
+    y_pred = model(X_tensor)
+    loss = criterion(y_pred, y_tensor)
+
+    # Backward pass
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    # Print progress every 20 epochs
+    if (epoch + 1) % 20 == 0:
+        print(f"Epoch [{epoch+1}/200] - Loss: {loss.item():.4f}")
+
+# ✅ Final learned parameters
+print("Learned weight:", model.coef_)
+print("Learned bias:", model.intercept_)
+```
+
+---
+
+## 📖 **Documentation & Examples**
+
+Explore the interactive examples:
+
+* [1 - Tensor Basics](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/basics/1-tensor.ipynb)
+* [2 - Regression](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/nn/1-regression.ipynb)
+* [3 - Neural Network Layers](https://github.com/Mitchell-Mirano/sorix/blob/main/examples/basics/2-layers.ipynb)
+
+👉 More examples available in the [examples folder](https://github.com/Mitchell-Mirano/sorix/tree/main/examples).
+
+---
+
+## 🛠️ **Project Status**
+
+sorix is **under active development** 🚧.
+New features are being added frequently, including:
+
+* More neural network layers.
+* Better GPU support.
+* Extended autograd functionality.
+
+You can contribute by:
+
+* Reporting issues
+* Adding new features
+* Improving documentation
+* Writing tests
+
+---
+
+## 📌 **Links**
+
+* [PyPI Package](https://pypi.org/project/sorix/)
+* [GitHub Repository](https://github.com/Mitchell-Mirano/sorix)
+
+---

sorix-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "sorix"
+version = "1.0.0"
+description = "A minimalistic framework for building neural networks in Python."
+authors = [
+  {name = "Mitchell Mirano", email = "mitchellmirano25@gmail.com"},
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+   "numpy>=2.0",
+]
+
+[project.optional-dependencies]
+
+# Para CUDA 13.x
+cp13 = [
+    "cupy-cuda13x>=13.0",
+    "numpy>=2.0,<3.0",
+]
+
+[dependency-groups]
+dev = [
+    "joblib>=1.5.2",
+    "jupyter>=1.1.1",
+    "matplotlib>=3.10.6",
+    "seaborn>=0.13.2",
+]

sorix-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sorix-1.0.0/sorix/__init__.py

@@ -0,0 +1,11 @@
+from .tensor.tensor import tensor,no_grad
+from .cuda import cuda
+from .utils.utils import sigmoid,softmax,argmax
+from .utils.utils import (as_tensor,from_numpy,
+                          zeros, ones,full,eye,diag,empty,
+                          arange,linspace, logspace,
+                          rand, randn,randint,randperm,
+                          zeros_like,ones_like,empty_like,full_like,
+                          )
+
+from .utils.math import (sin,cos,tanh,exp,log,sqrt,mean,sum)

sorix-1.0.0/sorix/clustering/__init__.py

@@ -0,0 +1 @@
+from .k_means import Kmeans

sorix-1.0.0/sorix/clustering/k_means.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import pandas as pd
+from typing import Union
+
+
+class Kmeans:
+
+    """K-means algorithm
+
+    Parameters
+    ----------
+    n_centroids : int
+        Number of centroids.
+    """
+
+    def __init__(self, n_centroids:int):
+        self.n_centroids = n_centroids
+        self.centroids = None
+        self.features_names = None
+        self.history_train = {}
+        self.labels = None
+
+    def _data_preprocessing_train(self, 
+                                 features:Union[pd.DataFrame, np.ndarray], 
+                                 history_train:bool) -> np.ndarray:
+        
+        if isinstance(features, pd.DataFrame):
+            self.features_names = features.columns.to_list()
+            
+        features_train = features.to_numpy() if isinstance(features, pd.DataFrame) else features
+
+        self.centroids = features_train[np.random.randint(0, len(features_train), self.n_centroids)]
+        if history_train:
+            self.history_train[0] = self.centroids
+        return features_train
+
+    def _distances(self, features:np.ndarray, centroids:np.ndarray) -> np.ndarray:
+        distances_features_centroides = []
+        for feature in features:
+            distances_feature = []
+            for centroid in centroids:
+                distances_feature.append(np.linalg.norm(centroid - feature))
+            distances_features_centroides.append(distances_feature)
+        return np.array(distances_features_centroides)
+
+    def _new_labels(self, distances:np.ndarray) -> np.ndarray:
+        new_labels = np.array([np.where(distance == np.min(distance))[0][0] for distance in distances])
+        return new_labels
+
+    def _new_centroids(self, features:np.ndarray, labels:np.array) -> np.ndarray:
+
+
+        new_centroids = []
+        for label in set(labels):
+            filter = np.where(labels == label)
+            vectors = features[filter]
+            media_vectors = vectors.sum(axis=0) / len(vectors)
+            new_centroids.append(media_vectors)
+        return np.array(new_centroids)
+
+    def _moviment(self, centroids_before:np.ndarray, centroids_after:np.ndarray) -> float:
+        moviments = []
+        for centroid_bf, centroid_af in zip(centroids_before, centroids_after):
+            moviments.append(np.linalg.norm(centroid_bf - centroid_af))
+        return np.mean(moviments)
+
+    def train(self, 
+              features:Union[pd.DataFrame, np.ndarray], 
+              moviment_limit:float=0.0001,
+              max_iters:int=300,
+              history_train:bool=False) -> None:
+        
+        """
+        Train the k-means algorithm
+        
+        Parameters
+        ----------
+        features : Union[pd.DataFrame, np.ndarray]
+            Features to train.
+        moviment_limit : float, optional
+            Limit of moviment. The default is 0.0001.
+        max_iters : int, optional
+            Maximum iterations. The default is 300.
+        history_train : bool, optional
+            Save history of train. The default is False.
+        """
+        
+        features_train = self._data_preprocessing_train(features, history_train)
+        iters = 0
+        while True:
+            iters += 1
+            distances = self._distances(features_train, self.centroids)
+            self.labels = self._new_labels(distances)
+            centroids_before = self.centroids
+            self.centroids = self._new_centroids(features_train, self.labels)
+            moviment = self._moviment(centroids_before, self.centroids)
+            if history_train:
+                self.history_train[iters] = self.centroids
+                print('Iter: {} \t {} \t moviment: {:.3f}'.format(iters, 50 * '=' + '>', moviment))
+            if moviment < moviment_limit:
+                break
+            if iters > max_iters:
+                break
+
+    def predict(self, features:Union[pd.DataFrame, np.ndarray]) -> np.ndarray:
+
+        """
+        Predict the labels of features
+
+        Parameters
+        ----------
+        features : Union[pd.DataFrame, np.ndarray]
+            Features to predict.
+
+        Returns
+        -------
+        np.ndarray
+            Predicted labels.
+        """
+
+        features = features.to_numpy() if isinstance(features, pd.DataFrame) else features
+
+        distances = self._distances(features, self.centroids)
+        labels = self._new_labels(distances)
+        return labels
+    
+    def get_distances(self, features:Union[pd.DataFrame, np.ndarray]) -> np.ndarray:
+
+        """
+        Get distances between features and centroids
+
+        Parameters
+        ----------
+        features : Union[pd.DataFrame, np.ndarray]
+            Features to predict.
+
+        Returns
+        -------
+        np.ndarray
+            Distances between features and centroids.
+        """
+
+        features = features.to_numpy() if isinstance(features, pd.DataFrame) else features
+
+        return self._distances(features, self.centroids)
+
+    def get_inertia(self, features:Union[pd.DataFrame, np.ndarray]) -> float:
+
+        """
+        Get inertia of features for k-centroids
+
+        Parameters
+        ----------
+        features : Union[pd.DataFrame, np.ndarray]
+            Features to predict.
+
+        Returns
+        -------
+        float
+            Inertia of features.
+        """
+
+        features = features.to_numpy() if isinstance(features, pd.DataFrame) else features
+        distances = self._distances(features, self.centroids)
+        labels = self._new_labels(distances)
+
+        inertia = 0
+        for label in set(labels):
+            filter = np.where(labels == label)
+            vectors = features[filter]
+            inertia += np.sum((vectors - self.centroids[label])**2)
+        return inertia
+    
+
+    def __str__(self):
+        
+        text = f"""
+        model: {self.__class__.__name__} \n
+        n_centroids: {self.n_centroids} \n
+        """
+        return text
+    
+    def __repr__(self):
+        return self.__str__()
+

sorix-1.0.0/sorix/cuda/__init__.py

@@ -0,0 +1 @@
+from .cuda import is_available

sorix-1.0.0/sorix/cuda/cuda.py

@@ -0,0 +1,52 @@
+from sorix.cupy.cupy import _cupy_available
+
+def is_available(verbose: bool = True) -> bool:
+
+
+    if not _cupy_available:
+        if verbose:
+            print("❌ CuPy is not installed.")
+        return False
+
+    import cupy as cp
+    
+    try:
+        n_gpus = cp.cuda.runtime.getDeviceCount()
+        if n_gpus == 0:
+            if verbose:
+                print("❌ No CUDA devices found.")
+            return False
+
+        # Test 1: operación simple en GPU (memoria + aritmética básica)
+        try:
+            _ = int((cp.arange(5) * 2).sum())
+            print("✅ GPU basic operation passed")
+        except Exception as e:
+            if verbose:
+                print("❌ GPU basic operation failed:", e)
+            return False
+
+        # Test 2: operación que fuerza cuBLAS (matmul)
+        try:
+            A = cp.random.rand(4, 4)
+            B = cp.random.rand(4, 4)
+            _ = int((A @ B).sum())  # fuerza cuBLAS
+        except Exception as e:
+            if verbose:
+                print("❌ cuBLAS/linear algebra operation failed:", e)
+            return False
+
+        if verbose:
+            props = cp.cuda.runtime.getDeviceProperties(0)
+            print(f"✅ GPU available: {props['name'].decode('utf-8')}")
+            print(f"CUDA runtime version: {cp.cuda.runtime.runtimeGetVersion()}")
+            print(f"CuPy version: {cp.__version__}")
+
+        return True
+
+    except Exception as e:
+        if verbose:
+            print("❌ Error while checking CuPy/CUDA:", e)
+        return False
+
+

sorix-1.0.0/sorix/cupy/cupy.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+
+try:
+    import cupy as cp
+    _cupy_available = True
+except:
+    _cupy_available = False

sorix-1.0.0/sorix/datasets/__init__.py

@@ -0,0 +1,3 @@
+from .dataset import Dataset
+from .dataloader import DataLoader
+from .train_test import train_test_split

sorix-1.0.0/sorix/datasets/dataloader.py

@@ -0,0 +1,17 @@
+class DataLoader:
+    def __init__(self, dataset, batch_size=16):
+        self.dataset = dataset
+        self.batch_size = batch_size
+
+    def __iter__(self):
+
+        for i in range(0, len(self.dataset), self.batch_size):
+            yield self.dataset[i:i+self.batch_size]
+
+    def __len__(self):
+
+        ln = len(self.dataset) // self.batch_size
+        if len(self.dataset) % self.batch_size != 0:
+            ln += 1
+        return ln
+    

sorix-1.0.0/sorix/datasets/dataset.py

@@ -0,0 +1,21 @@
+class Dataset:
+    def __init__(self, X, y):
+        self.X = X
+        self.y = y
+
+    def __len__(self):
+        return len(self.X)
+
+    def __getitem__(self, idx):
+
+        return self.X[idx], self.y[idx]
+
+    def __setitem__(self, idx, value):
+        self.X[idx], self.y[idx] = value
+
+
+    def __str__(self):
+        return f"Dataset(\nX=\n{self.X}, y={self.y})"
+
+    def __repr__(self):
+        return self.__str__()