openarchx 0.1.0__tar.gz

openarchx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 OpenArchX
+
+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.

openarchx-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include MANIFEST.in
+recursive-include examples *.py
+recursive-include examples *.md 

openarchx-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: openarchx
+Version: 0.1.0
+Summary: A lightweight and extensible deep learning framework with native model serialization
+Home-page: https://github.com/openarchx/openarchx
+Author: OpenArchX Team
+Author-email: OpenArchX Team <info@openarchx.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/openarchx/openarchx
+Project-URL: Bug Tracker, https://github.com/openarchx/openarchx/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Provides-Extra: pytorch
+Requires-Dist: torch>=1.7.0; extra == "pytorch"
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow>=2.4.0; extra == "tensorflow"
+Provides-Extra: huggingface
+Requires-Dist: transformers>=4.0.0; extra == "huggingface"
+Requires-Dist: datasets>=1.0.0; extra == "huggingface"
+Provides-Extra: all
+Requires-Dist: torch>=1.7.0; extra == "all"
+Requires-Dist: tensorflow>=2.4.0; extra == "all"
+Requires-Dist: transformers>=4.0.0; extra == "all"
+Requires-Dist: datasets>=1.0.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# OpenArchX
+
+[![PyPI version](https://badge.fury.io/py/openarchx.svg)](https://badge.fury.io/py/openarchx)
+[![GitHub license](https://img.shields.io/github/license/openarchx/openarchx)](https://github.com/openarchx/openarchx/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/openarchx.svg)](https://pypi.org/project/openarchx/)
+
+A lightweight and extensible deep learning framework in pure Python with native model serialization support.
+
+## Features
+
+- Simple and clean API inspired by modern deep learning frameworks
+- Native `.oaxm` model serialization format
+- Seamless integration with PyTorch, TensorFlow, and Hugging Face
+- Framework-agnostic design for maximum flexibility
+- Pure Python implementation with minimal dependencies
+
+## Installation
+
+### Basic Installation
+
+```bash
+pip install openarchx
+```
+
+### With Framework Integration Support
+
+```bash
+# For PyTorch integration
+pip install openarchx[pytorch]
+
+# For TensorFlow integration
+pip install openarchx[tensorflow]
+
+# For Hugging Face integration
+pip install openarchx[huggingface]
+
+# For all integrations
+pip install openarchx[all]
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import openarchx as ox
+from openarchx.nn import Sequential, Dense, ReLU
+from openarchx.core import Tensor
+from openarchx.utils import save_model, load_model
+
+# Create a model
+model = Sequential([
+    Dense(10, input_dim=5),
+    ReLU(),
+    Dense(1)
+])
+
+# Generate dummy data
+X = np.random.randn(100, 5).astype(np.float32)
+y = np.sum(X * np.array([0.2, 0.5, -0.3, 0.7, -0.1]), axis=1, keepdims=True)
+X, y = Tensor(X), Tensor(y)
+
+# Train the model
+optimizer = ox.optim.SGD(model.parameters(), learning_rate=0.01)
+loss_fn = ox.losses.MSELoss()
+
+for epoch in range(10):
+    # Forward pass
+    y_pred = model(X)
+    loss = loss_fn(y_pred, y)
+    
+    # Backward pass
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    
+    print(f"Epoch {epoch}: Loss = {loss.data}")
+
+# Save the model to .oaxm format
+save_model(model, "my_model.oaxm")
+
+# Load the model
+loaded_model = load_model("my_model.oaxm", model_class=Sequential)
+```
+
+## Model Serialization with .oaxm
+
+OpenArchX provides a native model serialization format called `.oaxm` (OpenArchX Model):
+
+```python
+# Save a model with metadata
+metadata = {
+    "description": "My trained model",
+    "version": "1.0.0",
+    "author": "Your Name"
+}
+save_model(model, "model.oaxm", metadata=metadata)
+
+# Convert from PyTorch
+from openarchx.utils import convert_from_pytorch
+convert_from_pytorch(torch_model, "converted_model.oaxm")
+
+# Convert from TensorFlow
+from openarchx.utils import convert_from_tensorflow
+convert_from_tensorflow(tf_model, "converted_model.oaxm")
+```
+
+## Framework Integration
+
+### PyTorch Integration
+
+```python
+import torch
+import torch.nn as nn
+from openarchx.utils import get_pytorch_model_adapter
+
+# Convert PyTorch model to OpenArchX
+pt_model = nn.Sequential(
+    nn.Linear(10, 5),
+    nn.ReLU(),
+    nn.Linear(5, 1)
+)
+
+# Create an adapter to use the PyTorch model in OpenArchX
+adapted_model = get_pytorch_model_adapter(pt_model)
+output = adapted_model(Tensor(np.random.randn(1, 10)))
+```
+
+### TensorFlow Integration
+
+```python
+import tensorflow as tf
+from openarchx.utils import get_tensorflow_model_adapter
+
+# Use TensorFlow model in OpenArchX
+tf_model = tf.keras.Sequential([
+    tf.keras.layers.Dense(5, activation='relu', input_shape=(10,)),
+    tf.keras.layers.Dense(1)
+])
+
+# Create an adapter to use the TensorFlow model in OpenArchX
+adapted_model = get_tensorflow_model_adapter(tf_model)
+output = adapted_model(Tensor(np.random.randn(1, 10)))
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

openarchx-0.1.0/README.md

@@ -0,0 +1,147 @@
+# OpenArchX
+
+[![PyPI version](https://badge.fury.io/py/openarchx.svg)](https://badge.fury.io/py/openarchx)
+[![GitHub license](https://img.shields.io/github/license/openarchx/openarchx)](https://github.com/openarchx/openarchx/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/openarchx.svg)](https://pypi.org/project/openarchx/)
+
+A lightweight and extensible deep learning framework in pure Python with native model serialization support.
+
+## Features
+
+- Simple and clean API inspired by modern deep learning frameworks
+- Native `.oaxm` model serialization format
+- Seamless integration with PyTorch, TensorFlow, and Hugging Face
+- Framework-agnostic design for maximum flexibility
+- Pure Python implementation with minimal dependencies
+
+## Installation
+
+### Basic Installation
+
+```bash
+pip install openarchx
+```
+
+### With Framework Integration Support
+
+```bash
+# For PyTorch integration
+pip install openarchx[pytorch]
+
+# For TensorFlow integration
+pip install openarchx[tensorflow]
+
+# For Hugging Face integration
+pip install openarchx[huggingface]
+
+# For all integrations
+pip install openarchx[all]
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import openarchx as ox
+from openarchx.nn import Sequential, Dense, ReLU
+from openarchx.core import Tensor
+from openarchx.utils import save_model, load_model
+
+# Create a model
+model = Sequential([
+    Dense(10, input_dim=5),
+    ReLU(),
+    Dense(1)
+])
+
+# Generate dummy data
+X = np.random.randn(100, 5).astype(np.float32)
+y = np.sum(X * np.array([0.2, 0.5, -0.3, 0.7, -0.1]), axis=1, keepdims=True)
+X, y = Tensor(X), Tensor(y)
+
+# Train the model
+optimizer = ox.optim.SGD(model.parameters(), learning_rate=0.01)
+loss_fn = ox.losses.MSELoss()
+
+for epoch in range(10):
+    # Forward pass
+    y_pred = model(X)
+    loss = loss_fn(y_pred, y)
+    
+    # Backward pass
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    
+    print(f"Epoch {epoch}: Loss = {loss.data}")
+
+# Save the model to .oaxm format
+save_model(model, "my_model.oaxm")
+
+# Load the model
+loaded_model = load_model("my_model.oaxm", model_class=Sequential)
+```
+
+## Model Serialization with .oaxm
+
+OpenArchX provides a native model serialization format called `.oaxm` (OpenArchX Model):
+
+```python
+# Save a model with metadata
+metadata = {
+    "description": "My trained model",
+    "version": "1.0.0",
+    "author": "Your Name"
+}
+save_model(model, "model.oaxm", metadata=metadata)
+
+# Convert from PyTorch
+from openarchx.utils import convert_from_pytorch
+convert_from_pytorch(torch_model, "converted_model.oaxm")
+
+# Convert from TensorFlow
+from openarchx.utils import convert_from_tensorflow
+convert_from_tensorflow(tf_model, "converted_model.oaxm")
+```
+
+## Framework Integration
+
+### PyTorch Integration
+
+```python
+import torch
+import torch.nn as nn
+from openarchx.utils import get_pytorch_model_adapter
+
+# Convert PyTorch model to OpenArchX
+pt_model = nn.Sequential(
+    nn.Linear(10, 5),
+    nn.ReLU(),
+    nn.Linear(5, 1)
+)
+
+# Create an adapter to use the PyTorch model in OpenArchX
+adapted_model = get_pytorch_model_adapter(pt_model)
+output = adapted_model(Tensor(np.random.randn(1, 10)))
+```
+
+### TensorFlow Integration
+
+```python
+import tensorflow as tf
+from openarchx.utils import get_tensorflow_model_adapter
+
+# Use TensorFlow model in OpenArchX
+tf_model = tf.keras.Sequential([
+    tf.keras.layers.Dense(5, activation='relu', input_shape=(10,)),
+    tf.keras.layers.Dense(1)
+])
+
+# Create an adapter to use the TensorFlow model in OpenArchX
+adapted_model = get_tensorflow_model_adapter(tf_model)
+output = adapted_model(Tensor(np.random.randn(1, 10)))
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

openarchx-0.1.0/examples/core_test.py

@@ -0,0 +1,147 @@
+import numpy as np
+import traceback
+import sys
+from openarchx.core.tensor import Tensor
+from openarchx.nn.module import Module
+from openarchx.layers.cnn import Conv2d, MaxPool2d
+from openarchx.layers.base import Linear
+from openarchx.optimizers.adam import Adam
+from openarchx.layers.activations import relu
+
+def print_separator():
+    print("\n" + "="*50 + "\n")
+
+def softmax(x):
+    """Stable softmax implementation"""
+    if isinstance(x, Tensor):
+        x = x.data
+    x = x - np.max(x, axis=1, keepdims=True)  # For numerical stability
+    exp_x = np.exp(x)
+    return exp_x / exp_x.sum(axis=1, keepdims=True)
+
+def cross_entropy_loss(pred, target):
+    """Stable cross entropy loss calculation"""
+    if isinstance(pred, Tensor):
+        pred = pred.data
+    if isinstance(target, Tensor):
+        target = target.data
+    
+    epsilon = 1e-7
+    pred_clipped = np.clip(pred, epsilon, 1 - epsilon)
+    return -np.mean(np.sum(target * np.log(pred_clipped), axis=1))
+
+def test_tensor_ops():
+    print_separator()
+    print("Testing basic tensor operations...")
+    
+    try:
+        # Test creation and basic ops
+        a = Tensor(np.array([[1, 2], [3, 4]]), requires_grad=True)
+        b = Tensor(np.array([[5, 6], [7, 8]]), requires_grad=True)
+        
+        print("Addition:")
+        c = a + b
+        print(c.data)
+        
+        print("\nMatrix multiplication:")
+        d = a @ b
+        print(d.data)
+        
+        print("\nReshape and transpose:")
+        e = a.reshape(4)
+        print(f"Reshaped: {e.data}")
+        f = a.transpose(1, 0)
+        print(f"Transposed: {f.data}")
+        
+        print("\nTensor operations test passed!")
+    except Exception as e:
+        print(f"Tensor operations error: {e}")
+        traceback.print_exc()
+
+def test_conv_layer():
+    print_separator()
+    print("Testing convolution layer...")
+    
+    try:
+        # Create small input
+        x = np.random.randn(2, 3, 4, 4)  # [batch_size, channels, height, width]
+        x_tensor = Tensor(x)
+        
+        # Create conv layer
+        conv = Conv2d(in_channels=3, out_channels=2, kernel_size=3, padding=1)
+        
+        # Forward pass
+        out = conv(x_tensor)
+        print(f"Conv2d input shape: {x.shape}")
+        print(f"Conv2d output shape: {out.data.shape}")
+        print("\nConvolution layer test passed!")
+        
+    except Exception as e:
+        print(f"Conv2d error: {e}")
+        traceback.print_exc()
+
+class SimpleNet(Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = Conv2d(1, 4, kernel_size=3, padding=1)
+        self.fc1 = Linear(64, 10)  # Fixed: 4 * 4 * 4 = 64 input features
+    
+    def forward(self, x):
+        x = relu(self.conv1(x))
+        batch_size = x.data.shape[0]
+        x = x.reshape(batch_size, -1)  # Flatten conv output
+        x = self.fc1(x)
+        probs = softmax(x)  # Apply softmax to logits
+        return Tensor(probs, requires_grad=True)
+
+def test_small_network():
+    print_separator()
+    print("Testing small network...")
+    
+    try:
+        # Create small input
+        np.random.seed(42)  # For reproducibility
+        x = np.random.randn(2, 1, 4, 4)  # [batch_size, channels, height, width]
+        y = np.zeros((2, 10))  # One-hot encoded targets
+        y[:, 0] = 1  # Set first class as target
+        
+        # Create model and optimizer
+        model = SimpleNet()
+        optimizer = Adam(model.parameters(), lr=0.01)
+        
+        # Training step
+        x_tensor = Tensor(x)
+        y_tensor = Tensor(y)
+        
+        print(f"Input shape: {x.shape}")
+        
+        # Forward pass
+        pred = model(x_tensor)
+        print(f"Output shape: {pred.data.shape}")
+        
+        # Calculate loss
+        loss = cross_entropy_loss(pred, y_tensor)
+        print(f"Initial loss: {loss:.4f}")
+        
+        # Backward pass
+        loss_tensor = Tensor(np.array(loss), requires_grad=True)
+        optimizer.zero_grad()
+        loss_tensor.backward()
+        optimizer.step()
+        
+        # Another forward pass to check if loss decreased
+        pred = model(x_tensor)
+        new_loss = cross_entropy_loss(pred, y_tensor)
+        print(f"Loss after one step: {new_loss:.4f}")
+        print("\nNetwork training test passed!")
+        
+    except Exception as e:
+        print(f"Training error: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    print("Starting core functionality tests...")
+    test_tensor_ops()
+    test_conv_layer()
+    test_small_network()
+    print("\nTests completed!")

openarchx-0.1.0/examples/cuda_test.py

@@ -0,0 +1,61 @@
+from openarchx.core.tensor import Tensor
+import numpy as np
+import time
+
+def benchmark_matmul(size=1000, device='cpu'):
+    """Benchmark matrix multiplication on CPU vs GPU"""
+    # Create random matrices
+    a = np.random.randn(size, size).astype(np.float32)
+    b = np.random.randn(size, size).astype(np.float32)
+    
+    # Convert to tensors
+    ta = Tensor(a, device=device)
+    tb = Tensor(b, device=device)
+    
+    # Warmup
+    _ = ta @ tb
+    
+    # Benchmark
+    start = time.time()
+    for _ in range(10):
+        c = ta @ tb
+    end = time.time()
+    
+    return (end - start) / 10
+
+def test_cuda_ops():
+    """Test basic CUDA operations"""
+    try:
+        # Test tensor creation and device movement
+        a = Tensor(np.array([[1, 2], [3, 4]]), device='cuda')
+        b = Tensor(np.array([[5, 6], [7, 8]]), device='cuda')
+        
+        print("CUDA Tensor Operations Test:")
+        print("----------------------------")
+        
+        # Test addition
+        c = a + b
+        print(f"Addition result:\n{c}")
+        
+        # Test matrix multiplication
+        d = a @ b
+        print(f"\nMatrix multiplication result:\n{d}")
+        
+        # Test element-wise multiplication
+        e = a * b
+        print(f"\nElement-wise multiplication result:\n{e}")
+        
+        # Benchmark large matrix multiplication
+        print("\nBenchmarking matrix multiplication:")
+        cpu_time = benchmark_matmul(size=1000, device='cpu')
+        gpu_time = benchmark_matmul(size=1000, device='cuda')
+        
+        print(f"CPU average time: {cpu_time:.4f} seconds")
+        print(f"GPU average time: {gpu_time:.4f} seconds")
+        print(f"Speedup: {cpu_time/gpu_time:.2f}x")
+        
+    except Exception as e:
+        print(f"Error during CUDA test: {str(e)}")
+
+if __name__ == "__main__":
+    test_cuda_ops()