hqde 0.1.0__py3-none-any.whl

hqde/__init__.py

@@ -0,0 +1,62 @@
+"""
+HQDE: Hierarchical Quantum-Distributed Ensemble Learning Framework
+
+A comprehensive framework for distributed ensemble learning with quantum-inspired
+algorithms, adaptive quantization, and efficient hierarchical aggregation.
+"""
+
+__version__ = "0.1.0"
+__author__ = "HQDE Team"
+
+# Core components
+from .core.hqde_system import HQDESystem, create_hqde_system
+from .core.hqde_system import (
+    AdaptiveQuantizer,
+    QuantumInspiredAggregator,
+    DistributedEnsembleManager
+)
+
+# Quantum-inspired components
+from .quantum import (
+    QuantumEnsembleAggregator,
+    QuantumNoiseGenerator,
+    QuantumEnsembleOptimizer
+)
+
+# Distributed components
+from .distributed import (
+    MapReduceEnsembleManager,
+    HierarchicalAggregator,
+    ByzantineFaultTolerantAggregator,
+    DynamicLoadBalancer
+)
+
+# Utilities
+from .utils import (
+    PerformanceMonitor,
+    SystemMetrics
+)
+
+__all__ = [
+    # Core
+    'HQDESystem',
+    'create_hqde_system',
+    'AdaptiveQuantizer',
+    'QuantumInspiredAggregator',
+    'DistributedEnsembleManager',
+
+    # Quantum
+    'QuantumEnsembleAggregator',
+    'QuantumNoiseGenerator',
+    'QuantumEnsembleOptimizer',
+
+    # Distributed
+    'MapReduceEnsembleManager',
+    'HierarchicalAggregator',
+    'ByzantineFaultTolerantAggregator',
+    'DynamicLoadBalancer',
+
+    # Utils
+    'PerformanceMonitor',
+    'SystemMetrics'
+]

hqde/core/__init__.py

@@ -0,0 +1,23 @@
+"""
+Core HQDE system components.
+
+This module contains the main HQDE system implementation including
+adaptive quantization, quantum-inspired aggregation, and distributed
+ensemble management.
+"""
+
+from .hqde_system import (
+    HQDESystem,
+    AdaptiveQuantizer,
+    QuantumInspiredAggregator,
+    DistributedEnsembleManager,
+    create_hqde_system
+)
+
+__all__ = [
+    'HQDESystem',
+    'AdaptiveQuantizer',
+    'QuantumInspiredAggregator',
+    'DistributedEnsembleManager',
+    'create_hqde_system'
+]

hqde/core/hqde_system.py

@@ -0,0 +1,380 @@
+"""
+HQDE (Hierarchical Quantum-Distributed Ensemble Learning) Core System
+
+This module implements the main HQDE framework with quantum-inspired algorithms,
+distributed ensemble learning, and adaptive quantization.
+"""
+
+import torch
+import torch.nn as nn
+import numpy as np
+import ray
+from typing import Dict, List, Optional, Tuple, Any
+from collections import defaultdict
+import logging
+import time
+import psutil
+from concurrent.futures import ThreadPoolExecutor
+
+class AdaptiveQuantizer:
+    """Adaptive weight quantization based on real-time importance scoring."""
+
+    def __init__(self, base_bits: int = 8, min_bits: int = 4, max_bits: int = 16):
+        self.base_bits = base_bits
+        self.min_bits = min_bits
+        self.max_bits = max_bits
+        self.compression_cache = {}
+
+    def compute_importance_score(self, weights: torch.Tensor, gradients: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """Compute importance scores based on gradient magnitude and weight variance."""
+        with torch.no_grad():
+            # Weight-based importance
+            weight_importance = torch.abs(weights)
+
+            # Gradient-based importance if available
+            if gradients is not None:
+                grad_importance = torch.abs(gradients)
+                combined_importance = 0.7 * weight_importance + 0.3 * grad_importance
+            else:
+                combined_importance = weight_importance
+
+            # Normalize to [0, 1]
+            if combined_importance.numel() > 0:
+                min_val = combined_importance.min()
+                max_val = combined_importance.max()
+                if max_val > min_val:
+                    importance = (combined_importance - min_val) / (max_val - min_val)
+                else:
+                    importance = torch.ones_like(combined_importance) * 0.5
+            else:
+                importance = torch.ones_like(combined_importance) * 0.5
+
+        return importance
+
+    def adaptive_quantize(self, weights: torch.Tensor, importance_score: torch.Tensor) -> Tuple[torch.Tensor, Dict[str, Any]]:
+        """Perform adaptive quantization based on importance scores."""
+        # Determine bits per parameter based on importance
+        bits_per_param = self.min_bits + (self.max_bits - self.min_bits) * importance_score
+        bits_per_param = torch.clamp(bits_per_param, self.min_bits, self.max_bits).int()
+
+        # For simplicity, use uniform quantization with average bits
+        avg_bits = int(bits_per_param.float().mean().item())
+
+        # Quantize weights
+        weight_min = weights.min()
+        weight_max = weights.max()
+
+        if weight_max > weight_min:
+            scale = (weight_max - weight_min) / (2**avg_bits - 1)
+            zero_point = weight_min
+
+            quantized = torch.round((weights - zero_point) / scale)
+            quantized = torch.clamp(quantized, 0, 2**avg_bits - 1)
+
+            # Dequantize for use
+            dequantized = quantized * scale + zero_point
+        else:
+            dequantized = weights.clone()
+            scale = torch.tensor(1.0)
+            zero_point = torch.tensor(0.0)
+
+        metadata = {
+            'scale': scale,
+            'zero_point': zero_point,
+            'avg_bits': avg_bits,
+            'compression_ratio': 32.0 / avg_bits  # Assuming original is float32
+        }
+
+        return dequantized, metadata
+
+class QuantumInspiredAggregator:
+    """Quantum-inspired ensemble aggregation with controlled noise injection."""
+
+    def __init__(self, noise_scale: float = 0.01, exploration_factor: float = 0.1):
+        self.noise_scale = noise_scale
+        self.exploration_factor = exploration_factor
+
+    def quantum_noise_injection(self, weights: torch.Tensor) -> torch.Tensor:
+        """Add quantum-inspired noise for exploration."""
+        noise = torch.randn_like(weights) * self.noise_scale
+        return weights + noise
+
+    def efficiency_weighted_aggregation(self, weight_list: List[torch.Tensor],
+                                      efficiency_scores: List[float]) -> torch.Tensor:
+        """Aggregate weights using efficiency-based weighting."""
+        if not weight_list or not efficiency_scores:
+            raise ValueError("Empty weight list or efficiency scores")
+
+        # Normalize efficiency scores
+        efficiency_tensor = torch.tensor(efficiency_scores, dtype=torch.float32)
+        efficiency_weights = torch.softmax(efficiency_tensor, dim=0)
+
+        # Weighted aggregation
+        aggregated = torch.zeros_like(weight_list[0])
+        for weight, eff_weight in zip(weight_list, efficiency_weights):
+            aggregated += eff_weight * weight
+
+        # Add quantum noise for exploration
+        aggregated = self.quantum_noise_injection(aggregated)
+
+        return aggregated
+
+class DistributedEnsembleManager:
+    """Manages distributed ensemble learning with Ray."""
+
+    def __init__(self, num_workers: int = 4):
+        self.num_workers = num_workers
+        self.workers = []
+        self.quantizer = AdaptiveQuantizer()
+        self.aggregator = QuantumInspiredAggregator()
+
+        # Initialize Ray if not already initialized
+        if not ray.is_initialized():
+            ray.init(ignore_reinit_error=True)
+
+    def create_ensemble_workers(self, model_class, model_kwargs: Dict[str, Any]):
+        """Create distributed ensemble workers."""
+        @ray.remote
+        class EnsembleWorker:
+            def __init__(self, model_class, model_kwargs):
+                self.model = model_class(**model_kwargs)
+                self.efficiency_score = 1.0
+                self.quantizer = AdaptiveQuantizer()
+
+            def train_step(self, data_batch):
+                # Simulate training step
+                loss = torch.randn(1).item()
+                self.efficiency_score = max(0.1, self.efficiency_score * 0.99 + 0.01 * (1.0 / (1.0 + loss)))
+                return loss
+
+            def get_weights(self):
+                return {name: param.data.clone() for name, param in self.model.named_parameters()}
+
+            def set_weights(self, weights_dict):
+                for name, param in self.model.named_parameters():
+                    if name in weights_dict:
+                        param.data.copy_(weights_dict[name])
+
+            def get_efficiency_score(self):
+                return self.efficiency_score
+
+        self.workers = [EnsembleWorker.remote(model_class, model_kwargs)
+                       for _ in range(self.num_workers)]
+
+    def aggregate_weights(self) -> Dict[str, torch.Tensor]:
+        """Aggregate weights from all workers."""
+        # Get weights and efficiency scores from workers
+        weight_futures = [worker.get_weights.remote() for worker in self.workers]
+        efficiency_futures = [worker.get_efficiency_score.remote() for worker in self.workers]
+
+        all_weights = ray.get(weight_futures)
+        efficiency_scores = ray.get(efficiency_futures)
+
+        if not all_weights:
+            return {}
+
+        # Aggregate each parameter separately
+        aggregated_weights = {}
+        param_names = all_weights[0].keys()
+
+        for param_name in param_names:
+            # Collect parameter tensors from all workers
+            param_tensors = [weights[param_name] for weights in all_weights]
+
+            # Compute importance scores for quantization
+            stacked_params = torch.stack(param_tensors)
+            importance_scores = self.quantizer.compute_importance_score(stacked_params)
+
+            # Quantize and aggregate
+            quantized_params = []
+            for i, param in enumerate(param_tensors):
+                quantized, metadata = self.quantizer.adaptive_quantize(
+                    param, importance_scores[i]
+                )
+                quantized_params.append(quantized)
+
+            # Efficiency-weighted aggregation
+            aggregated_param = self.aggregator.efficiency_weighted_aggregation(
+                quantized_params, efficiency_scores
+            )
+
+            aggregated_weights[param_name] = aggregated_param
+
+        return aggregated_weights
+
+    def broadcast_weights(self, weights: Dict[str, torch.Tensor]):
+        """Broadcast aggregated weights to all workers."""
+        futures = [worker.set_weights.remote(weights) for worker in self.workers]
+        ray.get(futures)
+
+    def train_ensemble(self, data_loader, num_epochs: int = 10):
+        """Train the ensemble using distributed workers."""
+        for epoch in range(num_epochs):
+            # Simulate training on each worker
+            training_futures = []
+            for worker in self.workers:
+                # In a real implementation, you'd distribute different data batches
+                training_futures.append(worker.train_step.remote(None))
+
+            # Wait for training to complete
+            losses = ray.get(training_futures)
+
+            # Aggregate weights
+            aggregated_weights = self.aggregate_weights()
+
+            # Broadcast aggregated weights
+            if aggregated_weights:
+                self.broadcast_weights(aggregated_weights)
+
+            print(f"Epoch {epoch + 1}/{num_epochs}, Average Loss: {np.mean(losses):.4f}")
+
+    def shutdown(self):
+        """Shutdown the distributed ensemble manager."""
+        ray.shutdown()
+
+class HQDESystem:
+    """Main HQDE (Hierarchical Quantum-Distributed Ensemble Learning) System."""
+
+    def __init__(self,
+                 model_class,
+                 model_kwargs: Dict[str, Any],
+                 num_workers: int = 4,
+                 quantization_config: Optional[Dict[str, Any]] = None,
+                 aggregation_config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize HQDE System.
+
+        Args:
+            model_class: The model class to use for ensemble members
+            model_kwargs: Keyword arguments for model initialization
+            num_workers: Number of distributed workers
+            quantization_config: Configuration for adaptive quantization
+            aggregation_config: Configuration for quantum-inspired aggregation
+        """
+        self.model_class = model_class
+        self.model_kwargs = model_kwargs
+        self.num_workers = num_workers
+
+        # Initialize components
+        self.quantizer = AdaptiveQuantizer(**(quantization_config or {}))
+        self.aggregator = QuantumInspiredAggregator(**(aggregation_config or {}))
+        self.ensemble_manager = DistributedEnsembleManager(num_workers)
+
+        # Performance monitoring
+        self.metrics = {
+            'training_time': 0.0,
+            'communication_overhead': 0.0,
+            'memory_usage': 0.0,
+            'compression_ratio': 1.0
+        }
+
+        self.logger = logging.getLogger(__name__)
+
+    def initialize_ensemble(self):
+        """Initialize the distributed ensemble."""
+        self.logger.info(f"Initializing HQDE ensemble with {self.num_workers} workers")
+        self.ensemble_manager.create_ensemble_workers(self.model_class, self.model_kwargs)
+
+    def train(self, data_loader, num_epochs: int = 10, validation_loader=None):
+        """Train the HQDE ensemble."""
+        start_time = time.time()
+
+        # Monitor initial memory usage
+        initial_memory = psutil.Process().memory_info().rss / 1024 / 1024  # MB
+
+        self.logger.info(f"Starting HQDE training for {num_epochs} epochs")
+
+        # Train the ensemble
+        self.ensemble_manager.train_ensemble(data_loader, num_epochs)
+
+        # Calculate metrics
+        end_time = time.time()
+        final_memory = psutil.Process().memory_info().rss / 1024 / 1024  # MB
+
+        self.metrics.update({
+            'training_time': end_time - start_time,
+            'memory_usage': final_memory - initial_memory
+        })
+
+        self.logger.info(f"HQDE training completed in {self.metrics['training_time']:.2f} seconds")
+        self.logger.info(f"Memory usage: {self.metrics['memory_usage']:.2f} MB")
+
+        return self.metrics
+
+    def predict(self, data_loader):
+        """Make predictions using the trained ensemble."""
+        # This is a simplified prediction method
+        # In a real implementation, you'd aggregate predictions from all workers
+        predictions = []
+
+        # Get weights from first worker as representative
+        if self.ensemble_manager.workers:
+            weights = ray.get(self.ensemble_manager.workers[0].get_weights.remote())
+            # Simulate predictions using these weights
+            for batch in data_loader:
+                # In practice, you'd run the model forward pass
+                batch_predictions = torch.randn(len(batch), 10)  # Simulated predictions
+                predictions.append(batch_predictions)
+
+        return torch.cat(predictions, dim=0) if predictions else torch.empty(0)
+
+    def get_performance_metrics(self) -> Dict[str, float]:
+        """Get performance metrics from the HQDE system."""
+        return self.metrics.copy()
+
+    def save_model(self, filepath: str):
+        """Save the trained ensemble model."""
+        # Get aggregated weights
+        aggregated_weights = self.ensemble_manager.aggregate_weights()
+
+        model_state = {
+            'aggregated_weights': aggregated_weights,
+            'model_kwargs': self.model_kwargs,
+            'metrics': self.metrics,
+            'num_workers': self.num_workers
+        }
+
+        torch.save(model_state, filepath)
+        self.logger.info(f"HQDE model saved to {filepath}")
+
+    def load_model(self, filepath: str):
+        """Load a trained ensemble model."""
+        model_state = torch.load(filepath)
+
+        self.model_kwargs = model_state['model_kwargs']
+        self.metrics = model_state['metrics']
+        self.num_workers = model_state['num_workers']
+
+        # Reinitialize ensemble with loaded state
+        self.initialize_ensemble()
+
+        # Set weights if available
+        if 'aggregated_weights' in model_state:
+            self.ensemble_manager.broadcast_weights(model_state['aggregated_weights'])
+
+        self.logger.info(f"HQDE model loaded from {filepath}")
+
+    def cleanup(self):
+        """Cleanup resources."""
+        self.ensemble_manager.shutdown()
+
+# Factory function for easy instantiation
+def create_hqde_system(model_class,
+                      model_kwargs: Dict[str, Any],
+                      num_workers: int = 4,
+                      **kwargs) -> HQDESystem:
+    """
+    Factory function to create and initialize an HQDE system.
+
+    Args:
+        model_class: The model class for ensemble members
+        model_kwargs: Model initialization parameters
+        num_workers: Number of distributed workers
+        **kwargs: Additional configuration parameters
+
+    Returns:
+        Initialized HQDESystem instance
+    """
+    system = HQDESystem(model_class, model_kwargs, num_workers, **kwargs)
+    system.initialize_ensemble()
+    return system

hqde/distributed/__init__.py

@@ -0,0 +1,18 @@
+"""
+Distributed computing components for HQDE framework.
+
+This module provides distributed ensemble management, hierarchical aggregation,
+and MapReduce-inspired weight management for scalable ensemble learning.
+"""
+
+from .mapreduce_ensemble import MapReduceEnsembleManager
+from .hierarchical_aggregator import HierarchicalAggregator
+from .fault_tolerance import ByzantineFaultTolerantAggregator
+from .load_balancer import DynamicLoadBalancer
+
+__all__ = [
+    'MapReduceEnsembleManager',
+    'HierarchicalAggregator',
+    'ByzantineFaultTolerantAggregator',
+    'DynamicLoadBalancer'
+]