openarchx 0.1.0__py3-none-any.whl

openarchx/utils/transforms.py

@@ -0,0 +1,259 @@
+import numpy as np
+from ..core.tensor import Tensor
+
+
+class Transform:
+    """Base class for all transforms."""
+    
+    def __call__(self, x):
+        """Apply the transform to input x."""
+        raise NotImplementedError("Transform must implement __call__ method")
+    
+
+class Compose:
+    """Composes several transforms together."""
+    
+    def __init__(self, transforms):
+        """
+        Args:
+            transforms (list): List of transforms to compose.
+        """
+        self.transforms = transforms
+        
+    def __call__(self, x):
+        """Apply all transforms sequentially."""
+        for t in self.transforms:
+            x = t(x)
+        return x
+
+
+class ToTensor:
+    """Convert a numpy.ndarray to OpenArchX Tensor."""
+    
+    def __call__(self, x):
+        """
+        Args:
+            x: NumPy array or list to be converted to tensor.
+        Returns:
+            OpenArchX Tensor.
+        """
+        if isinstance(x, Tensor):
+            return x
+        if not isinstance(x, np.ndarray):
+            x = np.array(x, dtype=np.float32)
+        return Tensor(x)
+
+
+class Normalize:
+    """Normalize a tensor with mean and standard deviation."""
+    
+    def __init__(self, mean, std):
+        """
+        Args:
+            mean: Mean value for each channel/feature.
+            std: Standard deviation for each channel/feature.
+        """
+        self.mean = np.array(mean, dtype=np.float32)
+        self.std = np.array(std, dtype=np.float32)
+        
+    def __call__(self, x):
+        """
+        Args:
+            x: Tensor to be normalized.
+        Returns:
+            Normalized Tensor.
+        """
+        if isinstance(x, Tensor):
+            return Tensor((x.data - self.mean) / self.std)
+        return (x - self.mean) / self.std
+
+
+class RandomCrop:
+    """Crop randomly the image in a sample."""
+    
+    def __init__(self, output_size):
+        """
+        Args:
+            output_size (tuple or int): Desired output size. If int, square crop is made.
+        """
+        if isinstance(output_size, int):
+            self.output_size = (output_size, output_size)
+        else:
+            self.output_size = output_size
+        
+    def __call__(self, x):
+        """
+        Args:
+            x: Image to be cropped.
+        Returns:
+            Cropped image.
+        """
+        h, w = x.shape[-2:]
+        new_h, new_w = self.output_size
+        
+        top = np.random.randint(0, h - new_h + 1)
+        left = np.random.randint(0, w - new_w + 1)
+        
+        if isinstance(x, Tensor):
+            x_data = x.data
+            if len(x_data.shape) == 2:
+                x_data = x_data[top:top + new_h, left:left + new_w]
+            elif len(x_data.shape) == 3:
+                x_data = x_data[:, top:top + new_h, left:left + new_w]
+            else:
+                x_data = x_data[..., top:top + new_h, left:left + new_w]
+            return Tensor(x_data)
+        else:
+            if len(x.shape) == 2:
+                return x[top:top + new_h, left:left + new_w]
+            elif len(x.shape) == 3:
+                return x[:, top:top + new_h, left:left + new_w]
+            else:
+                return x[..., top:top + new_h, left:left + new_w]
+
+
+class RandomHorizontalFlip:
+    """Randomly flip the image horizontally."""
+    
+    def __init__(self, p=0.5):
+        """
+        Args:
+            p (float): Probability of flipping.
+        """
+        self.p = p
+        
+    def __call__(self, x):
+        """
+        Args:
+            x: Image to be flipped.
+        Returns:
+            Flipped image with probability p.
+        """
+        if np.random.random() < self.p:
+            if isinstance(x, Tensor):
+                # Handle the last dimension for channels first or last
+                if len(x.data.shape) == 3:  # Assume channels-first (C, H, W)
+                    return Tensor(x.data[:, :, ::-1])
+                elif len(x.data.shape) == 2:  # No channels
+                    return Tensor(x.data[:, ::-1])
+                else:  # Batch images or other dimensions
+                    return Tensor(np.flip(x.data, axis=-1))
+            else:
+                # Handle the last dimension for channels first or last
+                if len(x.shape) == 3:  # Assume channels-first (C, H, W)
+                    return x[:, :, ::-1]
+                elif len(x.shape) == 2:  # No channels
+                    return x[:, ::-1]
+                else:  # Batch images or other dimensions
+                    return np.flip(x, axis=-1)
+        return x
+
+
+class Resize:
+    """Resize the image to a given size."""
+    
+    def __init__(self, output_size):
+        """
+        Args:
+            output_size (tuple or int): Desired output size. If int, square resize is made.
+        """
+        if isinstance(output_size, int):
+            self.output_size = (output_size, output_size)
+        else:
+            self.output_size = output_size
+            
+    def __call__(self, x):
+        """
+        Args:
+            x: Image to be resized.
+        Returns:
+            Resized image.
+        """
+        # Check if scipy is available for resize
+        try:
+            from scipy.ndimage import zoom
+        except ImportError:
+            raise ImportError("SciPy is required for resize. Please install it with 'pip install scipy'")
+            
+        new_h, new_w = self.output_size
+        
+        if isinstance(x, Tensor):
+            x_data = x.data
+            if len(x_data.shape) == 2:  # (H, W)
+                h, w = x_data.shape
+                zoom_h, zoom_w = new_h / h, new_w / w
+                return Tensor(zoom(x_data, (zoom_h, zoom_w)))
+            elif len(x_data.shape) == 3:  # (C, H, W)
+                c, h, w = x_data.shape
+                zoom_h, zoom_w = new_h / h, new_w / w
+                return Tensor(zoom(x_data, (1, zoom_h, zoom_w)))
+            else:  # Batch or other dimensions
+                raise ValueError("Unsupported tensor shape for resize")
+        else:
+            if len(x.shape) == 2:  # (H, W)
+                h, w = x.shape
+                zoom_h, zoom_w = new_h / h, new_w / w
+                return zoom(x, (zoom_h, zoom_w))
+            elif len(x.shape) == 3:  # (C, H, W)
+                c, h, w = x.shape
+                zoom_h, zoom_w = new_h / h, new_w / w
+                return zoom(x, (1, zoom_h, zoom_w))
+            else:  # Batch or other dimensions
+                raise ValueError("Unsupported array shape for resize")
+
+
+class TorchTransformAdapter:
+    """Adapter for using PyTorch transforms with OpenArchX."""
+    
+    def __init__(self, torch_transform):
+        """
+        Args:
+            torch_transform: A PyTorch transform or composition of transforms.
+        """
+        import importlib.util
+        if importlib.util.find_spec("torch") is None:
+            raise ImportError("PyTorch is required for this adapter. Please install it with 'pip install torch'")
+            
+        import torch
+        self.torch_transform = torch_transform
+        
+    def __call__(self, x):
+        """
+        Args:
+            x: Input data to transform.
+        Returns:
+            Transformed data as OpenArchX Tensor.
+        """
+        import torch
+        import numpy as np
+        
+        # Convert to torch tensor if needed
+        if isinstance(x, np.ndarray):
+            x_torch = torch.from_numpy(x)
+        elif isinstance(x, Tensor):
+            x_torch = torch.from_numpy(x.data)
+        else:
+            x_torch = x
+            
+        # Apply torch transform
+        result = self.torch_transform(x_torch)
+        
+        # Convert back to numpy/Tensor
+        if isinstance(result, torch.Tensor):
+            result = result.numpy()
+            
+        return Tensor(result) if not isinstance(x, Tensor) else result
+
+
+class TransformFactory:
+    """Factory for creating transforms from various sources."""
+    
+    @staticmethod
+    def from_torch(torch_transform):
+        """Create a transform from a PyTorch transform."""
+        return TorchTransformAdapter(torch_transform)
+    
+    @staticmethod
+    def compose(transforms):
+        """Create a composition of transforms."""
+        return Compose(transforms) 

openarchx-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,43 @@
+openarchx/__init__.py,sha256=pG8ssyLIjKFRsA8W0pDJvgCm0HI2kGSi22CaT21g2kI,205
+openarchx/core/tensor.py,sha256=NS2-KZQudUPksg0ZKbwrybyt9OedpO7w_FwfTkbpz-c,6894
+openarchx/cuda/__init__.py,sha256=J8aKj9Jxch7yaI0p12GkzkbAeIAWK5pPTmkLQF_1BQI,725
+openarchx/cuda/cuda_ops.py,sha256=N7tzwYH4Va2J-W0ehUeCkcY2BdQC2xlze_fnQqD4NA8,10617
+openarchx/layers/activations.py,sha256=sqdFKSRCsLGgOjtRbB2qpUWB2pIFQPHPqJ1RoWHMrDk,1930
+openarchx/layers/base.py,sha256=TUFn3hgRKvi6aib66i2rwOf_SHozE-ycvFSBIPe2X94,1292
+openarchx/layers/cnn.py,sha256=qWwUiSMaQdFgyTOCwVKqN_IrGxBSex4_Py3IWChj8PY,6060
+openarchx/layers/transformer.py,sha256=l_MonyVYRmJIKfcdYaBMmh5PfmfsbPx8-pacgE7AswQ,5617
+openarchx/nn/__init__.py,sha256=6nm-YuCydqUInkDV8ub22wBhy1iB85AMEKeIwIFRWGY,572
+openarchx/nn/activations.py,sha256=68FLmEQRb6ue7Ij24aLa-WMxHjvdOxsJm5-QtYcwR64,4758
+openarchx/nn/containers.py,sha256=PdAPUbXN8U7ynDJQx6Rrjdykpn0RUZlMUsP9O5IO_9c,4756
+openarchx/nn/dropout.py,sha256=HAqQxiv3ETc0mY1cp1pwTKj6_G4AK8caJj7kGetnn1o,4121
+openarchx/nn/layers.py,sha256=mBGJwDFEQQ4QX2xzPLqT2MaZ66g0CtxAiPGJ1hloFVg,13870
+openarchx/nn/losses.py,sha256=_ijSBLiJwsx9hW3PMTkxE2AayvnIwISJKSAjEy0qnhI,5877
+openarchx/nn/module.py,sha256=B4vj8DxwyevL7xdGgoUQIbUxuPMxom_TfHWVLJ1avZk,583
+openarchx/nn/padding.py,sha256=AlfNE3KaYvy_AhU2C5Ri_iFFp23Mvh-CKY-ZbdxoMHI,4845
+openarchx/nn/pooling.py,sha256=FOyub46ZH31Rf6fPRvYzK_8U-EBgGksN_As0ZD9xhBw,14068
+openarchx/nn/rnn.py,sha256=_vMxzB4Dj03bXmYn84cms8Oq3h4ZHP2r2AWcGVk-JDg,9040
+openarchx/nn/transformers.py,sha256=0AyNqsTIWy56f7-QuE5rEmBEa4bTJ9PHUfoChOefKJQ,7914
+openarchx/optimizers/adam.py,sha256=DBtTUtHFMxkWm2eM2mcwGgEGqKtvV84PeCmtobIxBao,1861
+openarchx/optimizers/adaptive.py,sha256=MxMJ1WXk6tDk9PFpiuy28qfIpSZYtHcSQ2p6re80FVw,2780
+openarchx/optimizers/base.py,sha256=5O9hDPs5U2P9-69VDMeHw5WgMvsiVjj1TBRII8itX0o,750
+openarchx/optimizers/modern.py,sha256=pJnQnUsGdN6nyyeyglEqkkyO06XKSU89LhK4KTx_oks,4151
+openarchx/optimizers/optx.py,sha256=969dFa642fCYKtBFg-kuYwS_D_RudDomWwr0Agv5Jwc,3923
+openarchx/optimizers/sgd.py,sha256=sYdlx-nmPY8Alsj55GGd5Xz44JBtYrEg2iWbp1z3v-0,2585
+openarchx/quantum/circuit.py,sha256=gPrk-tSxeff6oHnv6k6mFycWK2daNpndAvejzG2l-H8,3203
+openarchx/quantum/gates.py,sha256=zR788dMYGdZKNKSqSENzlga_--K7MPzNFjHfY7h__IM,4626
+openarchx/utils/__init__.py,sha256=oSli5jb-kVAmrmLfxgj_hYv2GVeex9Bj5hAVDhh3l_c,1912
+openarchx/utils/data.py,sha256=YFok4Nappy9faAAyDNy-gTfIjtyG3_7dStQAiadF3Nc,8396
+openarchx/utils/huggingface.py,sha256=udNu7Sosixb3ld5TIVIINKPsyS1jf6Gm88k6lzz_OnY,11308
+openarchx/utils/losses.py,sha256=fgD4AFVauPC2HrvZjKoU6rx7tBDGawDw-8Ry1xK0mvI,723
+openarchx/utils/model_io.py,sha256=otQcOy39X6lWCEYw1cX-1iGlAiNmrGm0dMpxoMOTISU,18571
+openarchx/utils/pytorch.py,sha256=VCEDRGM3zEfB994plVfAhnaeGZHvNegISDs9qzq4kTA,17331
+openarchx/utils/tensorflow.py,sha256=T-h1Ttou2O1GnJJgt3ZvZ1MK-7o-ybT_35aus0MSXd8,18299
+openarchx/utils/transforms.py,sha256=6tS6tmvQI5e6G771tI3ttInB7lT1j9suKssfnyXxJCM,8445
+openarchx-0.1.0.dist-info/licenses/LICENSE,sha256=Ak-g7e8LDd8BKNcKnt6YQAWPtE9btoDNGzsT-qYMNCY,1085
+tests/__init__.py,sha256=bHuq05M3ZLXz8wZz33PzuPHIQPdse4SzXrgeajei3Hc,26
+tests/test_cuda_ops.py,sha256=aPzFnVbUp7uXUc7N1f_DG0-W9mrewORxEHnGMwKXLfo,6747
+tests/test_integrations.py,sha256=C0p5RyGG5DtjtsW1wba-4j431k2PyKex7zE4g-TLwZE,8538
+openarchx-0.1.0.dist-info/METADATA,sha256=hVE2lx18fL_6TXZneTA_9N7CN6oG8cw0JdTookK6hQA,5124
+openarchx-0.1.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+openarchx-0.1.0.dist-info/top_level.txt,sha256=ZqkjpbZbSLXTIzjIzJH3vjMMUC92lw8573qJ6cdzEiE,16
+openarchx-0.1.0.dist-info/RECORD,,

openarchx-0.1.0.dist-info/WHEEL

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

openarchx-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+openarchx
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# OpenArchX Tests Package