Upload 9 files

chg_package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CHG Algorithm Team
+
+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.

chg_package/README.md

@@ -0,0 +1,150 @@
+# CHG Algorithm Package
+
+[![Python Version](https://img.shields.io/badge/python-3.7+-blue.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+CHG (Covariance-based Hilbert Geometry) Algorithm is a sophisticated implementation of Gaussian Process regression with enhanced multi-head attention mechanisms for improved covariance computation and uncertainty quantification.
+
+## Features
+
+- **Multi-head Attention**: Advanced attention mechanism for better feature representation
+- **Enhanced Covariance**: Sophisticated covariance computation using neural network components
+- **Uncertainty Quantification**: Built-in uncertainty estimation for predictions
+- **Optimization Support**: Gradient-based parameter optimization
+- **Robust Implementation**: Handles numerical instabilities gracefully
+
+## Installation
+
+### From Source
+
+```bash
+git clone <repository-url>
+cd chg_package
+pip install -e .
+```
+
+### Development Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from chg_algorithm import CHG
+import numpy as np
+
+# Initialize model
+model = CHG(input_dim=3, hidden_dim=24, num_heads=4)
+
+# Generate sample data
+X_train = np.random.randn(100, 3)
+y_train = np.sum(X_train**2, axis=1) + 0.1 * np.random.randn(100)
+X_test = np.random.randn(20, 3)
+
+# Make predictions
+pred_mean, pred_var = model.fit_predict(X_train, y_train, X_test)
+
+print(f"Predictions: {pred_mean}")
+print(f"Uncertainties: {np.sqrt(pred_var)}")
+```
+
+### Running Demo
+
+```python
+from chg_algorithm import run_chg_experiment
+
+# Run complete demonstration
+model, predictions, variances = run_chg_experiment()
+```
+
+### Using Optimizer
+
+```python
+from chg_algorithm import CHG, CHGOptimizer
+
+# Initialize model and optimizer
+model = CHG(input_dim=3, hidden_dim=24, num_heads=4)
+optimizer = CHGOptimizer(model, learning_rate=0.001)
+
+# Optimize model parameters
+for epoch in range(10):
+    optimizer.step(X_train, y_train)
+    lml = model.log_marginal_likelihood(X_train, y_train)
+    print(f"Epoch {epoch}: Log Marginal Likelihood = {lml:.4f}")
+```
+
+## API Reference
+
+### CHG Class
+
+Main model class implementing the CHG algorithm.
+
+**Parameters:**
+- `input_dim` (int): Dimensionality of input features
+- `hidden_dim` (int): Hidden dimension for feature transformation  
+- `num_heads` (int): Number of attention heads
+
+**Key Methods:**
+- `fit_predict(X_train, y_train, X_test, noise_var=1e-6)`: Fit model and predict
+- `log_marginal_likelihood(X, y, noise_var=1e-6)`: Compute log marginal likelihood
+- `get_covariance_matrix(X)`: Get covariance matrix for inputs
+
+### CHGOptimizer Class
+
+Optimizer for CHG model parameters.
+
+**Parameters:**
+- `model` (CHG): CHG model instance to optimize
+- `learning_rate` (float): Learning rate for parameter updates
+
+**Key Methods:**
+- `step(X, y, noise_var=1e-6)`: Perform one optimization step
+- `compute_gradients(X, y, noise_var=1e-6)`: Compute parameter gradients
+
+## Algorithm Details
+
+The CHG algorithm combines several advanced techniques:
+
+1. **Multi-head Attention**: Uses multiple attention heads to capture different aspects of feature relationships
+2. **Enhanced Covariance**: Computes covariance using feedforward networks and layer normalization
+3. **Gaussian Process Framework**: Built on solid GP foundations for uncertainty quantification
+4. **Numerical Stability**: Includes fallback methods for numerical edge cases
+
+## Requirements
+
+- Python >= 3.7
+- NumPy >= 1.19.0
+- typing-extensions >= 3.7.4
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Citation
+
+If you use this software in your research, please cite:
+
+```bibtex
+@software{chg_algorithm,
+  title={CHG Algorithm: Covariance-based Hilbert Geometry for Gaussian Processes},
+  author={CHG Algorithm Team},
+  year={2024},
+  url={https://github.com/your-username/chg-algorithm}
+}
+```
+
+## Contact
+
+For questions and support, please contact: chg@example.com 

chg_package/chg_algorithm/__init__.py

@@ -0,0 +1,18 @@
+"""
+CHG Algorithm Package
+
+A Python package implementing the CHG (Covariance-based Hilbert Geometry) algorithm
+for Gaussian Process regression with enhanced multi-head attention mechanisms.
+"""
+
+from .core import CHG, CHGOptimizer, run_chg_experiment
+
+__version__ = "1.0.0"
+__author__ = "CHG Algorithm Team"
+__email__ = "chg@example.com"
+
+__all__ = [
+    'CHG',
+    'CHGOptimizer', 
+    'run_chg_experiment'
+] 

chg_package/chg_algorithm/core.py

@@ -0,0 +1,350 @@
+"""
+CHG (Covariance-based Hilbert Geometry) Algorithm Implementation
+
+This module contains the core CHG algorithm implementation with multi-head attention
+mechanism for Gaussian Process regression with enhanced covariance computation.
+
+Author: CHG Algorithm Team
+Version: 1.0.0
+"""
+
+import numpy as np
+from typing import Tuple, Optional
+
+
+class CHG:
+    """
+    CHG (Covariance-based Hilbert Geometry) Model
+    
+    A Gaussian Process model with multi-head attention mechanism for enhanced
+    covariance computation, supporting uncertainty quantification and optimization.
+    
+    Parameters:
+    -----------
+    input_dim : int
+        Dimensionality of input features
+    hidden_dim : int
+        Hidden dimension for feature transformation
+    num_heads : int
+        Number of attention heads
+    """
+    
+    def __init__(self, input_dim: int, hidden_dim: int, num_heads: int):
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.num_heads = num_heads
+        self.head_dim = hidden_dim // num_heads
+        
+        self._init_parameters()
+    
+    def _init_parameters(self):
+        """Initialize model parameters with proper scaling"""
+        # QKV projection matrices
+        self.W_q = np.random.normal(0, 0.02, (self.input_dim, self.hidden_dim))
+        self.W_k = np.random.normal(0, 0.02, (self.input_dim, self.hidden_dim))
+        self.W_v = np.random.normal(0, 0.02, (self.input_dim, self.hidden_dim))
+        
+        # Covariance feedforward network
+        self.W_ff1 = np.random.normal(0, 0.02, (self.hidden_dim, 2 * self.hidden_dim))
+        self.b_ff1 = np.zeros((2 * self.hidden_dim,))
+        self.W_ff2 = np.random.normal(0, 0.02, (2 * self.hidden_dim, 1))
+        self.b_ff2 = np.zeros((1,))
+        
+        # Layer normalization
+        self.gamma = np.ones((self.hidden_dim,))
+        self.beta = np.zeros((self.hidden_dim,))
+        
+        # Multi-head fusion
+        self.W_heads = np.random.normal(0, 0.02, (self.num_heads, 1))
+        self.scale = np.random.normal(1.0, 0.1, (1,))
+
+    def _layer_norm(self, x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, 
+                    eps: float = 1e-6) -> np.ndarray:
+        """Apply layer normalization"""
+        mean = np.mean(x, axis=-1, keepdims=True)
+        var = np.var(x, axis=-1, keepdims=True)
+        return gamma * (x - mean) / np.sqrt(var + eps) + beta
+
+    def _gelu(self, x: np.ndarray) -> np.ndarray:
+        """GELU activation function"""
+        return 0.5 * x * (1 + np.tanh(np.sqrt(2/np.pi) * (x + 0.044715 * x**3)))
+
+    def _compute_covariance(self, X1: np.ndarray, X2: np.ndarray) -> np.ndarray:
+        """
+        Compute enhanced covariance matrix using multi-head attention mechanism
+        
+        Parameters:
+        -----------
+        X1 : np.ndarray
+            First set of input points
+        X2 : np.ndarray  
+            Second set of input points
+            
+        Returns:
+        --------
+        np.ndarray
+            Covariance matrix between X1 and X2
+        """
+        n1, n2 = X1.shape[0], X2.shape[0]
+        
+        # Project to QKV spaces
+        Q1 = X1 @ self.W_q
+        K2 = X2 @ self.W_k
+        V2 = X2 @ self.W_v
+        
+        # Reshape for multi-head attention
+        Q1_h = Q1.reshape(n1, self.num_heads, self.head_dim)
+        K2_h = K2.reshape(n2, self.num_heads, self.head_dim)
+        V2_h = V2.reshape(n2, self.num_heads, self.head_dim)
+        
+        head_outputs = []
+        
+        for h in range(self.num_heads):
+            Q_h = Q1_h[:, h, :]
+            K_h = K2_h[:, h, :]
+            V_h = V2_h[:, h, :]
+            
+            # Attention scores as base similarity
+            attention_scores = Q_h @ K_h.T / np.sqrt(self.head_dim)
+            
+            # Enhanced covariance computation
+            enhanced_cov = np.zeros((n1, n2))
+            
+            for i in range(n1):
+                for j in range(n2):
+                    base_sim = attention_scores[i, j]
+                    
+                    # Feature interaction
+                    feature_int = Q_h[i] * K_h[j]
+                    
+                    # Layer normalization
+                    norm_features = self._layer_norm(
+                        feature_int.reshape(1, -1), 
+                        self.gamma[:self.head_dim], 
+                        self.beta[:self.head_dim]
+                    ).flatten()
+                    
+                    # Feedforward processing
+                    ff_hidden = norm_features @ self.W_ff1[:self.head_dim, :self.head_dim] + self.b_ff1[:self.head_dim]
+                    ff_hidden = self._gelu(ff_hidden)
+                    ff_out = ff_hidden @ self.W_ff2[:self.head_dim, :] + self.b_ff2
+                    
+                    # Residual connection
+                    enhanced_cov[i, j] = base_sim + ff_out[0]
+            
+            head_outputs.append(enhanced_cov)
+        
+        # Fuse multi-head outputs
+        final_cov = np.zeros((n1, n2))
+        for h, head_out in enumerate(head_outputs):
+            final_cov += self.W_heads[h, 0] * head_out
+        
+        final_cov = self.scale[0] * final_cov
+        
+        # Ensure positive definiteness for diagonal case
+        if n1 == n2 and np.allclose(X1, X2):
+            final_cov = 0.5 * (final_cov + final_cov.T)
+            final_cov += 1e-6 * np.eye(n1)
+        
+        return final_cov
+
+    def fit_predict(self, X_train: np.ndarray, y_train: np.ndarray, 
+                   X_test: np.ndarray, noise_var: float = 1e-6) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Fit the model and make predictions
+        
+        Parameters:
+        -----------
+        X_train : np.ndarray
+            Training input data
+        y_train : np.ndarray
+            Training target values
+        X_test : np.ndarray
+            Test input data
+        noise_var : float
+            Observation noise variance
+            
+        Returns:
+        --------
+        Tuple[np.ndarray, np.ndarray]
+            Predictive mean and variance
+        """
+        # Compute covariance matrices
+        K_train = self._compute_covariance(X_train, X_train)
+        K_test_train = self._compute_covariance(X_test, X_train)
+        K_test = self._compute_covariance(X_test, X_test)
+        
+        # GP inference
+        K_noisy = K_train + noise_var * np.eye(len(X_train))
+        
+        try:
+            L = np.linalg.cholesky(K_noisy)
+            alpha = np.linalg.solve(L, y_train)
+            alpha = np.linalg.solve(L.T, alpha)
+            
+            # Predictive mean
+            mean_pred = K_test_train @ alpha
+            
+            # Predictive variance
+            v = np.linalg.solve(L, K_test_train.T)
+            var_pred = np.diag(K_test) - np.sum(v**2, axis=0)
+            
+        except np.linalg.LinAlgError:
+            K_inv = np.linalg.pinv(K_noisy)
+            mean_pred = K_test_train @ K_inv @ y_train
+            var_pred = np.diag(K_test - K_test_train @ K_inv @ K_test_train.T)
+        
+        var_pred = np.maximum(var_pred, 1e-8)
+        return mean_pred, var_pred
+
+    def log_marginal_likelihood(self, X: np.ndarray, y: np.ndarray, 
+                               noise_var: float = 1e-6) -> float:
+        """
+        Compute log marginal likelihood for model selection
+        
+        Parameters:
+        -----------
+        X : np.ndarray
+            Input data
+        y : np.ndarray
+            Target values
+        noise_var : float
+            Observation noise variance
+            
+        Returns:
+        --------
+        float
+            Log marginal likelihood
+        """
+        K = self._compute_covariance(X, X)
+        K_noisy = K + noise_var * np.eye(len(X))
+        
+        try:
+            L = np.linalg.cholesky(K_noisy)
+            alpha = np.linalg.solve(L, y)
+            
+            data_fit = -0.5 * y.T @ alpha
+            complexity = -np.sum(np.log(np.diag(L)))
+            normalization = -0.5 * len(y) * np.log(2 * np.pi)
+            
+            return float(data_fit + complexity + normalization)
+            
+        except np.linalg.LinAlgError:
+            sign, logdet = np.linalg.slogdet(K_noisy)
+            K_inv = np.linalg.pinv(K_noisy)
+            
+            data_fit = -0.5 * y.T @ K_inv @ y
+            complexity = -0.5 * logdet if sign > 0 else -1e6
+            normalization = -0.5 * len(y) * np.log(2 * np.pi)
+            
+            return float(data_fit + complexity + normalization)
+
+    def get_covariance_matrix(self, X: np.ndarray) -> np.ndarray:
+        """Get the covariance matrix for given inputs"""
+        return self._compute_covariance(X, X)
+
+    def update_parameters(self, gradient_dict: dict, learning_rate: float = 0.001):
+        """Update model parameters using computed gradients"""
+        for param_name, gradient in gradient_dict.items():
+            if hasattr(self, param_name):
+                current_param = getattr(self, param_name)
+                updated_param = current_param - learning_rate * gradient
+                setattr(self, param_name, updated_param)
+
+
+class CHGOptimizer:
+    """
+    Optimizer for CHG model parameters using numerical gradients
+    
+    Parameters:
+    -----------
+    model : CHG
+        CHG model instance to optimize
+    learning_rate : float
+        Learning rate for parameter updates
+    """
+    
+    def __init__(self, model: CHG, learning_rate: float = 0.001):
+        self.model = model
+        self.lr = learning_rate
+        
+    def compute_gradients(self, X: np.ndarray, y: np.ndarray, noise_var: float = 1e-6):
+        """Compute numerical gradients for all model parameters"""
+        gradients = {}
+        eps = 1e-5
+        
+        base_loss = -self.model.log_marginal_likelihood(X, y, noise_var)
+        
+        for param_name in ['W_q', 'W_k', 'W_v', 'W_ff1', 'W_ff2', 'W_heads', 'scale']:
+            param = getattr(self.model, param_name)
+            grad = np.zeros_like(param)
+            
+            flat_param = param.flatten()
+            flat_grad = grad.flatten()
+            
+            for i in range(len(flat_param)):
+                flat_param[i] += eps
+                param_plus = flat_param.reshape(param.shape)
+                setattr(self.model, param_name, param_plus)
+                
+                loss_plus = -self.model.log_marginal_likelihood(X, y, noise_var)
+                
+                flat_param[i] -= 2 * eps
+                param_minus = flat_param.reshape(param.shape)
+                setattr(self.model, param_name, param_minus)
+                
+                loss_minus = -self.model.log_marginal_likelihood(X, y, noise_var)
+                
+                flat_grad[i] = (loss_plus - loss_minus) / (2 * eps)
+                flat_param[i] += eps
+            
+            setattr(self.model, param_name, flat_param.reshape(param.shape))
+            gradients[param_name] = flat_grad.reshape(param.shape)
+        
+        return gradients
+    
+    def step(self, X: np.ndarray, y: np.ndarray, noise_var: float = 1e-6):
+        """Perform one optimization step"""
+        gradients = self.compute_gradients(X, y, noise_var)
+        self.model.update_parameters(gradients, self.lr)
+
+
+def run_chg_experiment():
+    """
+    Run a simple experiment to demonstrate CHG functionality
+    
+    Returns:
+    --------
+    Tuple
+        Trained model, predictions, and variances
+    """
+    # Initialize CHG model
+    model = CHG(input_dim=3, hidden_dim=24, num_heads=4)
+    
+    # Generate synthetic data
+    np.random.seed(42)
+    X_train = np.random.randn(80, 3)
+    y_train = np.sum(X_train**2, axis=1) + 0.3 * np.sin(2 * X_train[:, 0]) + 0.1 * np.random.randn(80)
+    
+    X_test = np.random.randn(25, 3)
+    y_test = np.sum(X_test**2, axis=1) + 0.3 * np.sin(2 * X_test[:, 0])
+    
+    # CHG prediction
+    pred_mean, pred_var = model.fit_predict(X_train, y_train, X_test)
+    
+    # Evaluation metrics
+    rmse = np.sqrt(np.mean((pred_mean - y_test)**2))
+    mae = np.mean(np.abs(pred_mean - y_test))
+    
+    # Uncertainty quantification
+    pred_std = np.sqrt(pred_var)
+    coverage = np.mean((y_test >= pred_mean - 1.96 * pred_std) & 
+                      (y_test <= pred_mean + 1.96 * pred_std))
+    
+    print(f"CHG Performance:")
+    print(f"RMSE: {rmse:.4f}")
+    print(f"MAE: {mae:.4f}")
+    print(f"Coverage: {coverage:.4f}")
+    print(f"Log Marginal Likelihood: {model.log_marginal_likelihood(X_train, y_train):.4f}")
+    
+    return model, pred_mean, pred_var 

chg_package/examples/basic_example.py

@@ -0,0 +1,153 @@
+"""
+Basic example demonstrating CHG algorithm usage
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from chg_algorithm import CHG, CHGOptimizer
+
+
+def basic_regression_example():
+    """Demonstrate basic regression with CHG"""
+    print("=== Basic CHG Regression Example ===")
+    
+    # Generate synthetic 1D data for visualization
+    np.random.seed(42)
+    X_train = np.random.uniform(-3, 3, (50, 1))
+    y_train = np.sin(X_train.flatten()) + 0.1 * np.random.randn(50)
+    
+    X_test = np.linspace(-4, 4, 100).reshape(-1, 1)
+    y_true = np.sin(X_test.flatten())
+    
+    # Initialize and fit CHG model
+    model = CHG(input_dim=1, hidden_dim=16, num_heads=2)
+    pred_mean, pred_var = model.fit_predict(X_train, y_train, X_test)
+    pred_std = np.sqrt(pred_var)
+    
+    # Print metrics
+    mse = np.mean((pred_mean - y_true)**2)
+    print(f"Mean Squared Error: {mse:.4f}")
+    print(f"Log Marginal Likelihood: {model.log_marginal_likelihood(X_train, y_train):.4f}")
+    
+    # Visualization
+    plt.figure(figsize=(10, 6))
+    plt.scatter(X_train.flatten(), y_train, alpha=0.6, label='Training Data')
+    plt.plot(X_test.flatten(), y_true, 'r-', label='True Function')
+    plt.plot(X_test.flatten(), pred_mean, 'b-', label='CHG Prediction')
+    plt.fill_between(X_test.flatten(), 
+                     pred_mean - 2*pred_std, 
+                     pred_mean + 2*pred_std, 
+                     alpha=0.2, label='95% Confidence')
+    plt.xlabel('Input')
+    plt.ylabel('Output')
+    plt.title('CHG Gaussian Process Regression')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.show()
+
+
+def optimization_example():
+    """Demonstrate parameter optimization"""
+    print("\n=== CHG Optimization Example ===")
+    
+    # Generate data
+    np.random.seed(123)
+    X_train = np.random.randn(80, 2)
+    y_train = np.sum(X_train**2, axis=1) + 0.5 * np.random.randn(80)
+    
+    # Initialize model and optimizer
+    model = CHG(input_dim=2, hidden_dim=20, num_heads=3)
+    optimizer = CHGOptimizer(model, learning_rate=0.01)
+    
+    # Track optimization progress
+    lml_history = []
+    
+    print("Optimizing CHG parameters...")
+    for epoch in range(20):
+        optimizer.step(X_train, y_train)
+        lml = model.log_marginal_likelihood(X_train, y_train)
+        lml_history.append(lml)
+        
+        if epoch % 5 == 0:
+            print(f"Epoch {epoch:2d}: Log Marginal Likelihood = {lml:.4f}")
+    
+    # Plot optimization progress
+    plt.figure(figsize=(8, 5))
+    plt.plot(lml_history, 'b-', linewidth=2)
+    plt.xlabel('Epoch')
+    plt.ylabel('Log Marginal Likelihood')
+    plt.title('CHG Optimization Progress')
+    plt.grid(True, alpha=0.3)
+    plt.show()
+    
+    print(f"Final Log Marginal Likelihood: {lml_history[-1]:.4f}")
+
+
+def uncertainty_quantification_example():
+    """Demonstrate uncertainty quantification capabilities"""
+    print("\n=== Uncertainty Quantification Example ===")
+    
+    # Generate noisy data with outliers
+    np.random.seed(456)
+    X_train = np.random.uniform(-2, 2, (60, 1))
+    y_clean = 0.5 * X_train.flatten()**3 - X_train.flatten()
+    
+    # Add noise and some outliers
+    noise = 0.2 * np.random.randn(60)
+    outlier_idx = np.random.choice(60, 5, replace=False)
+    noise[outlier_idx] += np.random.choice([-2, 2], 5) * 2  # Add outliers
+    
+    y_train = y_clean + noise
+    
+    X_test = np.linspace(-3, 3, 80).reshape(-1, 1)
+    
+    # Fit CHG model
+    model = CHG(input_dim=1, hidden_dim=12, num_heads=2)
+    pred_mean, pred_var = model.fit_predict(X_train, y_train, X_test)
+    pred_std = np.sqrt(pred_var)
+    
+    # Analyze uncertainties
+    high_uncertainty_idx = pred_std > np.percentile(pred_std, 75)
+    print(f"Percentage of high-uncertainty predictions: {np.mean(high_uncertainty_idx)*100:.1f}%")
+    print(f"Average prediction uncertainty: {np.mean(pred_std):.4f}")
+    print(f"Maximum prediction uncertainty: {np.max(pred_std):.4f}")
+    
+    # Visualization
+    plt.figure(figsize=(12, 5))
+    
+    plt.subplot(1, 2, 1)
+    plt.scatter(X_train.flatten(), y_train, alpha=0.7, c='red', label='Training Data (with outliers)')
+    plt.plot(X_test.flatten(), pred_mean, 'b-', linewidth=2, label='CHG Prediction')
+    plt.fill_between(X_test.flatten(), 
+                     pred_mean - 2*pred_std, 
+                     pred_mean + 2*pred_std, 
+                     alpha=0.3, label='95% Confidence')
+    plt.xlabel('Input')
+    plt.ylabel('Output')
+    plt.title('CHG Predictions with Uncertainty')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    plt.subplot(1, 2, 2)
+    plt.plot(X_test.flatten(), pred_std, 'g-', linewidth=2)
+    plt.fill_between(X_test.flatten()[high_uncertainty_idx], 
+                     0, pred_std[high_uncertainty_idx], 
+                     alpha=0.4, color='orange', 
+                     label='High Uncertainty Regions')
+    plt.xlabel('Input')
+    plt.ylabel('Prediction Uncertainty (σ)')
+    plt.title('Uncertainty Estimation')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == "__main__":
+    # Run all examples
+    basic_regression_example()
+    optimization_example()
+    uncertainty_quantification_example()
+    
+    print("\n=== All Examples Completed ===") 

chg_package/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chg-algorithm"
+description = "CHG (Covariance-based Hilbert Geometry) Algorithm for Gaussian Process Regression"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "CHG Algorithm Team", email = "chg@example.com"}
+]
+keywords = ["gaussian-process", "machine-learning", "regression", "uncertainty-quantification"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8", 
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.19.0",
+    "typing-extensions>=3.7.4"
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "pytest-cov>=2.0",
+    "black>=21.0",
+    "flake8>=3.9",
+    "mypy>=0.910"
+]
+docs = [
+    "sphinx>=4.0",
+    "sphinx-rtd-theme>=1.0"
+]
+examples = [
+    "matplotlib>=3.0"
+]
+
+[project.scripts]
+chg-demo = "chg_algorithm.core:run_chg_experiment"
+
+[tool.setuptools.dynamic]
+version = {attr = "chg_algorithm.__version__"}
+
+[tool.black]
+line-length = 88
+target-version = ['py37', 'py38', 'py39', 'py310', 'py311']
+
+[tool.mypy]
+python_version = "3.7"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "--verbose --cov=chg_algorithm --cov-report=html --cov-report=term" 

chg_package/requirements.txt

@@ -0,0 +1,2 @@
+numpy>=1.19.0
+typing-extensions>=3.7.4

chg_package/setup.py

@@ -0,0 +1,59 @@
+"""
+Setup script for CHG Algorithm Package
+"""
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="chg-algorithm",
+    version="1.0.0",
+    author="CHG Algorithm Team",
+    author_email="chg@example.com",
+    description="CHG (Covariance-based Hilbert Geometry) Algorithm for Gaussian Process Regression",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/your-username/chg-algorithm",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Science/Research", 
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Scientific/Engineering :: Mathematics",
+    ],
+    python_requires=">=3.7",
+    install_requires=requirements,
+    extras_require={
+        "dev": [
+            "pytest>=6.0",
+            "pytest-cov>=2.0",
+            "black>=21.0",
+            "flake8>=3.9",
+            "mypy>=0.910",
+        ],
+        "docs": [
+            "sphinx>=4.0",
+            "sphinx-rtd-theme>=1.0",
+        ]
+    },
+    entry_points={
+        "console_scripts": [
+            "chg-demo=chg_algorithm.core:run_chg_experiment",
+        ],
+    },
+    include_package_data=True,
+    zip_safe=False,
+) 

chg_package/tests/test_chg.py

@@ -0,0 +1,179 @@
+"""
+Unit tests for CHG algorithm
+"""
+
+import unittest
+import numpy as np
+from chg_algorithm import CHG, CHGOptimizer
+
+
+class TestCHG(unittest.TestCase):
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.model = CHG(input_dim=2, hidden_dim=8, num_heads=2)
+        self.X_train = np.random.randn(20, 2)
+        self.y_train = np.random.randn(20)
+        self.X_test = np.random.randn(10, 2)
+    
+    def test_model_initialization(self):
+        """Test model initialization"""
+        self.assertEqual(self.model.input_dim, 2)
+        self.assertEqual(self.model.hidden_dim, 8)
+        self.assertEqual(self.model.num_heads, 2)
+        self.assertEqual(self.model.head_dim, 4)
+    
+    def test_parameter_shapes(self):
+        """Test parameter matrix shapes"""
+        self.assertEqual(self.model.W_q.shape, (2, 8))
+        self.assertEqual(self.model.W_k.shape, (2, 8))
+        self.assertEqual(self.model.W_v.shape, (2, 8))
+        self.assertEqual(self.model.W_heads.shape, (2, 1))
+    
+    def test_covariance_computation(self):
+        """Test covariance matrix computation"""
+        K = self.model._compute_covariance(self.X_train, self.X_train)
+        
+        # Check shape
+        self.assertEqual(K.shape, (20, 20))
+        
+        # Check symmetry (approximately)
+        self.assertTrue(np.allclose(K, K.T, atol=1e-6))
+        
+        # Check positive semi-definiteness
+        eigenvals = np.linalg.eigvals(K)
+        self.assertTrue(np.all(eigenvals >= -1e-6))
+    
+    def test_fit_predict(self):
+        """Test fit and predict functionality"""
+        pred_mean, pred_var = self.model.fit_predict(
+            self.X_train, self.y_train, self.X_test
+        )
+        
+        # Check output shapes
+        self.assertEqual(pred_mean.shape, (10,))
+        self.assertEqual(pred_var.shape, (10,))
+        
+        # Check variance is positive
+        self.assertTrue(np.all(pred_var > 0))
+    
+    def test_log_marginal_likelihood(self):
+        """Test log marginal likelihood computation"""
+        lml = self.model.log_marginal_likelihood(self.X_train, self.y_train)
+        
+        # Should return a finite number
+        self.assertTrue(np.isfinite(lml))
+        self.assertIsInstance(lml, float)
+    
+    def test_layer_norm(self):
+        """Test layer normalization"""
+        x = np.random.randn(5, 8)
+        gamma = np.ones(8)
+        beta = np.zeros(8)
+        
+        normalized = self.model._layer_norm(x, gamma, beta)
+        
+        # Check shape preservation
+        self.assertEqual(normalized.shape, x.shape)
+        
+        # Check normalization (mean ≈ 0, std ≈ 1)
+        mean = np.mean(normalized, axis=-1)
+        std = np.std(normalized, axis=-1)
+        self.assertTrue(np.allclose(mean, 0, atol=1e-6))
+        self.assertTrue(np.allclose(std, 1, atol=1e-6))
+    
+    def test_gelu_activation(self):
+        """Test GELU activation function"""
+        x = np.array([-2, -1, 0, 1, 2])
+        result = self.model._gelu(x)
+        
+        # Check shape preservation
+        self.assertEqual(result.shape, x.shape)
+        
+        # Check monotonicity
+        self.assertTrue(np.all(np.diff(result) > 0))
+        
+        # Check specific values
+        self.assertAlmostEqual(result[2], 0.0, places=6)  # GELU(0) = 0
+
+
+class TestCHGOptimizer(unittest.TestCase):
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.model = CHG(input_dim=2, hidden_dim=6, num_heads=2)
+        self.optimizer = CHGOptimizer(self.model, learning_rate=0.01)
+        self.X = np.random.randn(15, 2)
+        self.y = np.random.randn(15)
+    
+    def test_optimizer_initialization(self):
+        """Test optimizer initialization"""
+        self.assertEqual(self.optimizer.lr, 0.01)
+        self.assertIs(self.optimizer.model, self.model)
+    
+    def test_gradient_computation(self):
+        """Test gradient computation"""
+        gradients = self.optimizer.compute_gradients(self.X, self.y)
+        
+        # Check that gradients are computed for all parameters
+        expected_params = ['W_q', 'W_k', 'W_v', 'W_ff1', 'W_ff2', 'W_heads', 'scale']
+        for param in expected_params:
+            self.assertIn(param, gradients)
+            
+            # Check gradient shape matches parameter shape
+            param_shape = getattr(self.model, param).shape
+            self.assertEqual(gradients[param].shape, param_shape)
+    
+    def test_optimization_step(self):
+        """Test optimization step"""
+        # Store initial parameter values
+        initial_params = {}
+        for param in ['W_q', 'W_k', 'W_v', 'W_heads', 'scale']:
+            initial_params[param] = getattr(self.model, param).copy()
+        
+        # Perform optimization step
+        self.optimizer.step(self.X, self.y)
+        
+        # Check that parameters have been updated
+        for param in initial_params:
+            updated_param = getattr(self.model, param)
+            self.assertFalse(np.allclose(initial_params[param], updated_param))
+
+
+class TestExperiment(unittest.TestCase):
+    
+    def test_run_chg_experiment(self):
+        """Test the complete experiment function"""
+        from chg_algorithm import run_chg_experiment
+        
+        # Redirect stdout to capture print statements
+        import io
+        import sys
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        
+        try:
+            model, pred_mean, pred_var = run_chg_experiment()
+            
+            # Restore stdout
+            sys.stdout = sys.__stdout__
+            
+            # Check outputs
+            self.assertIsInstance(model, CHG)
+            self.assertEqual(pred_mean.shape, (25,))
+            self.assertEqual(pred_var.shape, (25,))
+            self.assertTrue(np.all(pred_var > 0))
+            
+            # Check that performance metrics were printed
+            output = captured_output.getvalue()
+            self.assertIn("CHG Performance", output)
+            self.assertIn("RMSE", output)
+            self.assertIn("MAE", output)
+            
+        finally:
+            # Ensure stdout is restored even if test fails
+            sys.stdout = sys.__stdout__
+
+
+if __name__ == "__main__":
+    unittest.main()