Comprehensive comparison for AI technology in applications

import numpy as np
from typing import Tuple, Optional
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class NeuralNetworkLayer:
    """
    Production-quality implementation of a neural network layer using NumPy.
    Demonstrates common AI patterns including forward pass, backpropagation,
    and gradient descent optimization.
    """
    
    def __init__(self, input_size: int, output_size: int, learning_rate: float = 0.01):
        """Initialize layer with Xavier initialization for weights."""
        if input_size <= 0 or output_size <= 0:
            raise ValueError("Input and output sizes must be positive integers")
        if learning_rate <= 0:
            raise ValueError("Learning rate must be positive")
            
        # Xavier initialization for better gradient flow
        self.weights = np.random.randn(input_size, output_size) * np.sqrt(2.0 / input_size)
        self.biases = np.zeros((1, output_size))
        self.learning_rate = learning_rate
        
        # Cache for backpropagation
        self.input_cache = None
        self.output_cache = None
        
    def relu(self, x: np.ndarray) -> np.ndarray:
        """ReLU activation function with numerical stability."""
        return np.maximum(0, x)
    
    def relu_derivative(self, x: np.ndarray) -> np.ndarray:
        """Derivative of ReLU for backpropagation."""
        return (x > 0).astype(np.float32)
    
    def forward(self, inputs: np.ndarray) -> np.ndarray:
        """Forward pass through the layer."""
        if inputs.ndim != 2:
            raise ValueError(f"Expected 2D input, got shape {inputs.shape}")
        if inputs.shape[1] != self.weights.shape[0]:
            raise ValueError(f"Input size {inputs.shape[1]} doesn't match weights {self.weights.shape[0]}")
        
        # Cache inputs for backpropagation
        self.input_cache = inputs.copy()
        
        # Linear transformation
        z = np.dot(inputs, self.weights) + self.biases
        
        # Apply activation
        self.output_cache = self.relu(z)
        
        return self.output_cache
    
    def backward(self, grad_output: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        """Backward pass to compute gradients."""
        if self.input_cache is None or self.output_cache is None:
            raise RuntimeError("Must call forward() before backward()")
        
        batch_size = self.input_cache.shape[0]
        
        # Gradient through activation
        grad_activation = grad_output * self.relu_derivative(self.output_cache)
        
        # Compute gradients
        grad_weights = np.dot(self.input_cache.T, grad_activation) / batch_size
        grad_biases = np.sum(grad_activation, axis=0, keepdims=True) / batch_size
        grad_input = np.dot(grad_activation, self.weights.T)
        
        # Gradient clipping for stability
        grad_weights = np.clip(grad_weights, -1.0, 1.0)
        grad_biases = np.clip(grad_biases, -1.0, 1.0)
        
        return grad_input, grad_weights, grad_biases
    
    def update_parameters(self, grad_weights: np.ndarray, grad_biases: np.ndarray) -> None:
        """Update weights and biases using gradient descent."""
        self.weights -= self.learning_rate * grad_weights
        self.biases -= self.learning_rate * grad_biases

# Example usage: Binary classification task
if __name__ == "__main__":
    try:
        # Generate synthetic training data
        np.random.seed(42)
        X_train = np.random.randn(100, 10)  # 100 samples, 10 features
        y_train = (np.sum(X_train, axis=1, keepdims=True) > 0).astype(np.float32)
        
        # Initialize layer
        layer = NeuralNetworkLayer(input_size=10, output_size=1, learning_rate=0.01)
        
        # Training loop
        epochs = 50
        for epoch in range(epochs):
            # Forward pass
            predictions = layer.forward(X_train)
            
            # Compute loss (MSE)
            loss = np.mean((predictions - y_train) ** 2)
            
            # Backward pass
            grad_loss = 2 * (predictions - y_train) / X_train.shape[0]
            grad_input, grad_weights, grad_biases = layer.backward(grad_loss)
            
            # Update parameters
            layer.update_parameters(grad_weights, grad_biases)
            
            if epoch % 10 == 0:
                logger.info(f"Epoch {epoch}, Loss: {loss:.4f}")
        
        logger.info("Training completed successfully")
        
    except Exception as e:
        logger.error(f"Training failed: {str(e)}")
        raise