quantmllibrary 0.1.0__py3-none-any.whl

quantml/models/normalization.py

@@ -0,0 +1,289 @@
+"""
+Normalization layers.
+
+Implementations of Batch Normalization and Layer Normalization.
+"""
+
+from typing import Optional, List, Union
+import math
+from quantml.tensor import Tensor
+from quantml import ops
+
+
+class BatchNorm1d:
+    """
+    Batch Normalization for 2D or 3D inputs.
+    
+    y = (x - mean) / sqrt(var + eps) * gamma + beta
+    
+    Attributes:
+        num_features: Number of features in input
+        eps: Small value for stability
+        momentum: Momentum for running stats (default: 0.1)
+        affine: Whether to learn gamma and beta
+        track_running_stats: Whether to track running mean/var
+    
+    Examples:
+        >>> bn = BatchNorm1d(10)
+        >>> x = Tensor([[1.0] * 10])
+        >>> y = bn.forward(x)
+    """
+    
+    def __init__(
+        self,
+        num_features: int,
+        eps: float = 1e-5,
+        momentum: float = 0.1,
+        affine: bool = True,
+        track_running_stats: bool = True
+    ):
+        self.num_features = num_features
+        self.eps = eps
+        self.momentum = momentum
+        self.affine = affine
+        self.track_running_stats = track_running_stats
+        self.training = True
+        
+        # Learnable parameters
+        if affine:
+            self.gamma = Tensor([1.0] * num_features, requires_grad=True)
+            self.beta = Tensor([0.0] * num_features, requires_grad=True)
+        else:
+            self.gamma = None
+            self.beta = None
+        
+        # Running stats (not trainable)
+        if track_running_stats:
+            self.running_mean = Tensor([0.0] * num_features, requires_grad=False)
+            self.running_var = Tensor([1.0] * num_features, requires_grad=False)
+            self.num_batches_tracked = 0
+        else:
+            self.running_mean = None
+            self.running_var = None
+    
+    def forward(self, x: Tensor) -> Tensor:
+        """
+        Forward pass.
+        
+        Args:
+            x: Input tensor (batch_size x num_features) or (batch x seq x features)
+        
+        Returns:
+            Normalized tensor
+        """
+        # Handle 3D input (batch, seq, features) by flattening
+        original_shape = None
+        data = x.data
+        if isinstance(data[0], list) and isinstance(data[0][0], list):
+            # 3D input
+            batch_size = len(data)
+            seq_len = len(data[0])
+            features = len(data[0][0])
+            if features != self.num_features:
+                raise ValueError(f"Expected {self.num_features} features, got {features}")
+            
+            # Flatten to (batch*seq, features)
+            flat_data = [row for batch in data for row in batch]
+            x_flat = Tensor(flat_data, requires_grad=x.requires_grad)
+            original_shape = (batch_size, seq_len, features)
+            
+            # Recurse with flattened input
+            out_flat = self._forward_2d(x_flat)
+            
+            # Reshape back directly using list comprehension
+            flat_out_data = out_flat.data
+            out_data = [
+                [flat_out_data[b * seq_len + t] for t in range(seq_len)]
+                for b in range(batch_size)
+            ]
+            
+            # Note: We lose gradient history through reshaping in pure Python
+            # unless we implement a proper Reshape op. For now, we return
+            # a new tensor which breaks the graph for 3D inputs.
+            # TODO: Implement Reshape/View op for full autograd support
+            
+            return Tensor(
+                out_data, 
+                requires_grad=out_flat.requires_grad,
+                _prev={out_flat} if out_flat.requires_grad else set(),
+                _op='reshape'
+            )
+        else:
+            # 2D input
+            return self._forward_2d(x)
+
+    def _forward_2d(self, x: Tensor) -> Tensor:
+        """Forward pass for 2D input."""
+        # Calculate mean and var
+        if self.training and self.track_running_stats:
+            # Current batch stats
+            batch_mean = ops.mean(x, axis=0)
+            batch_var = ops.var(x, axis=0, unbiased=False)
+            
+            # Update running stats (no grad)
+            n = x.data.shape[0] if hasattr(x.data, 'shape') else len(x.data)
+            
+            # Manual update to avoid graph creation
+            if self.running_mean is not None:
+                m = self.momentum
+                # running_mean = (1 - m) * running_mean + m * batch_mean
+                # Done manually on data
+                rm_data = self.running_mean.data
+                bm_data = batch_mean.data[0] if isinstance(batch_mean.data[0], list) else batch_mean.data
+                
+                new_rm = [
+                    (1 - m) * float(rm_data[i]) + m * float(bm_data[i])
+                    for i in range(self.num_features)
+                ]
+                self.running_mean._data = new_rm
+            
+            if self.running_var is not None:
+                m = self.momentum
+                # running_var = (1 - m) * running_var + m * batch_var * (n / (n-1))
+                rv_data = self.running_var.data
+                bv_data = batch_var.data[0] if isinstance(batch_var.data[0], list) else batch_var.data
+                
+                unbiased_factor = n / (n - 1) if n > 1 else 1.0
+                new_rv = [
+                    (1 - m) * float(rv_data[i]) + m * float(bv_data[i]) * unbiased_factor
+                    for i in range(self.num_features)
+                ]
+                self.running_var._data = new_rv
+                
+            self.num_batches_tracked += 1
+            
+            # Use batch stats for normalization
+            mean = batch_mean
+            var = batch_var
+        else:
+            # Use running stats
+            if self.running_mean is not None:
+                mean = self.running_mean
+                var = self.running_var
+            else:
+                # No running stats, compute batch stats
+                mean = ops.mean(x, axis=0)
+                var = ops.var(x, axis=0, unbiased=False)
+        
+        # Normalize: (x - mean) / sqrt(var + eps)
+        # Add eps
+        var_plus_eps = ops.add(var, self.eps)
+        std = ops.pow(var_plus_eps, 0.5)
+        
+        x_centered = ops.sub(x, mean)
+        x_norm = ops.div(x_centered, std)
+        
+        # Scale and shift
+        if self.affine and self.gamma is not None and self.beta is not None:
+            # Expand gamma and beta for broadcasting
+            # gamma is (features,), x_norm is (batch, features)
+            # We construct a (features,) tensor that works with broadcasting
+            out = ops.mul(x_norm, self.gamma)
+            out = ops.add(out, self.beta)
+            return out
+        else:
+            return x_norm
+    
+    def train(self, mode: bool = True) -> 'BatchNorm1d':
+        """Set training mode."""
+        self.training = mode
+        return self
+    
+    def eval(self) -> 'BatchNorm1d':
+        """Set evaluation mode."""
+        return self.train(False)
+    
+    def parameters(self) -> List[Tensor]:
+        """Get trainable parameters."""
+        params = []
+        if self.affine:
+            if self.gamma is not None: params.append(self.gamma)
+            if self.beta is not None: params.append(self.beta)
+        return params
+    
+    def zero_grad(self) -> None:
+        """Clear gradients."""
+        for p in self.parameters():
+            p.zero_grad()
+
+
+class LayerNorm:
+    """
+    Layer Normalization.
+    
+    y = (x - mean) / sqrt(var + eps) * gamma + beta
+    
+    Applied over the last dimension.
+    
+    Attributes:
+        normalized_shape: Input shape (int or list)
+        eps: Small value for stability
+        elementwise_affine: Whether to learn gamma and beta
+    """
+    
+    def __init__(
+        self,
+        normalized_shape: Union[int, List[int]],
+        eps: float = 1e-5,
+        elementwise_affine: bool = True
+    ):
+        if isinstance(normalized_shape, int):
+            self.normalized_shape = [normalized_shape]
+        else:
+            self.normalized_shape = list(normalized_shape)
+            
+        self.eps = eps
+        self.elementwise_affine = elementwise_affine
+        
+        # Total number of elements in normalized shape
+        self.num_elements = 1
+        for dim in self.normalized_shape:
+            self.num_elements *= dim
+            
+        if elementwise_affine:
+            self.gamma = Tensor([1.0] * self.num_elements, requires_grad=True)
+            self.beta = Tensor([0.0] * self.num_elements, requires_grad=True)
+        else:
+            self.gamma = None
+            self.beta = None
+    
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward pass."""
+        # Mean and var over last dim(s)
+        # For simplicity, we assume normalized_shape corresponds to the last dimension(s)
+        # and we currently only support 1D normalized_shape (last dim)
+        
+        axis = -1
+        mean = ops.mean(x, axis=axis)
+        var = ops.var(x, axis=axis, unbiased=False)
+        
+        # Add eps
+        var_plus_eps = ops.add(var, self.eps)
+        std = ops.pow(var_plus_eps, 0.5)
+        
+        # Normalize
+        # We need to reshape mean/std to broadcast correctly if they were reduced
+        # ops.sub and ops.div should handle broadcasting if implemented correctly
+        x_centered = ops.sub(x, mean)
+        x_norm = ops.div(x_centered, std)
+        
+        # Scale and shift
+        if self.elementwise_affine:
+            out = ops.mul(x_norm, self.gamma)
+            out = ops.add(out, self.beta)
+            return out
+        else:
+            return x_norm
+            
+    def parameters(self) -> List[Tensor]:
+        """Get trainable parameters."""
+        params = []
+        if self.elementwise_affine:
+            if self.gamma is not None: params.append(self.gamma)
+            if self.beta is not None: params.append(self.beta)
+        return params
+            
+    def zero_grad(self) -> None:
+        """Clear gradients."""
+        for p in self.parameters():
+            p.zero_grad()

quantml/models/rnn.py

@@ -0,0 +1,154 @@
+"""
+Simple RNN (Recurrent Neural Network) implementation.
+
+This module provides a basic RNN cell suitable for time-series prediction
+in quantitative trading.
+"""
+
+from typing import Optional
+import math
+from quantml.tensor import Tensor
+from quantml import ops
+from quantml.models.linear import Linear
+
+
+class SimpleRNN:
+    """
+    Simple RNN cell for sequence processing.
+    
+    The RNN maintains a hidden state and processes sequences one step at a time:
+    h_t = tanh(x_t @ W_xh + h_{t-1} @ W_hh + b)
+    
+    Attributes:
+        input_size: Size of input features
+        hidden_size: Size of hidden state
+        weight_ih: Input-to-hidden weights
+        weight_hh: Hidden-to-hidden weights
+        bias: Bias term
+    
+    Examples:
+        >>> rnn = SimpleRNN(10, 20)
+        >>> x = Tensor([[1.0] * 10])
+        >>> h = rnn.forward(x)  # Initial hidden state
+    """
+    
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True
+    ):
+        """
+        Initialize RNN cell.
+        
+        Args:
+            input_size: Number of input features
+            hidden_size: Size of hidden state
+            bias: Whether to include bias term
+        """
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.bias = bias
+        
+        # Initialize weights
+        # Input-to-hidden: (hidden_size, input_size)
+        limit_ih = math.sqrt(1.0 / input_size)
+        weight_ih_data = [[(2.0 * limit_ih * (i * input_size + j) / (input_size * hidden_size) - limit_ih)
+                          for j in range(input_size)]
+                         for i in range(hidden_size)]
+        self.weight_ih = Tensor(weight_ih_data, requires_grad=True)
+        
+        # Hidden-to-hidden: (hidden_size, hidden_size)
+        limit_hh = math.sqrt(1.0 / hidden_size)
+        weight_hh_data = [[(2.0 * limit_hh * (i * hidden_size + j) / (hidden_size * hidden_size) - limit_hh)
+                           for j in range(hidden_size)]
+                          for i in range(hidden_size)]
+        self.weight_hh = Tensor(weight_hh_data, requires_grad=True)
+        
+        # Bias
+        if bias:
+            bias_data = [[0.0] for _ in range(hidden_size)]
+            self.bias_param = Tensor(bias_data, requires_grad=True)
+        else:
+            self.bias_param = None
+        
+        # Hidden state (initialized to zeros)
+        self.hidden = None
+    
+    def forward(self, x: Tensor, hidden: Optional[Tensor] = None) -> Tensor:
+        """
+        Forward pass through RNN cell.
+        
+        Args:
+            x: Input tensor (batch_size x input_size)
+            hidden: Optional previous hidden state (batch_size x hidden_size)
+        
+        Returns:
+            New hidden state (batch_size x hidden_size)
+        """
+        # Initialize hidden state if not provided
+        if hidden is None:
+            if self.hidden is None:
+                # Create zero hidden state
+                batch_size = len(x.data) if isinstance(x.data[0], list) else 1
+                hidden_data = [[0.0] * self.hidden_size for _ in range(batch_size)]
+                hidden = Tensor(hidden_data)
+            else:
+                hidden = self.hidden
+        
+        # Ensure x is 2D
+        x_data = x.data if isinstance(x.data[0], list) else [x.data]
+        x_2d = Tensor(x_data)
+        
+        # Input-to-hidden: x @ W_ih^T
+        weight_ih_T = self._transpose(self.weight_ih)
+        ih = ops.matmul(x_2d, weight_ih_T)
+        
+        # Hidden-to-hidden: h @ W_hh^T
+        weight_hh_T = self._transpose(self.weight_hh)
+        hh = ops.matmul(hidden, weight_hh_T)
+        
+        # Combine
+        combined = ops.add(ih, hh)
+        
+        # Add bias
+        if self.bias and self.bias_param is not None:
+            combined = ops.add(combined, self.bias_param)
+        
+        # Apply tanh activation
+        new_hidden = ops.tanh(combined)
+        
+        # Store hidden state
+        self.hidden = new_hidden
+        
+        return new_hidden
+    
+    def _transpose(self, t: Tensor) -> Tensor:
+        """Transpose a 2D tensor."""
+        if not isinstance(t.data[0], list):
+            data = [t.data]
+        else:
+            data = t.data
+        
+        transposed = [[data[j][i] for j in range(len(data))] 
+                     for i in range(len(data[0]))]
+        return Tensor(transposed, requires_grad=t.requires_grad)
+    
+    def reset_hidden(self):
+        """Reset hidden state to zeros."""
+        self.hidden = None
+    
+    def parameters(self) -> list:
+        """Get all trainable parameters."""
+        params = [self.weight_ih, self.weight_hh]
+        if self.bias and self.bias_param is not None:
+            params.append(self.bias_param)
+        return params
+    
+    def zero_grad(self):
+        """Clear gradients for all parameters."""
+        self.weight_ih.zero_grad()
+        self.weight_hh.zero_grad()
+        if self.bias_param is not None:
+            self.bias_param.zero_grad()
+

quantml/models/tcn.py

@@ -0,0 +1,238 @@
+"""
+Temporal Convolutional Network (TCN) implementation.
+
+TCN uses causal convolutions with dilation for sequence modeling,
+making it suitable for time-series prediction in quant trading.
+"""
+
+from typing import List, Optional
+import math
+from quantml.tensor import Tensor
+from quantml import ops
+
+
+class TCNBlock:
+    """
+    A single TCN block with causal convolution and residual connection.
+    
+    TCN blocks use dilated convolutions to capture long-range dependencies
+    while maintaining causality (no future information leakage).
+    
+    Attributes:
+        in_channels: Number of input channels
+        out_channels: Number of output channels
+        kernel_size: Convolution kernel size
+        dilation: Dilation rate
+        stride: Stride (usually 1)
+    
+    Examples:
+        >>> block = TCNBlock(10, 20, kernel_size=3, dilation=1)
+        >>> x = Tensor([[1.0] * 10])
+        >>> out = block.forward(x)
+    """
+    
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int = 3,
+        dilation: int = 1,
+        stride: int = 1
+    ):
+        """
+        Initialize TCN block.
+        
+        Args:
+            in_channels: Number of input channels
+            out_channels: Number of output channels
+            kernel_size: Size of convolution kernel
+            dilation: Dilation rate for causal convolution
+            stride: Stride (typically 1)
+        """
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.dilation = dilation
+        self.stride = stride
+        
+        # Initialize convolution weights
+        # For simplicity, we'll use a linear layer approach
+        # In a full implementation, this would be a proper convolution
+        limit = math.sqrt(1.0 / (in_channels * kernel_size))
+        weight_data = [[[(2.0 * limit * (i * out_channels * kernel_size + 
+                                         j * kernel_size + k) / 
+                           (in_channels * out_channels * kernel_size) - limit)
+                         for k in range(kernel_size)]
+                        for j in range(in_channels)]
+                       for i in range(out_channels)]
+        
+        # Flatten for matrix multiplication
+        self.weight = Tensor(weight_data, requires_grad=True)
+        
+        # Bias
+        bias_data = [[0.0] for _ in range(out_channels)]
+        self.bias = Tensor(bias_data, requires_grad=True)
+    
+    def forward(self, x: Tensor) -> Tensor:
+        """
+        Forward pass through TCN block.
+        
+        Implements causal convolution with optional residual connection.
+        
+        Args:
+            x: Input tensor (batch_size x seq_len x in_channels)
+        
+        Returns:
+            Output tensor (batch_size x seq_len x out_channels)
+        """
+        # For simplicity, we'll implement a basic version
+        # A full TCN would implement proper causal dilated convolution
+        
+        # Ensure 2D input
+        x_data = x.data if isinstance(x.data[0], list) else [x.data]
+        x_2d = Tensor(x_data)
+        
+        # Simple linear transformation (simplified convolution)
+        # In full implementation, this would be a proper causal convolution
+        weight_flat = self._flatten_weight()
+        weight_T = self._transpose(weight_flat)
+        
+        # Apply transformation
+        out = ops.matmul(x_2d, weight_T)
+        
+        # Add bias
+        out = ops.add(out, self.bias)
+        
+        # Apply activation (ReLU)
+        out = ops.relu(out)
+        
+        # Residual connection if dimensions match
+        if self.in_channels == self.out_channels:
+            out = ops.add(out, x_2d)
+        
+        return out
+    
+    def _flatten_weight(self) -> Tensor:
+        """Flatten weight tensor for matrix multiplication."""
+        # Flatten kernel dimension
+        flat_data = []
+        for out_ch in range(self.out_channels):
+            row = []
+            for in_ch in range(self.in_channels):
+                for k in range(self.kernel_size):
+                    row.append(self.weight.data[out_ch][in_ch][k])
+            flat_data.append(row)
+        return Tensor(flat_data, requires_grad=self.weight.requires_grad)
+    
+    def _transpose(self, t: Tensor) -> Tensor:
+        """Transpose a 2D tensor."""
+        if not isinstance(t.data[0], list):
+            data = [t.data]
+        else:
+            data = t.data
+        
+        transposed = [[data[j][i] for j in range(len(data))] 
+                     for i in range(len(data[0]))]
+        return Tensor(transposed, requires_grad=t.requires_grad)
+    
+    def parameters(self) -> list:
+        """Get all trainable parameters."""
+        return [self.weight, self.bias]
+    
+    def zero_grad(self):
+        """Clear gradients for all parameters."""
+        self.weight.zero_grad()
+        self.bias.zero_grad()
+
+
+class TCN:
+    """
+    Full TCN model with multiple stacked blocks.
+    
+    A TCN consists of multiple TCNBlock layers stacked together,
+    with increasing dilation rates to capture multi-scale patterns.
+    
+    Attributes:
+        blocks: List of TCN blocks
+        input_size: Input feature size
+        output_size: Output feature size
+    
+    Examples:
+        >>> tcn = TCN(input_size=10, hidden_sizes=[20, 20], output_size=1)
+        >>> x = Tensor([[1.0] * 10])
+        >>> y = tcn.forward(x)
+    """
+    
+    def __init__(
+        self,
+        input_size: int,
+        hidden_sizes: List[int],
+        output_size: int,
+        kernel_size: int = 3
+    ):
+        """
+        Initialize TCN model.
+        
+        Args:
+            input_size: Number of input features
+            hidden_sizes: List of hidden layer sizes
+            output_size: Number of output features
+            kernel_size: Convolution kernel size
+        """
+        self.input_size = input_size
+        self.output_size = output_size
+        
+        # Build TCN blocks
+        self.blocks = []
+        in_channels = input_size
+        
+        for i, hidden_size in enumerate(hidden_sizes):
+            dilation = 2 ** i  # Exponential dilation
+            block = TCNBlock(in_channels, hidden_size, kernel_size, dilation)
+            self.blocks.append(block)
+            in_channels = hidden_size
+        
+        # Output layer
+        from quantml.models.linear import Linear
+        self.output_layer = Linear(in_channels, output_size)
+    
+    def forward(self, x: Tensor) -> Tensor:
+        """
+        Forward pass through TCN.
+        
+        Args:
+            x: Input tensor (batch_size x seq_len x input_size)
+        
+        Returns:
+            Output tensor (batch_size x output_size)
+        """
+        # Pass through TCN blocks
+        out = x
+        for block in self.blocks:
+            out = block.forward(out)
+        
+        # Global pooling (mean over sequence) and output layer
+        # For simplicity, take last timestep
+        if isinstance(out.data[0], list):
+            # Take last element of sequence
+            last = Tensor([[out.data[i][-1] for i in range(len(out.data))]])
+        else:
+            last = out
+        
+        output = self.output_layer.forward(last)
+        return output
+    
+    def parameters(self) -> list:
+        """Get all trainable parameters."""
+        params = []
+        for block in self.blocks:
+            params.extend(block.parameters())
+        params.extend(self.output_layer.parameters())
+        return params
+    
+    def zero_grad(self):
+        """Clear gradients for all parameters."""
+        for block in self.blocks:
+            block.zero_grad()
+        self.output_layer.zero_grad()
+