dsipts 1.1.7__tar.gz → 1.1.9__tar.gz

{dsipts-1.1.7 → dsipts-1.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsipts
-Version: 1.1.7
+Version: 1.1.9
 Summary: Unified library for timeseries modelling
 Author-email: Andrea Gobbi <agobbi@fbk.eu>
 Project-URL: Homepage, https://github.com/DSIP-FBK/DSIPTS
@@ -356,6 +356,9 @@ loss, quantile loss, MDA and a couple of experimental losses for minimizing the
 # Bash experiment
 Most of the time you want to train the models in a cluster with a GPU and command line training procedure can help speedup the process. DSIPTS leverages on OmegaConf-Hydra to to this and in the folder `bash_examples` you can find an examples. Please read the documentation [here](/bash_examples/README.md)
 
+## Losses
+
+- `dilated`: `persistence_weight` between 0 and 1
 
 
 # Modifiers
@@ -366,13 +369,7 @@ The VVA model is composed by two steps: the first is a clusterting procedure tha
 - **inverse_transform**: the output of the model are reverted to the original shape. In the VVA model the centroids are used for reconstruct the predicted timeseries.
 
 
-## Documentation
-You can find the documentation [here](https://dsip.pages.fbk.eu/dsip_dlresearch/timeseries/):
-or  in the folder `docs/_build/html/index.html`
-If yon need to generate the documentation after some modification just run:
-```
-./make_doc.sh    
-```
+
 
 For user only: be sure that the the CI file has pages enabled, see [public pages](https://roneo.org/en/gitlab-public-pages-private-repo/)
 

{dsipts-1.1.7 → dsipts-1.1.9}/README.md

@@ -324,6 +324,9 @@ loss, quantile loss, MDA and a couple of experimental losses for minimizing the
 # Bash experiment
 Most of the time you want to train the models in a cluster with a GPU and command line training procedure can help speedup the process. DSIPTS leverages on OmegaConf-Hydra to to this and in the folder `bash_examples` you can find an examples. Please read the documentation [here](/bash_examples/README.md)
 
+## Losses
+
+- `dilated`: `persistence_weight` between 0 and 1
 
 
 # Modifiers
@@ -334,13 +337,7 @@ The VVA model is composed by two steps: the first is a clusterting procedure tha
 - **inverse_transform**: the output of the model are reverted to the original shape. In the VVA model the centroids are used for reconstruct the predicted timeseries.
 
 
-## Documentation
-You can find the documentation [here](https://dsip.pages.fbk.eu/dsip_dlresearch/timeseries/):
-or  in the folder `docs/_build/html/index.html`
-If yon need to generate the documentation after some modification just run:
-```
-./make_doc.sh    
-```
+
 
 For user only: be sure that the the CI file has pages enabled, see [public pages](https://roneo.org/en/gitlab-public-pages-private-repo/)
 

{dsipts-1.1.7 → dsipts-1.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dsipts"
-version = "1.1.7"
+version = "1.1.9"
 description = "Unified library for timeseries modelling"
 readme = "README.md"
 requires-python = "==3.11.13"

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/__init__.py

@@ -25,7 +25,7 @@ from .models.TimeXER import TimeXER
 from .models.TTM import TTM
 from .models.Samformer import Samformer
 from .models.Duet import Duet
-
+from .models.Simple import Simple
 try:
     import lightning.pytorch as pl
     from .models.base_v2 import Base
@@ -44,5 +44,5 @@ __all__ = [
     "RNN", "LinearTS", "Persistent", "D3VAE", "DilatedConv", "TFT",
     "Informer", "VVA", "VQVAEA", "CrossFormer", "Autoformer", "PatchTST",
     "Diffusion", "DilatedConvED", "TIDE", "ITransformer", "TimeXER",
-    "TTM", "Samformer", "Duet", "Base"
+    "TTM", "Samformer", "Duet", "Base", "Simple"
 ]

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/data_structure/data_structure.py

@@ -800,7 +800,7 @@ class TimeSeries():
                                 callbacks=[checkpoint_callback,mc],
                                 auto_lr_find=auto_lr_find, 
                                 accelerator=accelerator,
-                                log_every_n_steps=5,
+                                log_every_n_steps=1,
                                 devices=devices,
                                 strategy=strategy,
                                 enable_progress_bar=False,

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/models/RNN.py

@@ -16,7 +16,7 @@ from ..data_structure.utils import beauty_string
 from .utils import  get_scope
 from .xlstm.xLSTM import xLSTM
 from .utils import Embedding_cat_variables
-
+torch.autograd.set_detect_anomaly(True)
 
 class MyBN(nn.Module):
     def __init__(self,channels):

dsipts-1.1.9/src/dsipts/models/Simple.py

@@ -0,0 +1,113 @@
+
+## Copyright 2022 DLinear Authors (https://github.com/cure-lab/LTSF-Linear/tree/main?tab=Apache-2.0-1-ov-file#readme)
+## Code modified for align the notation and the batch generation
+## extended to all present in informer, autoformer folder
+
+from torch import nn
+import torch
+
+try:
+    import lightning.pytorch as pl
+    from .base_v2 import Base
+    OLD_PL = False
+except:
+    import pytorch_lightning as pl
+    OLD_PL = True
+    from .base import Base
+from .utils import QuantileLossMO, get_activation
+from typing import List, Union
+from ..data_structure.utils import beauty_string
+from .utils import  get_scope
+from .utils import Embedding_cat_variables
+    
+
+
+
+class Simple(Base):
+    handle_multivariate = True
+    handle_future_covariates = True
+    handle_categorical_variables = True
+    handle_quantile_loss = True
+    description = get_scope(handle_multivariate,handle_future_covariates,handle_categorical_variables,handle_quantile_loss)
+    description+='\n THE SIMPLE IMPLEMENTATION DOES NOT USE CATEGORICAL NOR FUTURE VARIABLES'
+    
+    def __init__(self, 
+               
+                 hidden_size:int,
+                 dropout_rate:float=0.1,
+                 activation:str='torch.nn.ReLU',
+
+
+                 **kwargs)->None:
+       
+        super().__init__(**kwargs)
+
+        if activation == 'torch.nn.SELU':
+            beauty_string('SELU do not require BN','info',self.verbose)
+            use_bn = False
+            
+        if isinstance(activation, str):
+            activation = get_activation(activation)
+        else:
+            beauty_string('There is a bug in pytorch lightening, the constructior is called twice','info',self.verbose)
+        
+        self.save_hyperparameters(logger=False)
+      
+        
+       
+        self.emb_past = Embedding_cat_variables(self.past_steps,self.emb_dim,self.embs_past, reduction_mode=self.reduction_mode,use_classical_positional_encoder=self.use_classical_positional_encoder,device = self.device)
+        self.emb_fut = Embedding_cat_variables(self.future_steps,self.emb_dim,self.embs_fut, reduction_mode=self.reduction_mode,use_classical_positional_encoder=self.use_classical_positional_encoder,device = self.device)
+        emb_past_out_channel = self.emb_past.output_channels
+        emb_fut_out_channel = self.emb_fut.output_channels
+
+
+
+
+
+        self.linear = (nn.Sequential(nn.Linear(emb_past_out_channel*self.past_steps+emb_fut_out_channel*self.future_steps+self.past_steps*self.past_channels+self.future_channels*self.future_steps,hidden_size),
+                                                    activation(),nn.Dropout(dropout_rate),
+                                                    nn.Linear(hidden_size,self.out_channels*self.future_steps*self.mul)))
+                               
+    def forward(self, batch):
+      
+        x =  batch['x_num_past'].to(self.device)
+        
+        BS = x.shape[0]
+        if 'x_cat_future' in batch.keys():
+            emb_fut = self.emb_fut(BS,batch['x_cat_future'].to(self.device))
+        else:
+            emb_fut = self.emb_fut(BS,None)
+        if 'x_cat_past' in batch.keys():
+            emb_past = self.emb_past(BS,batch['x_cat_past'].to(self.device))
+        else:
+            emb_past = self.emb_past(BS,None)
+        
+        
+            
+
+        if 'x_num_future' in batch.keys():
+            x_future = batch['x_num_future'].to(self.device)
+        else:
+            x_future = None
+            
+        tmp = [x,emb_past]
+        tot_past = torch.cat(tmp,2).flatten(1)
+        
+
+
+        tmp = [emb_fut]
+                          
+        if x_future is not None:
+            tmp.append(x_future)
+           
+        tot_future = torch.cat(tmp,2).flatten(1)
+        tot = torch.cat([tot_past,tot_future],1)
+
+                    
+        res = self.linear(tot)
+        res = res.reshape(BS,self.future_steps,-1,self.mul)
+       
+        ##
+
+        return res
+    

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/models/base.py

@@ -12,7 +12,7 @@ import numpy as np
 from aim import Image
 import matplotlib.pyplot as plt
 from typing import List, Union
-from .utils import QuantileLossMO
+from .utils import QuantileLossMO, CPRS
 import torch.nn as nn
 
 def standardize_momentum(x,order):
@@ -135,10 +135,15 @@ class Base(pl.LightningModule):
         if n_classes==0:
             self.is_classification = False
             if len(self.quantiles)>0:
-                assert len(self.quantiles)==3, beauty_string('ONLY 3 quantiles premitted','info',True)
-                self.use_quantiles = True
-                self.mul = len(self.quantiles)
-                self.loss = QuantileLossMO(quantiles)
+                if self.loss_type=='cprs':
+                    self.use_quantiles = False
+                    self.mul = len(self.quantiles)
+                    self.loss = CPRS()
+                else:
+                    assert len(self.quantiles)==3, beauty_string('ONLY 3 quantiles premitted','info',True)
+                    self.use_quantiles = True
+                    self.mul = len(self.quantiles)
+                    self.loss = QuantileLossMO(quantiles)
             else:
                 self.use_quantiles = False
                 self.mul = 1
@@ -186,6 +191,10 @@ class Base(pl.LightningModule):
         Returns:
             torch.tensor: result
         """
+        if self.loss_type=='cprs':
+            tmp = self(batch)
+            return tmp.mean(axis=-1)
+        
         return self(batch)
         
     def configure_optimizers(self):
@@ -357,6 +366,14 @@ class Base(pl.LightningModule):
         :meta private:
         """
 
+        if self.loss_type=='cprs':
+            return self.loss(y_hat,batch['y'])
+
+        if self.loss_type=='long_lag':
+            batch_size,width,n_variables = batch['y'].shape
+            tmp = torch.abs(y_hat[:,:,:,0]-batch['y'])*torch.linspace(1,self.persistence_weight,width).view(1,width,1).repeat(batch_size,1,n_variables)
+            return tmp.mean()
+
         if self.use_quantiles is False:
             initial_loss = self.loss(y_hat[:,:,:,0], batch['y'])
         else:
@@ -428,12 +445,7 @@ class Base(pl.LightningModule):
             
         elif self.loss_type=='dilated':
             #BxLxCxMUL
-            if self.persistence_weight==0.1:
-                alpha = 0.25
-            if self.persistence_weight==1:
-                alpha = 0.5
-            else:
-                alpha  =0.75
+ 
             alpha = self.persistence_weight 
             gamma = 0.01
             loss = 0
@@ -444,8 +456,8 @@ class Base(pl.LightningModule):
                 loss+= dilate_loss( batch['y'][:,:,i:i+1],x[:,:,i:i+1], alpha, gamma, y_hat.device)
             
         elif self.loss_type=='huber':
-            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight/10)   
-            #loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+
             if self.use_quantiles is False:
                 x = y_hat[:,:,:,0]
             else:

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/models/base_v2.py

@@ -12,7 +12,7 @@ import numpy as np
 from aim import Image
 import matplotlib.pyplot as plt
 from typing import List, Union
-from .utils import QuantileLossMO
+from .utils import QuantileLossMO, CPRS
 import torch.nn as nn
 
 
@@ -137,10 +137,15 @@ class Base(pl.LightningModule):
         if n_classes==0:
             self.is_classification = False
             if len(self.quantiles)>0:
-                assert len(self.quantiles)==3, beauty_string('ONLY 3 quantiles premitted','info',True)
-                self.use_quantiles = True
-                self.mul = len(self.quantiles)
-                self.loss = QuantileLossMO(quantiles)
+                if self.loss_type=='cprs':
+                    self.use_quantiles = False
+                    self.mul = len(self.quantiles)
+                    self.loss = CPRS()
+                else:
+                    assert len(self.quantiles)==3, beauty_string('ONLY 3 quantiles premitted','info',True)
+                    self.use_quantiles = True
+                    self.mul = len(self.quantiles)
+                    self.loss = QuantileLossMO(quantiles)
             else:
                 self.use_quantiles = False
                 self.mul = 1
@@ -189,6 +194,11 @@ class Base(pl.LightningModule):
         Returns:
             torch.tensor: result
         """
+        
+        if self.loss_type=='cprs':
+            tmp = self(batch)
+            return tmp.mean(axis=-1)
+        
         return self(batch)
         
     def configure_optimizers(self):
@@ -365,6 +375,16 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
+        if self.loss_type=='cprs':
+            return self.loss(y_hat,batch['y'])
+
+        if self.loss_type=='long_lag':
+
+            batch_size,width,n_variables = batch['y'].shape
+            tmp = torch.abs(y_hat[:,:,:,0]-batch['y'])*torch.linspace(1,self.persistence_weight,width).view(1,width,1).repeat(batch_size,1,n_variables)
+            return tmp.mean()
+
+
 
         if self.use_quantiles is False:
             initial_loss = self.loss(y_hat[:,:,:,0], batch['y'])
@@ -437,24 +457,16 @@ class Base(pl.LightningModule):
             
         elif self.loss_type=='dilated':
             #BxLxCxMUL
-            if self.persistence_weight==0.1:
-                alpha = 0.25
-            if self.persistence_weight==1:
-                alpha = 0.5
-            else:
-                alpha  =0.75
+
             alpha = self.persistence_weight 
             gamma = 0.01
             loss = 0
             ##no multichannel here
-            for i in range(y_hat.shape[2]):
-                ##error here
-                
+            for i in range(y_hat.shape[2]):                
                 loss+= dilate_loss( batch['y'][:,:,i:i+1],x[:,:,i:i+1], alpha, gamma, y_hat.device)
             
         elif self.loss_type=='huber':
-            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight/10)   
-            #loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
             if self.use_quantiles is False:
                 x = y_hat[:,:,:,0]
             else:

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts/models/utils.py

@@ -621,4 +621,76 @@ class Embedding_cat_variables(nn.Module):
             emb.append(layer(cat_vars[:, :, index]).unsqueeze(2))
 
         cat_n_embd = torch.cat(emb,dim=2)
-        return cat_n_embd
+        return cat_n_embd
+    
+    
+    
+class CPRS(nn.Module):
+    """
+    Efficient vectorized implementation of Almost Fair CRPS.
+    
+    This version avoids explicit loops and uses broadcasting for better performance
+    with large ensembles.
+    """
+    
+    def __init__(self, alpha=0.95, reduction='mean'):
+        super().__init__()
+        self.alpha = alpha
+        self.reduction = reduction
+        
+    def forward(self, y_hat, target, weights=None):
+        """
+        Compute the almost fair CRPS loss (efficient version).
+        
+        Args:
+            ensemble: Tensor of shape (batch_size, n_members, ...)
+            target: Tensor of shape (batch_size, ...)
+            weights: Optional per-variable or per-location weights
+        
+        Returns:
+            Loss tensor
+        """
+        ## initial shape BS,width,n_variables,n_members need to go into batch_size, n_members, width, n_variables
+        ensemble = y_hat.permute(0,3,1,2)
+ 
+        
+        batch_size, n_members = ensemble.shape[:2]
+        epsilon = (1 - self.alpha) / n_members
+        
+        # Expand target to match ensemble shape
+        target_expanded = target.unsqueeze(1).expand_as(ensemble)
+        
+        # Compute first term: mean absolute error to target
+        mae_term = torch.abs(ensemble - target_expanded).mean(dim=1)
+        
+        # Compute second term: pairwise differences between ensemble members
+        # Use broadcasting to compute all pairwise differences efficiently
+        ensemble_i = ensemble.unsqueeze(2)  # (batch, n_members, 1, ...)
+        ensemble_j = ensemble.unsqueeze(1)  # (batch, 1, n_members, ...)
+        
+        pairwise_diffs = torch.abs(ensemble_i - ensemble_j)
+        
+        # Sum over all pairs (excluding diagonal)
+        # Create mask to exclude diagonal (i=j)
+        mask = ~torch.eye(n_members, dtype=torch.bool, device=ensemble.device)
+        mask = mask.view(1, n_members, n_members, *[1]*(len(ensemble.shape)-2))
+        
+        # Apply mask and compute mean
+        pairwise_term = (pairwise_diffs * mask).sum(dim=(1, 2)) / (n_members * (n_members - 1))
+        
+        # Combine terms according to afCRPS formula
+        loss = mae_term - (1 - epsilon) * pairwise_term
+        
+        # Apply weights if provided
+        if weights is not None:
+            loss = loss * weights
+            
+        # Apply reduction
+        if self.reduction == 'none':
+            return loss
+        elif self.reduction == 'sum':
+            return loss.sum()
+        elif self.reduction == 'mean':
+            return loss.mean()
+        else:
+            raise ValueError(f"Invalid reduction: {self.reduction}")

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsipts
-Version: 1.1.7
+Version: 1.1.9
 Summary: Unified library for timeseries modelling
 Author-email: Andrea Gobbi <agobbi@fbk.eu>
 Project-URL: Homepage, https://github.com/DSIP-FBK/DSIPTS
@@ -356,6 +356,9 @@ loss, quantile loss, MDA and a couple of experimental losses for minimizing the
 # Bash experiment
 Most of the time you want to train the models in a cluster with a GPU and command line training procedure can help speedup the process. DSIPTS leverages on OmegaConf-Hydra to to this and in the folder `bash_examples` you can find an examples. Please read the documentation [here](/bash_examples/README.md)
 
+## Losses
+
+- `dilated`: `persistence_weight` between 0 and 1
 
 
 # Modifiers
@@ -366,13 +369,7 @@ The VVA model is composed by two steps: the first is a clusterting procedure tha
 - **inverse_transform**: the output of the model are reverted to the original shape. In the VVA model the centroids are used for reconstruct the predicted timeseries.
 
 
-## Documentation
-You can find the documentation [here](https://dsip.pages.fbk.eu/dsip_dlresearch/timeseries/):
-or  in the folder `docs/_build/html/index.html`
-If yon need to generate the documentation after some modification just run:
-```
-./make_doc.sh    
-```
+
 
 For user only: be sure that the the CI file has pages enabled, see [public pages](https://roneo.org/en/gitlab-public-pages-private-repo/)
 

{dsipts-1.1.7 → dsipts-1.1.9}/src/dsipts.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/dsipts/models/PatchTST.py
 src/dsipts/models/Persistent.py
 src/dsipts/models/RNN.py
 src/dsipts/models/Samformer.py
+src/dsipts/models/Simple.py
 src/dsipts/models/TFT.py
 src/dsipts/models/TIDE.py
 src/dsipts/models/TTM.py