RiskLabAI 0.0.74__tar.gz → 0.0.78__tar.gz

{RiskLabAI-0.0.74 → risklabai-0.0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: RiskLabAI
-Version: 0.0.74
+Version: 0.0.78
 Summary: Financial AI using Python.
 Home-page: https://github.com/RiskLabAI/RiskLabAI.py
 Author: RiskLab
@@ -12,3 +12,6 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Intended Audience :: Developers
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: scipy
+Requires-Dist: ta
+Requires-Dist: quantecon

{RiskLabAI-0.0.74 → risklabai-0.0.78}/RiskLabAI/backtest/validation/purged_kfold.py

@@ -45,36 +45,43 @@ class PurgedKFold(CrossValidator):
 
         indices_to_drop: Set[int] = set()
         embargo_length = int(len(data_info_range) * embargo_fraction)
+        sorted_test_time_range = test_time_range.sort_index().copy()
 
-        effective_test_time_range = test_time_range if not continous_test_times else pd.Series(test_time_range.iloc[-1], index=[test_time_range.index[0]])
+        if not continous_test_times:
+            sorted_test_time_range = pd.DataFrame({
+                'start' : sorted_test_time_range.index,
+                'end' : sorted_test_time_range.values
+            })
+            # Identify where the new range starts immediately after or before the previous range ends
+            gaps = sorted_test_time_range['start'] > sorted_test_time_range['end'].shift(1)
+            # Cumulative sum to identify contiguous blocks
+            blocks = gaps.cumsum()
+            # Aggregate to find the min start and max end for each block
+            effective_test_time_range = sorted_test_time_range.groupby(blocks).agg({'start': 'min', 'end': 'max'})
+            effective_test_time_range = pd.Series(effective_test_time_range['end'].values, index=effective_test_time_range['start'])
+
+        else:
+            effective_test_time_range = pd.Series(sorted_test_time_range.iloc[-1], index=[sorted_test_time_range.index[0]])
 
         if embargo_length == 0:
-            embargoed_data_info_range = pd.Series(test_time_range.values, index=test_time_range.values)
+            embargoed_data_info_range = pd.Series(effective_test_time_range.values, index=effective_test_time_range.values)
 
         else:
-            effective_sample = data_info_range.loc[test_time_range.index.min():].copy().drop_duplicates()
+            effective_sample = data_info_range.loc[effective_test_time_range.index.min():].copy().drop_duplicates()
             embargoed_data_info_range = pd.Series(effective_sample.values, index=effective_sample.values)
-            embargoed_data_info_range = embargoed_data_info_range.shift(-embargo_length).fillna(embargoed_data_info_range.values[-1]) 
-
-        for start_ix, end_ix in effective_test_time_range.items():
-            # Adding the embargo period
-            end_ix_embargoed = embargoed_data_info_range.loc[end_ix]
-
-            overlapping_start = data_info_range[
-                (start_ix <= data_info_range.index) & (data_info_range.index <= end_ix_embargoed)
-            ].index
+            embargoed_data_info_range = embargoed_data_info_range.shift(-embargo_length).fillna(embargoed_data_info_range.values[-1])   
 
-            overlapping_end = data_info_range[
-                (start_ix <= data_info_range) & (data_info_range <= end_ix_embargoed)
-            ].index
+        effective_ranges = pd.Series(embargoed_data_info_range.loc[effective_test_time_range].values, index=effective_test_time_range.index)
 
-            enveloping = data_info_range[
-                (data_info_range.index <= start_ix) & (end_ix_embargoed <= data_info_range)
-            ].index
+        for start_ix, end_ix_embargoed in effective_ranges.items():
 
-            indices_to_drop.update(overlapping_start)
-            indices_to_drop.update(overlapping_end)
-            indices_to_drop.update(enveloping)
+            indices_to_drop.update(
+                data_info_range[
+                    ((start_ix <= data_info_range.index) & (data_info_range.index <= end_ix_embargoed)) |
+                    ((start_ix <= data_info_range) & (data_info_range <= end_ix_embargoed)) |
+                    ((data_info_range.index <= start_ix) & (end_ix_embargoed <= data_info_range))
+                ].index
+            )
 
         return data_info_range.drop(indices_to_drop)
 

{RiskLabAI-0.0.74 → risklabai-0.0.78}/RiskLabAI/pde/equation.py

@@ -89,8 +89,8 @@ class Equation:
         Tensor: tensor of size [batch_size, 1] containing terminal values
         """
         raise NotImplementedError
-    
-    
+
+
 class PricingDefaultRisk(Equation):
   """
   Args:
@@ -127,7 +127,7 @@ class PricingDefaultRisk(Equation):
     x_sample[:, :, 0] = np.ones([num_sample, self.dim]) * self.x_init
     for i in range(self.num_time_interval):
         x_sample[:, :, i + 1] = (1 + self.mu_bar * self.delta_t) * x_sample[:, :, i] + (
-            self.sigma * x_sample[:, :, i] * dw_sample[:, :, i])
+            self.sigma_matrix(x_sample[:, :, i]) * dw_sample[:, :, i])
     return dw_sample, x_sample
 
   def r_u(self, t, x, y, z)-> torch.Tensor:
@@ -161,7 +161,10 @@ class PricingDefaultRisk(Equation):
       torch.Tensor: tensor of size [batch_size, 1] containing H(z)
       """
       return torch.zeros((x.size()[0],1))
-    
+
+  def sigma_matrix(self,x):
+    return self.sigma * x
+
 
   def terminal(self, t, x)-> torch.Tensor:
     """
@@ -187,7 +190,95 @@ class PricingDefaultRisk(Equation):
     """
     return nn.ReLU()(torch.min(x, 2 , keepdim= True)[0])
 
-  
+
+class HJBLQ(Equation):
+  """
+
+  Args:
+  eqn_config (dict): dictionary containing PDE configuration parameters
+  """
+
+  def __init__(self, eqn_config: dict):
+    super().__init__(eqn_config)
+
+    self.x_init = np.zeros(self.dim)
+    self.sigma = np.sqrt(2.0)
+    self.lambd = 1.0
+
+  def sample(self, num_sample: int) -> tuple:
+    """
+    Sample forward SDE.
+
+    Args:
+    num_sample (int): number of samples to generate
+
+    Returns:
+    tuple: tuple of two tensors: dw_sample of size [num_sample, dim, num_time_interval] and
+    x_sample of size [num_sample, dim, num_time_interval+1]
+    """
+    dw_sample = np.random.normal(size=[num_sample, self.dim, self.num_time_interval]) * self.sqrt_delta_t
+    x_sample = np.zeros([num_sample, self.dim, self.num_time_interval + 1])
+    x_sample[:, :, 0] = np.ones([num_sample, self.dim]) * self.x_init
+    for i in range(self.num_time_interval):
+        x_sample[:, :, i + 1] = x_sample[:, :, i] + self.sigma * dw_sample[:, :, i]
+    return dw_sample, x_sample
+
+  def r_u(self, t: float, x: torch.Tensor, y: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
+    """
+    Interest rate in the PDE.
+
+    Args:
+    t (float): current time
+    x (torch.Tensor): tensor of size [batch_size, dim] containing space coordinates
+    y (torch.Tensor): tensor of size [batch_size, 1] containing function values
+    z (torch.Tensor): tensor of size [batch_size, dim] containing gradients
+
+    Returns:
+    torch.Tensor: tensor of size [batch_size, 1] containing generator values
+    """
+    return torch.ones((x.size()[0],)) * 0
+
+  def h_z(self, t: float, x: torch.Tensor,y: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
+    """
+    Function to compute <h,z> in the PDE.
+
+    Args:
+    t (float): current time
+    x (torch.Tensor): tensor of size [batch_size, dim] containing space coordinates
+    y (torch.Tensor): tensor of size [batch_size, 1] containing function value
+    z (torch.Tensor): tensor of size [batch_size, dim] containing gradients
+
+    Returns:
+    torch.Tensor: tensor of size [batch_size, 1] containing H(z)
+    """
+    return torch.sum(torch.square(z), dim=1)/ (self.sigma**2)
+
+  def terminal(self, t: float, x: torch.Tensor) -> torch.Tensor:
+    """
+    Terminal condition of the PDE.
+
+    Args:
+    t (float): current time
+    x (torch.Tensor): tensor of size [batch_size, dim] containing space coordinates
+
+    Returns:
+    torch.Tensor: tensor of size [batch_size, 1] containing terminal values
+    """
+    return torch.log(0.5 * (1 + torch.norm(x, dim=1)**2))
+  def sigma_matrix(self,x):
+    return self.sigma
+def terminal_for_sample(self, x)-> torch.Tensor:
+    """
+    Terminal condition of the PDE.
+
+    Args:
+    x (torch.Tensor): tensor of size [num_sample,batch_size, dim] containing space coordinates
+
+    Returns:
+    torch.Tensor: tensor of size [num_sample ,batch_size, 1] containing terminal values
+    """
+    return torch.sum(x ** 2, dim=2 ,keepdim=True )
+
 class BlackScholesBarenblatt(Equation):
   """
 
@@ -218,7 +309,7 @@ class BlackScholesBarenblatt(Equation):
     x_sample[:, :, 0] = np.ones((num_sample, self.dim)) * self.x_init
     for i in range(self.num_time_interval):
         x_sample[:, :, i + 1] = (1 + self.mu_bar * self.delta_t) * x_sample[:, :, i] + (
-            self.sigma * x_sample[:, :, i] * dw_sample[:, :, i])
+            self.sigma_matrix(x_sample[:, :, i]) * dw_sample[:, :, i])
     return dw_sample, x_sample
 
   def r_u(self, t: float, x: torch.Tensor, y: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
@@ -263,7 +354,9 @@ class BlackScholesBarenblatt(Equation):
     torch.Tensor: tensor of size [batch_size, 1] containing terminal values
     """
     return torch.sum(x ** 2, dim=1)
-def terminal_for_sample(self, x)-> torch.Tensor:
+  def sigma_matrix(self,x):
+    return self.sigma * x
+  def terminal_for_sample(self, x)-> torch.Tensor:
     """
     Terminal condition of the PDE.
 
@@ -274,6 +367,7 @@ def terminal_for_sample(self, x)-> torch.Tensor:
     torch.Tensor: tensor of size [num_sample ,batch_size, 1] containing terminal values
     """
     return torch.sum(x ** 2, dim=2 ,keepdim=True )
+
 class PricingDiffRate(Equation):
     """
     Nonlinear Black-Scholes equation with different interest rates for borrowing and lending
@@ -319,8 +413,9 @@ class PricingDiffRate(Equation):
 
     def terminal(self, t, x):
         temp = torch.max(x, 1)[0]
-        return torch.maximum(temp - 120, torch.tensor(0))
-
+        return nn.ReLU()(temp - 120) - 2*nn.ReLU()(temp - 150)
+    def sigma_matrix(self,x):
+      return self.sigma * x
     def terminal_for_sample(self, x)-> torch.Tensor:
         """
         Terminal condition of the PDE.
@@ -333,4 +428,3 @@ class PricingDiffRate(Equation):
         """
         temp = torch.max(x, 2 , keep_dim = True)[0]
         return torch.maximum(temp - 120, torch.tensor(0))
-        

{RiskLabAI-0.0.74 → risklabai-0.0.78}/RiskLabAI/pde/model.py

@@ -6,7 +6,7 @@ class TimeNet(Module):
     Neural network model for time dimension
     """
     def __init__(
-            self, 
+            self,
             output_dim: int
     ):
         """
@@ -27,9 +27,10 @@ class TimeNet(Module):
         self.tanh3 = Tanh()
         self.tanh4 = Tanh()
         self.tanh5 = Tanh()
+        self.tanh6 = Tanh()
 
     def forward(
-            self, 
+            self,
             x: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -51,6 +52,7 @@ class TimeNet(Module):
         x = self.layer5(x)
         x = self.tanh5(x)
         x = self.layer6(x)
+        x = self.tanh6(x)
         return x
 
 
@@ -59,8 +61,8 @@ class Net1(Module):
     A class for defining a neural network with a single linear layer.
     """
     def __init__(
-            self, 
-            input_dim: int, 
+            self,
+            input_dim: int,
             output_dim: int
     ):
         """
@@ -76,7 +78,7 @@ class Net1(Module):
         self.bn = BatchNorm1d(output_dim)
 
     def forward(
-            self, 
+            self,
             x: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -99,11 +101,11 @@ For implementing Deep-Time-SetTransformer we have used code written by authors o
 
 class MAB(nn.Module):
     def __init__(
-        self, 
-        dim_q: int, 
-        dim_k: int, 
-        dim_v: int, 
-        num_heads: int, 
+        self,
+        dim_q: int,
+        dim_k: int,
+        dim_v: int,
+        num_heads: int,
         ln: bool = False
     ):
         """
@@ -127,8 +129,8 @@ class MAB(nn.Module):
         self.fc_o = nn.Linear(dim_v, dim_v)
 
     def forward(
-        self, 
-        q: torch.Tensor, 
+        self,
+        q: torch.Tensor,
         k: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -155,10 +157,10 @@ class MAB(nn.Module):
 
 class SAB(nn.Module):
     def __init__(
-        self, 
-        dim_in: int, 
-        dim_out: int, 
-        num_heads: int, 
+        self,
+        dim_in: int,
+        dim_out: int,
+        num_heads: int,
         ln: bool = False
     ):
         """
@@ -173,7 +175,7 @@ class SAB(nn.Module):
         self.mab = MAB(dim_in, dim_in, dim_out, num_heads, ln=ln)
 
     def forward(
-        self, 
+        self,
         x: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -186,11 +188,11 @@ class SAB(nn.Module):
 
 class ISAB(nn.Module):
     def __init__(
-        self, 
-        dim_in: int, 
-        dim_out: int, 
-        num_heads: int, 
-        num_inds: int, 
+        self,
+        dim_in: int,
+        dim_out: int,
+        num_heads: int,
+        num_inds: int,
         ln: bool = False
     ):
         """
@@ -209,7 +211,7 @@ class ISAB(nn.Module):
         self.mab1 = MAB(dim_in, dim_out, dim_out, num_heads, ln=ln)
 
     def forward(
-        self, 
+        self,
         x: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -223,10 +225,10 @@ class ISAB(nn.Module):
 
 class PMA(nn.Module):
     def __init__(
-        self, 
-        dim: int, 
-        num_heads: int, 
-        num_seeds: int, 
+        self,
+        dim: int,
+        num_heads: int,
+        num_seeds: int,
         ln: bool = False
     ):
         """
@@ -243,7 +245,7 @@ class PMA(nn.Module):
         self.mab = MAB(dim, dim, dim, num_heads, ln=ln)
 
     def forward(
-        self, 
+        self,
         x: torch.Tensor
     ) -> torch.Tensor:
         """
@@ -375,12 +377,128 @@ class DeepTimeSetTransformer(nn.Module):
         output = self.time_layer4(t, output)
         output = nn.ReLU()(output)
         output = self.time_layer5(t, output)
-        
+
 
         return output
 import torch
 import torch.nn as nn
 
+
+
+class FBSNNNetwork(nn.Module):
+    def __init__(
+            self,
+            layersize: list[int]
+            ):
+        """
+        Initializes a neural network with multiple blocks.
+
+        Args:
+        - indim (int): input dimension
+        - layersize (List[int]): list of sizes of hidden layers
+        - outdim (int): output dimension
+        """
+        super(FBSNNNetwork, self).__init__()
+
+        # initialize first set of layers
+
+        self.n_layer = len(layersize) - 1
+        # create input layer
+
+        self.layers = nn.ModuleList([])
+        # create hidden layers
+        for i in range(len(layersize) - 1):
+          self.layers.append(nn.Linear(layersize[i], layersize[i + 1]))
+
+    def forward(
+            self,
+            x: torch.Tensor) -> torch.Tensor:
+        """
+        Passes the input through the neural network.
+
+        Args:
+        - x (torch.Tensor): input tensor
+
+        Returns:
+        - torch.Tensor: output tensor
+        """
+
+        for i in range(self.n_layer):
+
+
+
+            # apply layer to tensor
+            x = self.layers[i](x)
+            if i < self.n_layer - 1 :
+              x =torch.sin(x)
+
+        # apply output layer to tensor
+
+
+        return x
+
+
+class DeepBSDE(nn.Module):
+    def __init__(
+            self,
+            layersize: list[int]
+            ):
+        """
+        Initializes a neural network with multiple blocks.
+
+        Args:
+        - indim (int): input dimension
+        - layersize (List[int]): list of sizes of hidden layers
+        - outdim (int): output dimension
+        """
+        super(DeepBSDE, self).__init__()
+
+        # initialize first set of layers
+
+        self.n_layer = len(layersize) - 1
+        # create input layer
+
+        self.layers = nn.ModuleList([])
+        self.batch_layer = nn.ModuleList([])
+        # create hidden layers
+        for i in range(len(layersize) - 1):
+          self.layers.append(nn.Linear(layersize[i], layersize[i + 1] , bias=False))
+          self.batch_layer.append(nn.BatchNorm1d(layersize[i] , eps=1e-06, momentum=0.01))
+
+
+        self.batch_layer.append(nn.BatchNorm1d(layersize[-1] , eps=1e-06, momentum=0.01))
+
+    def forward(
+            self,
+            x: torch.Tensor) -> torch.Tensor:
+        """
+        Passes the input through the neural network.
+
+        Args:
+        - x (torch.Tensor): input tensor
+
+        Returns:
+        - torch.Tensor: output tensor
+        """
+        #x = self.batch_layer[0](x)
+        for i in range(self.n_layer - 1):
+
+            # apply layer to tensor
+            x = self.layers[i](x)
+            #x = self.batch_layer[i+1](x)
+
+
+            x =nn.ReLU()(x)
+
+
+        # apply output layer to tensor
+        x = self.layers[-1](x)
+        #x = self.batch_layer[-1](x)
+
+
+        return x
+
+
 class TimeDependentNetwork(nn.Module):
     def __init__(
             self,
@@ -406,18 +524,20 @@ class TimeDependentNetwork(nn.Module):
         # create input layer
         self.layers.append(Net1(indim, layersize[0]))
         self.time_layer.append(TimeNet(indim))
-        self.batch_layer.append(nn.BatchNorm1d(indim))
-        self.batch_layer.append(nn.BatchNorm1d(layersize[0]))
+        self.batch_layer.append(nn.BatchNorm1d(indim , eps=1e-06, momentum=0.01))
+        self.batch_layer.append(nn.BatchNorm1d(layersize[0],eps=1e-06, momentum=0.01))
 
         # create hidden layers
         for i in range(len(layersize) - 1):
             self.layers.append(Net1(layersize[i], layersize[i + 1]))
             self.time_layer.append(TimeNet(layersize[i]))
-            self.batch_layer.append(nn.BatchNorm1d(layersize[i + 1]))
+            self.batch_layer.append(nn.BatchNorm1d(layersize[i + 1] , eps=1e-06, momentum=0.01))
 
         # create output layer
         self.time_layer.append(TimeNet(outdim))
         self.linear = nn.Linear(layersize[-1], outdim)
+        self.batch_layer.append(nn.BatchNorm1d(outdim , eps=1e-06, momentum=0.01))
+
 
     def forward(
             self,
@@ -433,21 +553,23 @@ class TimeDependentNetwork(nn.Module):
         Returns:
         - torch.Tensor: output tensor
         """
-
         for i in range(self.n_layer):
             # apply time-based weights to input tensor
             time = self.time_layer[i](torch.cat((t, t**2, t**3, torch.exp(t)), 1))
+            x = self.batch_layer[i](x)
+
 
             x = x * (1 + time)
-            # x = self.batch_layer[i](x)
 
             # apply layer to tensor
             x = self.layers[i](x)
-            x = nn.ReLU()(x)
+
+            x = torch.sin(x)
 
         # apply output layer to tensor
 
         x = self.linear(x)
+        #x = self.batch_layer[-1](x)
 
         return x