openarchx 0.1.0__py3-none-any.whl

openarchx/quantum/gates.py

@@ -0,0 +1,126 @@
+import numpy as np
+from ..core.tensor import Tensor
+
+# Basic quantum gates as numpy arrays
+class QuantumGates:
+    @staticmethod
+    def I():
+        return np.array([[1, 0], [0, 1]], dtype=complex)
+    
+    @staticmethod
+    def X():
+        return np.array([[0, 1], [1, 0]], dtype=complex)
+    
+    @staticmethod
+    def Y():
+        return np.array([[0, -1j], [1j, 0]], dtype=complex)
+    
+    @staticmethod
+    def Z():
+        return np.array([[1, 0], [0, -1]], dtype=complex)
+    
+    @staticmethod
+    def H():
+        return np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
+    
+    @staticmethod
+    def CNOT():
+        return np.array([[1, 0, 0, 0],
+                        [0, 1, 0, 0],
+                        [0, 0, 0, 1],
+                        [0, 0, 1, 0]], dtype=complex)
+    
+    @staticmethod
+    def RX(theta):
+        return np.array([[np.cos(theta/2), -1j*np.sin(theta/2)],
+                        [-1j*np.sin(theta/2), np.cos(theta/2)]], dtype=complex)
+    
+    @staticmethod
+    def RY(theta):
+        return np.array([[np.cos(theta/2), -np.sin(theta/2)],
+                        [np.sin(theta/2), np.cos(theta/2)]], dtype=complex)
+    
+    @staticmethod
+    def RZ(theta):
+        return np.array([[np.exp(-1j*theta/2), 0],
+                        [0, np.exp(1j*theta/2)]], dtype=complex)
+
+class QuantumRegister:
+    def __init__(self, num_qubits):
+        self.num_qubits = num_qubits
+        # Initialize to |0>^⊗n state
+        self.state = np.zeros(2**num_qubits, dtype=complex)
+        self.state[0] = 1.0
+    
+    def apply_gate(self, gate, target_qubit):
+        """Apply a single-qubit gate to the specified target qubit"""
+        n = self.num_qubits
+        
+        # Create the full operator using tensor products
+        op = np.array([[1]])
+        for i in range(n):
+            if i == target_qubit:
+                op = np.kron(op, gate)
+            else:
+                op = np.kron(op, QuantumGates.I())
+        
+        self.state = op @ self.state
+    
+    def apply_controlled_gate(self, gate, control_qubit, target_qubit):
+        """Apply a controlled gate with specified control and target qubits"""
+        if abs(control_qubit - target_qubit) == 1:
+            # Adjacent qubits can use the gate directly
+            n = self.num_qubits
+            op = np.array([[1]])
+            for i in range(n):
+                if i == min(control_qubit, target_qubit):
+                    op = np.kron(op, gate)
+                    i += 1  # Skip next qubit as it's part of the controlled operation
+                else:
+                    op = np.kron(op, QuantumGates.I())
+        else:
+            # Non-adjacent qubits need swap operations
+            # This is a simplified implementation
+            op = self._create_non_adjacent_controlled_op(gate, control_qubit, target_qubit)
+        
+        self.state = op @ self.state
+    
+    def measure(self, qubit=None):
+        """Measure the specified qubit or the whole register"""
+        if qubit is None:
+            # Measure all qubits
+            probs = np.abs(self.state) ** 2
+            result = np.random.choice(len(self.state), p=probs)
+            self.state = np.zeros_like(self.state)
+            self.state[result] = 1.0
+            return bin(result)[2:].zfill(self.num_qubits)
+        else:
+            # Measure single qubit
+            # Project and renormalize the state
+            raise NotImplementedError("Single qubit measurement not implemented yet")
+    
+    def _create_non_adjacent_controlled_op(self, gate, control, target):
+        """Helper method to create controlled operations between non-adjacent qubits"""
+        # This is a simplified implementation
+        n = self.num_qubits
+        dim = 2**n
+        op = np.eye(dim, dtype=complex)
+        
+        # Create the controlled operation
+        ctrl_mask = 1 << control
+        target_mask = 1 << target
+        
+        for i in range(dim):
+            if i & ctrl_mask:  # If control qubit is 1
+                # Apply gate to target qubit
+                i_target_0 = i & ~target_mask  # Target bit set to 0
+                i_target_1 = i | target_mask   # Target bit set to 1
+                
+                if i & target_mask == 0:  # Target is 0
+                    op[i, i] = gate[0, 0]
+                    op[i, i_target_1] = gate[0, 1]
+                else:  # Target is 1
+                    op[i, i_target_0] = gate[1, 0]
+                    op[i, i] = gate[1, 1]
+        
+        return op

openarchx/utils/__init__.py

@@ -0,0 +1,50 @@
+from .data import Dataset, DataLoader, DatasetFactory
+
+# Optional integrations - handle gracefully if not available
+try:
+    from .pytorch import (get_pytorch_model_adapter, convert_to_pytorch_dataset,
+                          convert_from_pytorch_dataset, convert_pytorch_model)
+except ImportError:
+    # PyTorch integration not available
+    pass
+
+try:
+    from .tensorflow import (get_tensorflow_model_adapter, convert_to_tensorflow_dataset,
+                             convert_from_tensorflow_dataset, convert_tensorflow_model)
+except ImportError:
+    # TensorFlow integration not available
+    pass
+
+try:
+    from .huggingface import (get_huggingface_model, get_huggingface_dataset,
+                             get_huggingface_tokenizer)
+except ImportError:
+    # Hugging Face integration not available
+    pass
+
+# Model I/O utilities
+from .model_io import (save_model, load_model, convert_from_pytorch,
+                      convert_from_tensorflow, convert_to_pytorch,
+                      convert_to_tensorflow, register_model, get_model_class,
+                      list_registered_models)
+
+__all__ = [
+    # Data utilities
+    'Dataset', 'DataLoader', 'DatasetFactory',
+    
+    # PyTorch integration
+    'get_pytorch_model_adapter', 'convert_to_pytorch_dataset',
+    'convert_from_pytorch_dataset', 'convert_pytorch_model',
+    
+    # TensorFlow integration
+    'get_tensorflow_model_adapter', 'convert_to_tensorflow_dataset',
+    'convert_from_tensorflow_dataset', 'convert_tensorflow_model',
+    
+    # Hugging Face integration
+    'get_huggingface_model', 'get_huggingface_dataset', 'get_huggingface_tokenizer',
+    
+    # Model I/O utilities
+    'save_model', 'load_model', 'convert_from_pytorch', 'convert_from_tensorflow',
+    'convert_to_pytorch', 'convert_to_tensorflow', 'register_model',
+    'get_model_class', 'list_registered_models'
+] 

openarchx/utils/data.py

@@ -0,0 +1,229 @@
+import numpy as np
+from ..core.tensor import Tensor
+import importlib.util
+
+class Dataset:
+    """Base dataset class for OpenArchX framework."""
+    
+    def __init__(self, data=None, targets=None):
+        self.data = data
+        self.targets = targets
+        self.length = len(data) if data is not None else 0
+        
+    def __getitem__(self, index):
+        if self.data is None or self.targets is None:
+            raise NotImplementedError("Dataset must implement __getitem__ or provide data and targets")
+        return self.data[index], self.targets[index]
+        
+    def __len__(self):
+        return self.length
+
+
+class DataLoader:
+    """DataLoader for iterating over a dataset in batches with optional shuffling."""
+    
+    def __init__(self, dataset, batch_size=32, shuffle=False, drop_last=False):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.drop_last = drop_last
+        self.indices = np.arange(len(dataset))
+        
+    def __iter__(self):
+        if self.shuffle:
+            np.random.shuffle(self.indices)
+        
+        for start_idx in range(0, len(self.dataset), self.batch_size):
+            batch_indices = self.indices[start_idx:start_idx + self.batch_size]
+            
+            if len(batch_indices) < self.batch_size and self.drop_last:
+                continue
+                
+            batch = [self.dataset[i] for i in batch_indices]
+            
+            # Transpose the batch to get separate data and target batches
+            batch_data, batch_targets = zip(*batch)
+            
+            # Convert to arrays
+            batch_data = np.array(batch_data)
+            batch_targets = np.array(batch_targets)
+            
+            # Convert to Tensors
+            yield Tensor(batch_data), Tensor(batch_targets)
+            
+    def __len__(self):
+        if self.drop_last:
+            return len(self.dataset) // self.batch_size
+        return (len(self.dataset) + self.batch_size - 1) // self.batch_size
+
+
+# ===== ADAPTERS FOR EXTERNAL FRAMEWORKS =====
+# These are optional conversion utilities that don't affect core functionality
+
+class TorchDatasetAdapter(Dataset):
+    """Adapter for PyTorch datasets to OpenArchX framework."""
+    
+    def __init__(self, torch_dataset):
+        """
+        Args:
+            torch_dataset: A PyTorch Dataset object
+        """
+        super().__init__()
+        self.torch_dataset = torch_dataset
+        self.length = len(torch_dataset)
+        
+    def __getitem__(self, index):
+        data, target = self.torch_dataset[index]
+        
+        # Convert torch tensors to numpy arrays if needed
+        if hasattr(data, 'numpy'):
+            data = data.numpy()
+        if hasattr(target, 'numpy'):
+            target = target.numpy()
+            
+        return data, target
+        
+    def __len__(self):
+        return self.length
+
+
+class TFDatasetAdapter(Dataset):
+    """Adapter for TensorFlow datasets to OpenArchX framework."""
+    
+    def __init__(self, tf_dataset, x_key='x', y_key='y'):
+        """
+        Args:
+            tf_dataset: A TensorFlow Dataset object
+            x_key: Key for input features in TF dataset elements
+            y_key: Key for target values in TF dataset elements
+        """
+        super().__init__()
+        self.tf_dataset = tf_dataset
+        self.x_key = x_key
+        self.y_key = y_key
+        
+        # Count samples (might be expensive for large datasets)
+        try:
+            self.length = tf_dataset.cardinality().numpy()
+            if self.length < 0:  # If cardinality is unknown
+                self.length = sum(1 for _ in tf_dataset)
+        except:
+            # Fallback method
+            self.length = sum(1 for _ in tf_dataset)
+        
+        # Create iterator
+        self.iterator = iter(tf_dataset)
+        
+    def __getitem__(self, index):
+        # TensorFlow datasets don't support random indexing
+        # This implementation will iterate to the requested index
+        # Warning: This is inefficient for large indices or repeated access
+        # Better to use batching through the DataLoader
+        
+        # Reset iterator if needed
+        if index == 0 or not hasattr(self, 'current_index') or index < self.current_index:
+            self.iterator = iter(self.tf_dataset)
+            self.current_index = 0
+            
+        # Iterate until we reach the desired index
+        while self.current_index < index:
+            next(self.iterator)
+            self.current_index += 1
+            
+        # Get the item at the current index
+        item = next(self.iterator)
+        self.current_index += 1
+        
+        # Extract features and target
+        if isinstance(item, dict):
+            data = item[self.x_key].numpy()
+            target = item[self.y_key].numpy()
+        else:
+            data = item[0].numpy()
+            target = item[1].numpy()
+            
+        return data, target
+        
+    def __len__(self):
+        return self.length
+
+
+class HuggingFaceDatasetAdapter(Dataset):
+    """Adapter for Hugging Face datasets to OpenArchX framework."""
+    
+    def __init__(self, hf_dataset, input_cols=None, target_col=None, transform=None):
+        """
+        Args:
+            hf_dataset: A Hugging Face Dataset object
+            input_cols: Columns to use as input features
+            target_col: Column to use as target
+            transform: Optional transform to apply to inputs
+        """
+        super().__init__()
+        self.hf_dataset = hf_dataset
+        self.input_cols = input_cols
+        self.target_col = target_col
+        self.transform = transform
+        self.length = len(hf_dataset)
+        
+    def __getitem__(self, index):
+        item = self.hf_dataset[index]
+        
+        # Extract inputs
+        if self.input_cols:
+            if isinstance(self.input_cols, list):
+                data = np.array([item[col] for col in self.input_cols])
+            else:
+                data = np.array(item[self.input_cols])
+        else:
+            # Default: use all columns except target as input
+            data = np.array([v for k, v in item.items() if k != self.target_col])
+            
+        # Extract target
+        if self.target_col:
+            target = np.array(item[self.target_col])
+        else:
+            # Default behavior if no target specified
+            target = np.zeros(1)  # For unsupervised learning
+            
+        # Apply transform if specified
+        if self.transform:
+            data = self.transform(data)
+            
+        return data, target
+        
+    def __len__(self):
+        return self.length
+
+
+class DatasetFactory:
+    """Factory for creating datasets from various sources."""
+    
+    @staticmethod
+    def from_numpy(data, targets):
+        """Create a dataset from NumPy arrays."""
+        return Dataset(data, targets)
+    
+    @staticmethod
+    def from_torch(torch_dataset):
+        """Create a dataset from a PyTorch dataset."""
+        # Check if PyTorch is available
+        if importlib.util.find_spec("torch") is None:
+            raise ImportError("PyTorch is required for this adapter. Please install it with 'pip install torch'")
+        return TorchDatasetAdapter(torch_dataset)
+    
+    @staticmethod
+    def from_tensorflow(tf_dataset, x_key='x', y_key='y'):
+        """Create a dataset from a TensorFlow dataset."""
+        # Check if TensorFlow is available
+        if importlib.util.find_spec("tensorflow") is None:
+            raise ImportError("TensorFlow is required for this adapter. Please install it with 'pip install tensorflow'")
+        return TFDatasetAdapter(tf_dataset, x_key, y_key)
+    
+    @staticmethod
+    def from_huggingface(hf_dataset, input_cols=None, target_col=None, transform=None):
+        """Create a dataset from a Hugging Face dataset."""
+        # Check if datasets is available
+        if importlib.util.find_spec("datasets") is None:
+            raise ImportError("Hugging Face datasets is required for this adapter. Please install it with 'pip install datasets'")
+        return HuggingFaceDatasetAdapter(hf_dataset, input_cols, target_col, transform) 

openarchx/utils/huggingface.py

@@ -0,0 +1,288 @@
+"""
+Hugging Face Integration Utilities for OpenArchX.
+
+This module provides conversion and adapter utilities for using Hugging Face models
+and datasets with OpenArchX. These utilities are completely optional and do not 
+affect OpenArchX's core functionality, which remains independent from external libraries.
+"""
+
+import numpy as np
+import importlib.util
+from ..core.tensor import Tensor
+
+
+class HuggingFaceModelAdapter:
+    """Adapter for using Hugging Face models with OpenArchX."""
+    
+    def __init__(self, model_name_or_path, task="text-classification", **model_kwargs):
+        """
+        Initialize a Hugging Face model adapter.
+        
+        Args:
+            model_name_or_path: Name or path of the pretrained model.
+            task: The task the model should perform (e.g., "text-classification", "token-classification").
+            **model_kwargs: Additional arguments to pass to the model constructor.
+        """
+        # Check if transformers is installed
+        if importlib.util.find_spec("transformers") is None:
+            raise ImportError("Hugging Face transformers library is required. Install with 'pip install transformers'")
+            
+        from transformers import AutoModel, AutoModelForSequenceClassification, AutoTokenizer
+        
+        self.task = task
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+        
+        # Load appropriate model for the task
+        if task == "text-classification" or task == "sequence-classification":
+            self.model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, **model_kwargs)
+        elif task == "feature-extraction" or task == "embeddings":
+            self.model = AutoModel.from_pretrained(model_name_or_path, **model_kwargs)
+        else:
+            # For other tasks, try generic loading
+            from transformers import AutoModelForPreTraining
+            self.model = AutoModelForPreTraining.from_pretrained(model_name_or_path, **model_kwargs)
+            
+    def __call__(self, texts, **kwargs):
+        """
+        Process text through the model.
+        
+        Args:
+            texts: Input text or list of texts.
+            **kwargs: Additional arguments to pass to the tokenizer.
+            
+        Returns:
+            OpenArchX Tensor containing the model output.
+        """
+        # Prepare inputs
+        if isinstance(texts, str):
+            texts = [texts]
+            
+        # Tokenize
+        inputs = self.tokenizer(texts, return_tensors="pt", padding=True, truncation=True, **kwargs)
+        
+        # Get model output
+        with torch_no_grad():
+            outputs = self.model(**inputs)
+            
+        # Process outputs based on task
+        if self.task == "text-classification" or self.task == "sequence-classification":
+            # Get logits
+            result = outputs.logits.detach().cpu().numpy()
+        elif self.task == "feature-extraction" or self.task == "embeddings":
+            # Get last hidden state (embeddings)
+            result = outputs.last_hidden_state.detach().cpu().numpy()
+        else:
+            # Default to returning all outputs as a dict of numpy arrays
+            result = {k: v.detach().cpu().numpy() for k, v in outputs.items() if hasattr(v, 'detach')}
+            
+        # Convert to Tensor
+        if isinstance(result, dict):
+            return {k: Tensor(v) for k, v in result.items()}
+        return Tensor(result)
+
+
+class HuggingFaceDatasetLoader:
+    """Loader for Hugging Face datasets."""
+    
+    def __init__(self, dataset_name=None, dataset_path=None, split="train", **dataset_kwargs):
+        """
+        Initialize a Hugging Face dataset loader.
+        
+        Args:
+            dataset_name: Name of the dataset in the Hugging Face Hub.
+            dataset_path: Path to a local dataset.
+            split: Dataset split to use ("train", "validation", "test").
+            **dataset_kwargs: Additional arguments to pass to the dataset loader.
+        """
+        # Check if datasets is installed
+        if importlib.util.find_spec("datasets") is None:
+            raise ImportError("Hugging Face datasets library is required. Install with 'pip install datasets'")
+            
+        from datasets import load_dataset
+        
+        if dataset_name is None and dataset_path is None:
+            raise ValueError("Either dataset_name or dataset_path must be provided")
+            
+        # Load dataset
+        if dataset_path is not None:
+            self.dataset = load_dataset(dataset_path, split=split, **dataset_kwargs)
+        else:
+            self.dataset = load_dataset(dataset_name, split=split, **dataset_kwargs)
+    
+    def to_openarchx_dataset(self, input_cols=None, target_col=None, transform=None):
+        """
+        Convert the Hugging Face dataset to an OpenArchX Dataset.
+        
+        Args:
+            input_cols: Column(s) to use as input features.
+            target_col: Column to use as target.
+            transform: Transform to apply to the input features.
+            
+        Returns:
+            An OpenArchX Dataset.
+        """
+        from .data import HuggingFaceDatasetAdapter
+        return HuggingFaceDatasetAdapter(self.dataset, input_cols, target_col, transform)
+
+
+def torch_no_grad():
+    """Context manager to disable gradient calculation in PyTorch."""
+    try:
+        import torch
+        return torch.no_grad()
+    except ImportError:
+        # Fallback for when torch is not available
+        from contextlib import contextmanager
+        
+        @contextmanager
+        def dummy_context():
+            yield
+            
+        return dummy_context()
+
+
+class HuggingFaceTokenizerAdapter:
+    """Adapter for using Hugging Face tokenizers with OpenArchX."""
+    
+    def __init__(self, tokenizer_name_or_path, **tokenizer_kwargs):
+        """
+        Initialize a Hugging Face tokenizer adapter.
+        
+        Args:
+            tokenizer_name_or_path: Name or path of the pretrained tokenizer.
+            **tokenizer_kwargs: Additional arguments to pass to the tokenizer constructor.
+        """
+        # Check if transformers is installed
+        if importlib.util.find_spec("transformers") is None:
+            raise ImportError("Hugging Face transformers library is required. Install with 'pip install transformers'")
+            
+        from transformers import AutoTokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name_or_path, **tokenizer_kwargs)
+        
+    def __call__(self, texts, return_tensors="np", **kwargs):
+        """
+        Tokenize texts.
+        
+        Args:
+            texts: Input text or list of texts.
+            return_tensors: Output tensor format ("np" for numpy, "pt" for PyTorch, "tf" for TensorFlow).
+            **kwargs: Additional arguments to pass to the tokenizer.
+            
+        Returns:
+            Tokenized inputs, converted to OpenArchX Tensors if return_tensors="np".
+        """
+        # Call the tokenizer
+        outputs = self.tokenizer(texts, return_tensors=return_tensors, **kwargs)
+        
+        # Convert to OpenArchX Tensors if requested
+        if return_tensors == "np":
+            return {k: Tensor(v) if isinstance(v, np.ndarray) else v for k, v in outputs.items()}
+        return outputs
+
+
+class ModelWeightsExtractor:
+    """Utility to extract weights from a Hugging Face model into native OpenArchX format."""
+    
+    @staticmethod
+    def extract_transformer_weights(hf_model, layer_mapping=None):
+        """
+        Extract weights from a Hugging Face transformer model into a format
+        usable by OpenArchX native models.
+        
+        Args:
+            hf_model: A Hugging Face transformer model
+            layer_mapping: Optional dictionary mapping HF layer names to OpenArchX layer names
+            
+        Returns:
+            Dictionary of weights that can be loaded into a native OpenArchX model
+        """
+        # Default layer mapping if none provided
+        if layer_mapping is None:
+            layer_mapping = {
+                "embeddings": "embeddings",
+                "attention": "attention",
+                "intermediate": "intermediate",
+                "output": "output",
+                "layernorm": "layer_norm",
+            }
+            
+        # Get state dict from HF model
+        state_dict = hf_model.state_dict()
+        
+        # Convert to numpy arrays
+        numpy_weights = {k: v.detach().cpu().numpy() for k, v in state_dict.items()}
+        
+        # Transform to OpenArchX format based on mapping
+        openarchx_weights = {}
+        
+        for hf_name, param in numpy_weights.items():
+            # Map the parameter name to OpenArchX format
+            openarchx_name = hf_name
+            for hf_pattern, ox_pattern in layer_mapping.items():
+                if hf_pattern in hf_name:
+                    openarchx_name = hf_name.replace(hf_pattern, ox_pattern)
+                    break
+                    
+            openarchx_weights[openarchx_name] = Tensor(param)
+            
+        return openarchx_weights
+
+
+# Convenience functions
+
+def get_huggingface_model(model_name, task="text-classification", **kwargs):
+    """
+    Helper function to get a Hugging Face model adapter.
+    
+    Args:
+        model_name: Name or path of the pretrained model.
+        task: The task the model should perform.
+        **kwargs: Additional arguments to pass to the model constructor.
+        
+    Returns:
+        A HuggingFaceModelAdapter instance.
+    """
+    return HuggingFaceModelAdapter(model_name, task=task, **kwargs)
+
+
+def get_huggingface_dataset(dataset_name=None, dataset_path=None, **kwargs):
+    """
+    Helper function to get a Hugging Face dataset loader.
+    
+    Args:
+        dataset_name: Name of the dataset in the Hugging Face Hub.
+        dataset_path: Path to a local dataset.
+        **kwargs: Additional arguments to pass to the dataset loader.
+        
+    Returns:
+        A HuggingFaceDatasetLoader instance.
+    """
+    return HuggingFaceDatasetLoader(dataset_name=dataset_name, dataset_path=dataset_path, **kwargs)
+
+
+def get_huggingface_tokenizer(tokenizer_name, **kwargs):
+    """
+    Helper function to get a Hugging Face tokenizer adapter.
+    
+    Args:
+        tokenizer_name: Name or path of the pretrained tokenizer.
+        **kwargs: Additional arguments to pass to the tokenizer constructor.
+        
+    Returns:
+        A HuggingFaceTokenizerAdapter instance.
+    """
+    return HuggingFaceTokenizerAdapter(tokenizer_name, **kwargs)
+
+
+def extract_model_weights(hf_model, layer_mapping=None):
+    """
+    Extract weights from a Hugging Face model for use in a native OpenArchX model.
+    
+    Args:
+        hf_model: A Hugging Face model
+        layer_mapping: Optional mapping between HF and OpenArchX layer names
+        
+    Returns:
+        Dictionary of weights compatible with OpenArchX models
+    """
+    return ModelWeightsExtractor.extract_transformer_weights(hf_model, layer_mapping)