dsipts 1.1.10__py3-none-any.whl → 1.1.12__py3-none-any.whl

dsipts/data_structure/data_structure.py

@@ -35,7 +35,18 @@ from .modifiers import *
 from aim.pytorch_lightning import AimLogger
 import time
 
-
+class DummyScaler():
+    def __init__(self):
+        pass
+    def fit(self,x):
+        pass
+    def transform(self,x):
+        return x
+    def inverse_transform(self,x):
+        return x
+    def fit_transform(self,x):
+        return x
+    
 
 pd.options.mode.chained_assignment = None 
 log = logging.getLogger(__name__)
@@ -210,20 +221,23 @@ class TimeSeries():
         self.future_variables = []
         self.target_variables = ['signal']
         self.num_var = list(set(self.past_variables).union(set(self.future_variables)).union(set(self.target_variables)))
-        
+        self.num_var = list(np.sort(self.num_var))
         
     def enrich(self,dataset,columns):
-        if columns =='hour':
-            dataset[columns] = dataset.time.dt.hour
-        elif columns=='dow':
-            dataset[columns] = dataset.time.dt.weekday
-        elif columns=='month':
-            dataset[columns] = dataset.time.dt.month
-        elif columns=='minute':
-            dataset[columns] = dataset.time.dt.minute
-        else:
-            if columns  not in dataset.columns:
-                beauty_string(f'I can not automatically enrich column {columns}. Please contact the developers or add it manually to your dataset.','section',True)
+        try:
+            if columns =='hour':
+                dataset[columns] = dataset.time.dt.hour
+            elif columns=='dow':
+                dataset[columns] = dataset.time.dt.weekday
+            elif columns=='month':
+                dataset[columns] = dataset.time.dt.month
+            elif columns=='minute':
+                dataset[columns] = dataset.time.dt.minute
+            else:
+                if columns  not in dataset.columns:
+                    beauty_string(f'I can not automatically enrich column {columns}. Please contact the developers or add it manually to your dataset.','section',True)
+        except:
+            beauty_string(f'I can not automatically enrich column {columns}. Probably not a temporal index.','section',True)
 
     def load_signal(self,data:pd.DataFrame,
                     enrich_cat:List[str] = [],
@@ -300,7 +314,7 @@ class TimeSeries():
             if check_past:
                 beauty_string('I will update past column adding all target columns, if you want to avoid this beahviour please use check_pass as false','info',self.verbose)
                 past_variables = list(set(past_variables).union(set(target_variables)))
-
+                past_variables = list(np.sort(past_variables))
         self.cat_past_var = cat_past_var
         self.cat_fut_var = cat_fut_var
 
@@ -321,14 +335,18 @@ class TimeSeries():
                 beauty_string('Categorical {c} already present, it will be added to categorical variable but not call the enriching function','info',self.verbose) 
             else:
                 self.enrich(dataset,c)
+        self.cat_past_var = list(np.sort(self.cat_past_var))
+        self.cat_fut_var = list(np.sort(self.cat_fut_var))
+        
         self.cat_var = list(set(self.cat_past_var+self.cat_fut_var)) ## all categorical data
-
+        self.cat_var = list(np.sort(self.cat_var))
         self.dataset = dataset
         self.past_variables = past_variables
         self.future_variables = future_variables
         self.target_variables = target_variables
         self.out_vars = len(target_variables)
         self.num_var = list(set(self.past_variables).union(set(self.future_variables)).union(set(self.target_variables)))
+        self.num_var = list(np.sort(self.num_var))
         if silly_model:
             beauty_string('YOU ARE TRAINING A SILLY MODEL WITH THE TARGETS IN THE INPUTS','section',self.verbose) 
             self.future_variables+=self.target_variables
@@ -665,7 +683,8 @@ class TimeSeries():
         #self.model.apply(weight_init_zeros)
 
         self.config = config
-        
+
+
         beauty_string('Setting the model','block',self.verbose)
         beauty_string(model,'',self.verbose)
         
@@ -790,8 +809,17 @@ class TimeSeries():
             weight_exists = False
             beauty_string('I can not load a previous model','section',self.verbose)
 
+        self.model.to(torch.device("cuda:0" if torch.cuda.is_available() else "cpu"))
+        if self.model.can_be_compiled():
+            try:
+                self.model = torch.compile(self.model)
+                beauty_string('Model COMPILED','block',self.verbose)
+
+            except:
+                beauty_string('Can not compile the model','block',self.verbose)
+        else:
+            beauty_string('Model can not still be compiled, be patient','block',self.verbose)
 
-        
         
         if OLD_PL:
             trainer = pl.Trainer(default_root_dir=dirpath,
@@ -873,10 +901,19 @@ class TimeSeries():
             self.losses = pd.DataFrame()
 
         try:
+
             if OLD_PL:
-                self.model = self.model.load_from_checkpoint(self.checkpoint_file_last)
+                if isinstance(self.model, torch._dynamo.eval_frame.OptimizedModule):
+                    self.model = self.model._orig_mod 
+                    self.model.load_from_checkpoint(self.checkpoint_file_last)
+                else:
+                    self.model = self.model.load_from_checkpoint(self.checkpoint_file_last)
             else:
-                self.model = self.model.__class__.load_from_checkpoint(self.checkpoint_file_last)
+                if isinstance(self.model, torch._dynamo.eval_frame.OptimizedModule):
+                    mm = self.model._orig_mod 
+                    self.model = mm.__class__.load_from_checkpoint(self.checkpoint_file_last)
+                else:
+                    self.model = self.model.__class__.load_from_checkpoint(self.checkpoint_file_last)
 
         except Exception as _:
             beauty_string(f'There is a problem loading the weights on file MAYBE CHANGED HOW WEIGHTS ARE LOADED {self.checkpoint_file_last}','section',self.verbose)
@@ -1164,6 +1201,6 @@ class TimeSeries():
                 self.model = self.model.load_from_checkpoint(tmp_path,verbose=self.verbose,)
             else:
                 self.model = self.model.__class__.load_from_checkpoint(tmp_path,verbose=self.verbose,)
-
+            self.model.to(torch.device("cuda:0" if torch.cuda.is_available() else "cpu"))
         except Exception as e:
             beauty_string(f'There is a problem loading the weights on file {tmp_path} {e}','section',self.verbose)

dsipts/models/Autoformer.py

@@ -148,7 +148,8 @@ class Autoformer(Base):
             projection=nn.Linear(d_model, self.out_channels*self.mul, bias=True)
         )
         self.projection = nn.Linear(self.past_channels,self.out_channels*self.mul )
-
+    def can_be_compiled(self):
+        return True
     def forward(self, batch):
         
 

dsipts/models/CrossFormer.py

@@ -114,7 +114,8 @@ class CrossFormer(Base):
         
                                          
         
-     
+    def can_be_compiled(self):
+        return True
         
     def forward(self, batch):
 

dsipts/models/D3VAE.py

@@ -98,7 +98,8 @@ class D3VAE(Base):
         self.gamma = 0.01
         self.lambda1 = 1.0
 
-        
+    def can_be_compiled(self):
+        return False   
     def configure_optimizers(self):
         """
         Each model has optim_config and scheduler_config

dsipts/models/Diffusion.py

@@ -425,6 +425,9 @@ class Diffusion(Base):
         loss = self.compute_loss(batch,out)
         return loss
 
+    def can_be_compiled(self):
+        return False
+
     # function to concat embedded categorical variables
     def cat_categorical_vars(self, batch:dict):
         """Extracting categorical context about past and future

dsipts/models/DilatedConv.py

@@ -234,7 +234,8 @@ class DilatedConv(Base):
         self.return_additional_loss = True
         
 
-        
+    def can_be_compiled(self):
+        return True
 
     def forward(self, batch):
         """It is mandatory to implement this method

dsipts/models/DilatedConvED.py

@@ -228,7 +228,8 @@ class DilatedConvED(Base):
                                                 nn.BatchNorm1d(hidden_RNN) if use_bn else nn.Dropout(dropout_rate) ,
                                                 Permute() if use_bn else nn.Identity() ,
                                                 nn.Linear(hidden_RNN ,self.mul))
-        
+    def can_be_compiled(self):
+        return True  
 
 
     def forward(self, batch):

dsipts/models/Duet.py

@@ -136,7 +136,8 @@ class Duet(Base):
                                          activation(),
                                          nn.Linear(dim*2,self.out_channels*self.mul  ))
 
-
+    def can_be_compiled(self):
+        return False  
     def forward(self, batch:dict)-> float:
         # x: [Batch, Input length, Channel]
         x_enc = batch['x_num_past'].to(self.device)

dsipts/models/ITransformer.py

@@ -8,6 +8,8 @@ import numpy as np
 from .itransformer.Transformer_EncDec import Encoder, EncoderLayer
 from .itransformer.SelfAttention_Family import FullAttention, AttentionLayer
 from .itransformer.Embed import DataEmbedding_inverted
+from ..data_structure.utils import beauty_string
+from .utils import  get_scope,get_activation,Embedding_cat_variables
 
 try:
     import lightning.pytorch as pl
@@ -17,12 +19,6 @@ except:
     import pytorch_lightning as pl
     OLD_PL = True
     from .base import Base
-from .utils import QuantileLossMO,Permute, 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
 
 
 
@@ -34,8 +30,6 @@ class ITransformer(Base):
     description = get_scope(handle_multivariate,handle_future_covariates,handle_categorical_variables,handle_quantile_loss)
     
     def __init__(self, 
-                
-
                  # specific params
                  hidden_size:int,
                  d_model: int,
@@ -107,6 +101,9 @@ class ITransformer(Base):
         )
         self.projector = nn.Linear(d_model, self.future_steps*self.mul, bias=True)
 
+    def can_be_compiled(self):
+        return True  
+
     def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
         if self.use_norm:
             # Normalization from Non-stationary Transformer

dsipts/models/Informer.py

@@ -124,7 +124,8 @@ class Informer(Base):
         
                 
         
-  
+    def can_be_compiled(self):
+        return True  
         
     def forward(self,batch): 
         #x_enc, x_mark_enc, x_dec, x_mark_dec,enc_self_mask=None, dec_self_mask=None, dec_enc_mask=None):

dsipts/models/LinearTS.py

@@ -143,7 +143,8 @@ class LinearTS(Base):
                                                     activation(),
                                                     nn.BatchNorm1d(hidden_size//8) if use_bn else nn.Dropout(dropout_rate) ,    
                                                     nn.Linear(hidden_size//8,self.future_steps*self.mul)))
-                               
+    def can_be_compiled(self):
+        return True                            
     def forward(self, batch):
       
         x =  batch['x_num_past'].to(self.device)

dsipts/models/PatchTST.py

@@ -133,6 +133,9 @@ class PatchTST(Base):
     
         #self.final_linear = nn.Sequential(nn.Linear(past_channels,past_channels//2),activation(),nn.Dropout(dropout_rate), nn.Linear(past_channels//2,out_channels)  )
     
+    def can_be_compiled(self):
+        return True  
+    
     def forward(self, batch):           # x: [Batch, Input length, Channel]
         
 

dsipts/models/RNN.py

@@ -148,7 +148,8 @@ class RNN(Base):
                                             activation(),
                                             MyBN(hidden_RNN//8) if use_bn else nn.Dropout(dropout_rate) ,
                                             nn.Linear(hidden_RNN//8,1)))
-
+    def can_be_compiled(self):
+        return True  
   
 
     def forward(self, batch):

dsipts/models/Samformer.py

@@ -85,7 +85,9 @@ class Samformer(Base):
                                          activation(),
                                          nn.Linear(dim*2,self.out_channels*self.mul  ))
 
-
+    def can_be_compiled(self):
+        return True  
+  
     def forward(self, batch:dict)-> float:
 
         x = batch['x_num_past'].to(self.device)

dsipts/models/Simple.py

@@ -67,7 +67,9 @@ class Simple(Base):
         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 can_be_compiled(self):
+        return True  
+                             
     def forward(self, batch):
       
         x =  batch['x_num_past'].to(self.device)

dsipts/models/TFT.py

@@ -111,6 +111,10 @@ class TFT(Base):
 
         self.outLinear = nn.Linear(d_model, self.out_channels*self.mul)
 
+    def can_be_compiled(self):
+        return False  
+  
+
     def forward(self, batch:dict) -> torch.Tensor:
         """Temporal Fusion Transformer
 

dsipts/models/TIDE.py

@@ -106,7 +106,10 @@ class TIDE(Base):
 
         # linear for Y lookback
         self.linear_target = nn.Linear(self.past_steps*self.out_channels, self.future_steps*self.out_channels*self.mul)
-
+    
+    def can_be_compiled(self):
+        return False  
+  
 
     def forward(self, batch:dict)-> float:
         """training process of the diffusion network

dsipts/models/TTM.py

@@ -12,240 +12,146 @@ except:
     from .base import Base
 
 
-
-from typing import List,Union
-
-from .utils import  QuantileLossMO
+from .ttm.utils import get_model, get_frequency_token, count_parameters, DEFAULT_FREQUENCY_MAPPING
 from ..data_structure.utils import beauty_string
-from .ttm.utils import get_model, get_frequency_token, count_parameters, RMSELoss
-
+from .utils import  get_scope
 
 class TTM(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)
+    
     def __init__(self, 
                 model_path:str,
-                past_steps:int,
-                future_steps:int,
-                freq_prefix_tuning:bool,
-                freq:str,
                 prefer_l1_loss:bool,  # exog: set true to use l1 loss
                 prefer_longer_context:bool,
-                loss_type:str,
-                num_input_channels,
                 prediction_channel_indices,
-                exogenous_channel_indices,
+                exogenous_channel_indices_cont,
+                exogenous_channel_indices_cat,
                 decoder_mode,
+                freq,
+                freq_prefix_tuning,
                 fcm_context_length,
                 fcm_use_mixer,
                 fcm_mix_layers,
                 fcm_prepend_past,
                 enable_forecast_channel_mixing,
-                out_channels:int,
-                embs:List[int],
-                remove_last = False,
-                optim:Union[str,None]=None,
-                optim_config:dict=None,
-                scheduler_config:dict=None,
-                verbose = False,
-                use_quantiles=False,
-                persistence_weight:float=0.0,
-                quantiles:List[int]=[],
                 **kwargs)->None:
-        """TODO and FIX for future and past categorical variables
-        
-        Args:
-            model_path (str): _description_
-            past_steps (int): _description_
-            future_steps (int): _description_
-            freq_prefix_tuning (bool): _description_
-            freq (str): _description_
-            prefer_l1_loss (bool): _description_
-            loss_type (str): _description_
-            num_input_channels (_type_): _description_
-            prediction_channel_indices (_type_): _description_
-            exogenous_channel_indices (_type_): _description_
-            decoder_mode (_type_): _description_
-            fcm_context_length (_type_): _description_
-            fcm_use_mixer (_type_): _description_
-            fcm_mix_layers (_type_): _description_
-            fcm_prepend_past (_type_): _description_
-            enable_forecast_channel_mixing (_type_): _description_
-            out_channels (int): _description_
-            embs (List[int]): _description_
-            remove_last (bool, optional): _description_. Defaults to False.
-            optim (Union[str,None], optional): _description_. Defaults to None.
-            optim_config (dict, optional): _description_. Defaults to None.
-            scheduler_config (dict, optional): _description_. Defaults to None.
-            verbose (bool, optional): _description_. Defaults to False.
-            use_quantiles (bool, optional): _description_. Defaults to False.
-            persistence_weight (float, optional): _description_. Defaults to 0.0.
-            quantiles (List[int], optional): _description_. Defaults to [].
-        """
-        super(TTM, self).__init__(verbose)
+   
+        super().__init__(**kwargs)
         self.save_hyperparameters(logger=False)
-        self.future_steps = future_steps
-        self.use_quantiles = use_quantiles
-        self.optim = optim
-        self.optim_config = optim_config
-        self.scheduler_config = scheduler_config
-        self.persistence_weight = persistence_weight 
-        self.loss_type = loss_type
-        self.remove_last = remove_last
-        self.embs = embs
-        self.freq = freq
-        self.extend_variables = False
-
-        # NOTE: For Hydra
-        prediction_channel_indices = list(prediction_channel_indices)
-        exogenous_channel_indices = list(exogenous_channel_indices)
-
-        if len(quantiles)>0:
-            assert len(quantiles)==3, beauty_string('ONLY 3 quantiles premitted','info',True)
-            self.use_quantiles = True
-            self.mul = len(quantiles)
-            self.loss = QuantileLossMO(quantiles)
-            self.extend_variables = True
-            if out_channels * 3 != len(prediction_channel_indices):
-                prediction_channel_indices, exogenous_channel_indices, num_input_channels = self.__add_quantile_features(prediction_channel_indices, 
-                                                                                                                         exogenous_channel_indices, 
-                                                                                                                         out_channels)
+
+        
+
+        self.index_fut = list(exogenous_channel_indices_cont)
+
+        if len(exogenous_channel_indices_cat)>0:
+            self.index_fut_cat = (self.past_channels+len(self.embs_past))+list(exogenous_channel_indices_cat)
         else:
-            self.mul = 1
-            if self.loss_type == 'mse':
-                self.loss = nn.MSELoss(reduction="mean")
-            elif self.loss_type == 'rmse':
-                self.loss = RMSELoss()
-            else:
-                self.loss = nn.L1Loss()
+            self.index_fut_cat = []
+        self.freq = freq
+
+        base_freq_token = get_frequency_token(self.freq)  # e.g., shape [n_token] or scalar
+        # ensure it's a tensor of integer type
+        if not torch.is_tensor(base_freq_token):
+            base_freq_token = torch.tensor(base_freq_token)
+        base_freq_token = base_freq_token.long()
+        self.register_buffer("token", base_freq_token, persistent=True)
+                
         
         self.model = get_model(
             model_path=model_path,
-            context_length=past_steps,
-            prediction_length=future_steps,
-            freq_prefix_tuning=freq_prefix_tuning,
-            freq=freq,
+            context_length=self.past_steps,
+            prediction_length=self.future_steps,
             prefer_l1_loss=prefer_l1_loss,
             prefer_longer_context=prefer_longer_context,
-            num_input_channels=num_input_channels,
+            num_input_channels=self.past_channels+len(self.embs_past), #giusto
             decoder_mode=decoder_mode,
             prediction_channel_indices=list(prediction_channel_indices),
-            exogenous_channel_indices=list(exogenous_channel_indices),
+            exogenous_channel_indices=self.index_fut + self.index_fut_cat,
             fcm_context_length=fcm_context_length,
             fcm_use_mixer=fcm_use_mixer,
             fcm_mix_layers=fcm_mix_layers,
+            freq=freq,
+            freq_prefix_tuning=freq_prefix_tuning,
             fcm_prepend_past=fcm_prepend_past,
-            #loss='mse',
             enable_forecast_channel_mixing=enable_forecast_channel_mixing,
+            
         )
-        self.__freeze_backbone()
-
-    def __add_quantile_features(self, prediction_channel_indices, exogenous_channel_indices, out_channels):
-        prediction_channel_indices = list(range(out_channels * 3))
-        exogenous_channel_indices = [prediction_channel_indices[-1] + i for i in range(1, len(exogenous_channel_indices)+1)]
-        num_input_channels = len(prediction_channel_indices) + len(exogenous_channel_indices)
-        return prediction_channel_indices, exogenous_channel_indices, num_input_channels
+        hidden_size =  self.model.config.hidden_size
+        self.model.prediction_head = torch.nn.Linear(hidden_size, self.out_channels*self.mul)
+        self._freeze_backbone()
 
-    def __freeze_backbone(self):
+    def _freeze_backbone(self):
         """
         Freeze the backbone of the model.
         This is useful when you want to fine-tune only the head of the model.
         """
-        print(
-            "Number of params before freezing backbone",
-            count_parameters(self.model),
-        )
+        beauty_string(f"Number of params before freezing backbone:{count_parameters(self.model)}",'info',self.verbose)
+        
         # Freeze the backbone of the model
         for param in self.model.backbone.parameters():
             param.requires_grad = False
         # Count params
-        print(
-            "Number of params after freezing the backbone",
-            count_parameters(self.model),
-        )
+        beauty_string(f"Number of params after freezing the backbone: {count_parameters(self.model)}",'info',self.verbose)
+            
     
-    def __scaler(self, input):
-        #new_data = torch.tensor([MinMaxScaler().fit_transform(step_data) for step_data in data])
-        for i, e in enumerate(self.embs):
+    def _scaler_past(self, input):
+        for i, e in enumerate(self.embs_past):
+            input[:,:,i] = input[:, :, i] / (e-1)
+        return input
+    def _scaler_fut(self, input):
+        for i, e in enumerate(self.embs_fut):
             input[:,:,i] = input[:, :, i] / (e-1)
         return input
-    
-    def __build_tupla_indexes(self, size, target_idx, current_idx):
-        permute = list(range(size))
-        history = dict()
-        for j, i in enumerate(target_idx):
-            c = history.get(current_idx[j], current_idx[j])
-            permute[i], permute[c] = current_idx[j], i
-            history[i] = current_idx[j]
-
-
-    def __permute_indexes(self, values, target_idx, current_idx):
-        if current_idx is None or target_idx is None:
-            raise ValueError("Indexes cannot be None")
-        if sorted(current_idx) != sorted(target_idx):
-            return values[..., self.__build_tupla_indexes(values.shape[-1], target_idx, current_idx)]
-        return values
-    
-    def __extend_with_quantile_variables(self, x, original_indexes):
-        covariate_indexes = [i for i in range(x.shape[-1]) if i not in original_indexes]
-        covariate_tensors = x[..., covariate_indexes]
-
-        new_tensors = [x[..., target_index] for target_index in original_indexes for _ in range(3)]
 
-        new_original_indexes = list(range(len(original_indexes) * 3))
-        return torch.cat([torch.stack(new_tensors, dim=-1), covariate_tensors], dim=-1), new_original_indexes
-    
+    def can_be_compiled(self):
+        return True  
+  
     def forward(self, batch):
-        x_enc = batch['x_num_past']
+        x_enc = batch['x_num_past'].to(self.device)
         original_indexes = batch['idx_target'][0].tolist()
-        original_indexes_future = batch['idx_target_future'][0].tolist()
 
 
-        if self.extend_variables:
-            x_enc, original_indexes = self.__extend_with_quantile_variables(x_enc, original_indexes)
-
         if 'x_cat_past' in batch.keys():
             x_mark_enc = batch['x_cat_past'].to(torch.float32).to(self.device)
-            x_mark_enc = self.__scaler(x_mark_enc)
+            x_mark_enc = self._scaler_past(x_mark_enc)
             past_values = torch.cat((x_enc,x_mark_enc), axis=-1).type(torch.float32)
         else:
             past_values = x_enc
         
-        x_dec = torch.tensor([]).to(self.device)
+        future_values = torch.zeros_like(past_values).to(self.device)
+        future_values = future_values[:,:self.future_steps,:]
+
         if 'x_num_future' in batch.keys(): 
-            x_dec = batch['x_num_future'].to(self.device)
-            if self.extend_variables:
-                x_dec, original_indexes_future = self.__extend_with_quantile_variables(x_dec, original_indexes_future)
+            future_values[:,:,self.index_fut] = batch['x_num_future'].to(self.device)
         if 'x_cat_future' in batch.keys():
             x_mark_dec = batch['x_cat_future'].to(torch.float32).to(self.device)
-            x_mark_dec = self.__scaler(x_mark_dec)
-            future_values = torch.cat((x_dec, x_mark_dec), axis=-1).type(torch.float32)
-        else:
-            future_values = x_dec
-
-        if self.remove_last:
-            idx_target = batch['idx_target'][0]
-            x_start = x_enc[:,-1,idx_target].unsqueeze(1)
-            x_enc[:,:,idx_target]-=x_start 
-
+            x_mark_dec = self._scaler_fut(x_mark_dec)
+            future_values[:,:,self.index_cat_fut] = x_mark_dec
+        
 
-        past_values = self.__permute_indexes(past_values, self.model.prediction_channel_indices, original_indexes)
+        #investigating!! problem with dynamo!
+        #freq_token = get_frequency_token(self.freq).repeat(past_values.shape[0])
 
-        
-        future_values = self.__permute_indexes(future_values, self.model.prediction_channel_indices, original_indexes_future)
+        batch_size = past_values.shape[0]
+        freq_token = self.token.repeat(batch_size).long().to(self.device)
 
-        freq_token = get_frequency_token(self.freq).repeat(x_enc.shape[0])
 
         res = self.model(
             past_values= past_values,
-            future_values= future_values,
+            future_values= future_values,# future_values if future_values.shape[0]>0 else None,
             past_observed_mask = None,
             future_observed_mask = None,
             output_hidden_states =  False,
             return_dict = False,
-            freq_token= freq_token,
+            freq_token= freq_token,#[0:past_values.shape[0]], ##investigating
             static_categorical_values = None
         )
-        #args = None
-        #res = self.model(**args)
+
+
         BS = res.shape[0]
         return res.reshape(BS,self.future_steps,-1,self.mul)
         

dsipts/models/TimeXER.py

@@ -125,7 +125,9 @@ class TimeXER(Base):
 
         
 
-
+    def can_be_compiled(self):
+        return True  
+  
 
 
     def forward(self, batch:dict)-> float:

dsipts/models/base.py

@@ -111,8 +111,11 @@ class Base(pl.LightningModule):
         self.train_loss_epoch = -100.0
         self.verbose = verbose
         self.name = self.__class__.__name__
-        self.train_epoch_metrics = []
-        self.validation_epoch_metrics = []
+        self.register_buffer("train_epoch_metrics", torch.tensor(0.0))
+        self.register_buffer("validation_epoch_metrics", torch.tensor(0.0))
+        self.register_buffer("train_epoch_count", torch.tensor(0))
+        self.register_buffer("validation_epoch_count", torch.tensor(0))
+        
         
         self.use_quantiles = True if len(quantiles)>0 else False
         self.quantiles =  quantiles
@@ -295,7 +298,8 @@ class Base(pl.LightningModule):
                 y_hat = self(batch)
                 loss = self.compute_loss(batch,y_hat)
             
-        self.train_epoch_metrics.append(loss.item())
+        self.train_epoch_metrics+=loss.detach()
+        self.train_epoch_count +=1
         return loss
 
     
@@ -311,27 +315,20 @@ class Base(pl.LightningModule):
             y_hat = self(batch)
             score = 0
         if batch_idx==0:
-            if self.use_quantiles:
-                idx = 1
-            else:
-                idx = 0
-            #track the predictions! We can do better than this but maybe it is better to firstly update pytorch-lightening 
-
+           
             if self.count_epoch%int(max(self.trainer.max_epochs/100,1))==1:
-
-                for i in range(batch['y'].shape[2]):
-                    real =  batch['y'][0,:,i].cpu().detach().numpy()
-                    pred =  y_hat[0,:,i,idx].cpu().detach().numpy()
-                    fig, ax = plt.subplots(figsize=(7,5))  
-                    ax.plot(real,'o-',label='real')
-                    ax.plot(pred,'o-',label='pred')
-                    ax.legend()
-                    ax.set_title(f'Channel {i} first element first batch validation {int(100*self.count_epoch/self.trainer.max_epochs)}%')
-                    self.logger.experiment.track(Image(fig), name='cm_training_end')
-                    #self.log(f"example_{i}", np.stack([real, pred]).T,sync_dist=True)
-
-        return self.compute_loss(batch,y_hat)+score
-
+                self._val_outputs.append({
+                    "y": batch['y'].detach().cpu(),
+                    "y_hat": y_hat.detach().cpu()
+                })                
+        self.validation_epoch_metrics = (self.compute_loss(batch,y_hat)+score).detach()
+        self.validation_epoch_count+=1
+
+        return None #self.compute_loss(batch,y_hat)+score
+    
+    def on_validation_start(self):
+        # reset buffer each epoch
+        self._val_outputs = []
 
     def validation_epoch_end(self, outs):
         """
@@ -339,14 +336,30 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        if len(outs)==0:
-            loss = 10000
-            beauty_string(f'THIS IS A BUG, It should be polulated','info',self.verbose)
-        else:
-            loss = torch.stack(outs).mean()
-        
-        self.log("val_loss", loss.item(),sync_dist=True)
-        beauty_string(f'Epoch: {self.count_epoch} train error: {self.train_loss_epoch:.4f} validation loss: {loss.item():.4f}','info',self.verbose)
+        if len(self._val_outputs)>0:
+            ys = torch.cat([o["y"] for o in self._val_outputs])
+            y_hats = torch.cat([o["y_hat"] for o in self._val_outputs])
+            if self.use_quantiles:
+                idx = 1
+            else:
+                idx = 0
+            for i in range(ys.shape[2]):
+                real =  ys[0,:,i].cpu().detach().numpy()
+                pred =  y_hats[0,:,i,idx].cpu().detach().numpy()
+                fig, ax = plt.subplots(figsize=(7,5))  
+                ax.plot(real,'o-',label='real')
+                ax.plot(pred,'o-',label='pred')
+                ax.legend()
+                ax.set_title(f'Channel {i} first element first batch validation {int(100*self.count_epoch/self.trainer.max_epochs)}%')
+                self.logger.experiment.track(Image(fig), name='cm_training_end')
+                #self.log(f"example_{i}", np.stack([real, pred]).T,sync_dist=True)
+                plt.close(fig) 
+        avg = self.validation_epoch_metrics/self.validation_epoch_count
+
+        self.validation_epoch_metrics.zero_()
+        self.validation_epoch_count.zero_()
+        self.log("val_loss", avg,sync_dist=True)
+        beauty_string(f'Epoch: {self.count_epoch} train error: {self.train_loss_epoch:.4f} validation loss: {avg:.4f}','info',self.verbose)
 
     def training_epoch_end(self, outs):
         """
@@ -355,12 +368,11 @@ class Base(pl.LightningModule):
         :meta private:
         """
 
-        loss = sum(outs['loss'] for outs in outs) / len(outs)
-        self.log("train_loss", loss.item(),sync_dist=True)
+        loss = self.train_epoch_metrics/self.global_step
+        self.log("train_loss", loss,sync_dist=True)
         self.count_epoch+=1    
 
-        self.train_loss_epoch = loss.item()
-
+        self.train_loss_epoch = loss
     def compute_loss(self,batch,y_hat):
         """
         custom loss calculation

dsipts/models/base_v2.py

@@ -15,7 +15,6 @@ from typing import List, Union
 from .utils import QuantileLossMO, CPRS
 import torch.nn as nn
 
-
 def standardize_momentum(x,order):
     mean = torch.mean(x,1).unsqueeze(1).repeat(1,x.shape[1],1)
     num = torch.pow(x-mean,order).mean(axis=1)
@@ -113,8 +112,13 @@ class Base(pl.LightningModule):
         self.train_loss_epoch = -100.0
         self.verbose = verbose
         self.name = self.__class__.__name__
-        self.train_epoch_metrics = []
-        self.validation_epoch_metrics = []
+        #self.train_epoch_metrics = 0
+        #self.validation_epoch_metrics = 0
+        
+        self.register_buffer("train_epoch_metrics", torch.tensor(0.0))
+        self.register_buffer("validation_epoch_metrics", torch.tensor(0.0))
+        self.register_buffer("train_epoch_count", torch.tensor(0))
+        self.register_buffer("validation_epoch_count", torch.tensor(0))
         
         self.use_quantiles = True if len(quantiles)>0 else False
         self.quantiles =  quantiles
@@ -299,10 +303,11 @@ class Base(pl.LightningModule):
                 y_hat = self(batch)
                 loss = self.compute_loss(batch,y_hat)
             
-        self.train_epoch_metrics.append(loss.item())
+        self.train_epoch_metrics+=loss.detach()
+        self.train_epoch_count +=1
         return loss
 
-    
+
     def validation_step(self, batch, batch_idx):
         """
         pythotrch lightening stuff
@@ -315,42 +320,54 @@ class Base(pl.LightningModule):
         else:
             y_hat = self(batch)
             score = 0
-        if batch_idx==0:
-            if self.use_quantiles:
-                idx = 1
-            else:
-                idx = 0
-            #track the predictions! We can do better than this but maybe it is better to firstly update pytorch-lightening 
+        #log_this_batch = (batch_idx == 0) and (self.count_epoch % int(max(self.trainer.max_epochs / 100,1)) == 1)
 
-            if self.count_epoch%int(max(self.trainer.max_epochs/100,1))==1:
-
-                for i in range(batch['y'].shape[2]):
-                    real =  batch['y'][0,:,i].cpu().detach().numpy()
-                    pred =  y_hat[0,:,i,idx].cpu().detach().numpy()
-                    fig, ax = plt.subplots(figsize=(7,5))  
-                    ax.plot(real,'o-',label='real')
-                    ax.plot(pred,'o-',label='pred')
-                    ax.legend()
-                    ax.set_title(f'Channel {i} first element first batch validation {int(100*self.count_epoch/self.trainer.max_epochs)}%')
-                    self.logger.experiment.track(Image(fig), name='cm_training_end')
-                    #self.log(f"example_{i}", np.stack([real, pred]).T,sync_dist=True)
-        self.validation_epoch_metrics.append(self.compute_loss(batch,y_hat)+score)
-        return 
+        #if log_this_batch:
+            #track the predictions! We can do better than this but maybe it is better to firstly update pytorch-lightening 
+        self._val_outputs=[{
+                "y": batch['y'].detach().cpu(),
+                "y_hat": y_hat.detach().cpu()
+            }]               
+        self.validation_epoch_metrics+= (self.compute_loss(batch,y_hat)+score).detach()
+        self.validation_epoch_count+=1
+        return None
 
+    def on_validation_start(self):
+        # reset buffer each epoch
+        self._val_outputs = []
+    
 
     def on_validation_epoch_end(self):
         """
         pythotrch lightening stuff
         
         :meta private:
-        """
+        """   
 
-        if len(self.validation_epoch_metrics)==0:
-            avg = 10000
-            beauty_string(f'THIS IS A BUG, It should be polulated','info',self.verbose)
-        else:
-            avg = torch.stack(self.validation_epoch_metrics).mean()
-        self.validation_epoch_metrics = []
+        if len(self._val_outputs)>0:
+            ys = torch.cat([o["y"] for o in self._val_outputs])
+            y_hats = torch.cat([o["y_hat"] for o in self._val_outputs])
+            if self.use_quantiles:
+                idx = 1
+            else:
+                idx = 0
+            for i in range(ys.shape[2]):
+                real =  ys[0,:,i].cpu().detach().numpy()
+                pred =  y_hats[0,:,i,idx].cpu().detach().numpy()
+                fig, ax = plt.subplots(figsize=(7,5))  
+                ax.plot(real,'o-',label='real')
+                ax.plot(pred,'o-',label='pred')
+                ax.legend()
+                ax.set_title(f'Channel {i} first element first batch validation {int(100*self.count_epoch/self.trainer.max_epochs)}%')
+                self.logger.experiment.track(Image(fig), name='cm_training_end')
+                #self.log(f"example_{i}", np.stack([real, pred]).T,sync_dist=True)
+                plt.close(fig) 
+            
+         
+        avg = self.validation_epoch_metrics/self.validation_epoch_count
+
+        self.validation_epoch_metrics.zero_()
+        self.validation_epoch_count.zero_()
         self.log("val_loss", avg,sync_dist=True)
         beauty_string(f'Epoch: {self.count_epoch} train error: {self.train_loss_epoch:.4f} validation loss: {avg:.4f}','info',self.verbose)
 
@@ -361,14 +378,12 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        if len(self.train_epoch_metrics)==0:
-            avg = 0
-            beauty_string(f'THIS IS A BUG, It should be polulated','info',self.verbose)
-        else:
-            avg = np.stack(self.train_epoch_metrics).mean()
+
+        avg = self.train_epoch_metrics/self.train_epoch_count
         self.log("train_loss", avg,sync_dist=True)
         self.count_epoch+=1    
-        self.train_epoch_metrics = []
+        self.train_epoch_metrics.zero_()
+        self.train_epoch_count.zero_()
         self.train_loss_epoch = avg
 
     def compute_loss(self,batch,y_hat):

dsipts/models/duet/layers.py

@@ -219,7 +219,7 @@ class SparseDispatcher(object):
         # expand according to batch index so we can just split by _part_sizes
         inp_exp = inp[self._batch_index].squeeze(1)
         return torch.split(inp_exp, self._part_sizes, dim=0)
-
+ 
     def combine(self, expert_out, multiply_by_gates=True):
         """Sum together the expert output, weighted by the gates.
         The slice corresponding to a particular batch element `b` is computed
@@ -234,7 +234,9 @@ class SparseDispatcher(object):
           a `Tensor` with shape `[batch_size, <extra_output_dims>]`.
         """
         # apply exp to expert outputs, so we are not longer in log space
+  
         stitched = torch.cat(expert_out, 0)
+
         if multiply_by_gates:
             # stitched = stitched.mul(self._nonzero_gates)
             stitched = torch.einsum("i...,ij->i...", stitched, self._nonzero_gates)
@@ -430,9 +432,11 @@ class Linear_extractor_cluster(nn.Module):
         expert_inputs = dispatcher.dispatch(x_norm)
 
         gates = dispatcher.expert_to_gates()
+
         expert_outputs = [
             self.experts[i](expert_inputs[i]) for i in range(self.num_experts)
         ]
+        #y = dispatcher.combine([e for e in expert_outputs if len(e)>0])
+        #with torch._dynamo.disable():
         y = dispatcher.combine(expert_outputs)
-
         return y, loss

{dsipts-1.1.10.dist-info → dsipts-1.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsipts
-Version: 1.1.10
+Version: 1.1.12
 Summary: Unified library for timeseries modelling
 Author-email: Andrea Gobbi <agobbi@fbk.eu>
 Project-URL: Homepage, https://github.com/DSIP-FBK/DSIPTS

{dsipts-1.1.10.dist-info → dsipts-1.1.12.dist-info}/RECORD

@@ -3,33 +3,33 @@ dsipts/data_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 dsipts/data_management/monash.py,sha256=aZxq9FbIH6IsU8Lwou1hAokXjgOAK-wdl2VAeFg2k4M,13075
 dsipts/data_management/public_datasets.py,sha256=yXFzOZZ-X0ZG1DoqVU-zFmEGVMc2033YDQhRgYxY8ws,6793
 dsipts/data_structure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsipts/data_structure/data_structure.py,sha256=87VtKelx2EPoddrVYcja9dO5rQqaS83vZlQB_NY54PI,58994
+dsipts/data_structure/data_structure.py,sha256=KVkjTVjc7NznJIou4LYGzMbzE7ye-K3ll65GEgn2qKg,60814
 dsipts/data_structure/modifiers.py,sha256=qlry9dfw8pEE0GrvgwROZJkJ6oPpUnjEHPIG5qIetss,7948
 dsipts/data_structure/utils.py,sha256=QwfKPZgSy6DIw5n6ztOdPJIAnzo4EnlMTgRbpiWnyko,6593
-dsipts/models/Autoformer.py,sha256=ddGT3L9T4gAXNJHx1TsuYZy7j63Anyr0rkqqXaOoSu4,8447
-dsipts/models/CrossFormer.py,sha256=iO64L3S01jxuWA9dmm8FsK1WRvBIXbZ0PQ2tZlEQg4w,6481
-dsipts/models/D3VAE.py,sha256=NstHIniNteBRrkfL7SJ3-bJEl3l3IIxoSxavRV3j16U,6857
-dsipts/models/Diffusion.py,sha256=pUujnrdeSSkj4jC1RORbcptt03KpuCsGVwg414o4LPg,40733
-dsipts/models/DilatedConv.py,sha256=_c0NvFuT3vbYmo9A8cQchGo1XVb0qOpzBprNEkkAgiE,14292
-dsipts/models/DilatedConvED.py,sha256=fXk1-EWiRC5J_VIepTjYKya_D02SlEAkyiJcCjhW_XU,14004
-dsipts/models/Duet.py,sha256=EharWHT_r7tEYIk7BkozVLPZ0xptE5mmQmeFGm3uBsA,7628
-dsipts/models/ITransformer.py,sha256=jO8wxLaC06Wgu4GncrFFTISv3pVyfFLLhQvbEOYsz6Y,7368
-dsipts/models/Informer.py,sha256=ByJ00qGk12ONFF7NZWAACzxxRb5UXcu5wpkGMYX9Cq4,6920
-dsipts/models/LinearTS.py,sha256=B0-Sz4POwUyl-PN2ssSx8L-ZHgwrQQPcMmreyvSS47U,9104
-dsipts/models/PatchTST.py,sha256=Z7DM1Kw5Ym8Hh9ywj0j9RuFtKaz_yVZmKFIYafjceM8,9061
+dsipts/models/Autoformer.py,sha256=nUQvPC_qtajLT1AHdNJmF_P3ZL01j3spkZ4ubxdGF3g,8497
+dsipts/models/CrossFormer.py,sha256=ClW6H_hrtLJH0iqTC7q_ya_Bwc_Xu-0lpAN5w2DSUYk,6526
+dsipts/models/D3VAE.py,sha256=d1aY6kGjBSxZncN-KPWpdUGunu182ng2QFInGFrKYQM,6903
+dsipts/models/Diffusion.py,sha256=owst4IxA3hkEEIrn5K-zwAYWUzEhouiRPwM4nTLcyoE,40786
+dsipts/models/DilatedConv.py,sha256=TMDzd_cNgCZa6YusVVVGbTGGH3YlMz0IZZ9ZxRrJ3i4,14334
+dsipts/models/DilatedConvED.py,sha256=KwG83yHqoEx_Vmea69zTPsSP1-0GdOUrtXwvhNDuWj8,14048
+dsipts/models/Duet.py,sha256=m67PStuYE6vkFUFUofBrrLryx1ZUZropyVGcu_ygOx8,7681
+dsipts/models/ITransformer.py,sha256=2WXqqEvnWH2DqRQyXfGm4Eg4_q32GFy2XnNeoTl-KmY,7310
+dsipts/models/Informer.py,sha256=gxCdU2KkNhadyMujBA5A0eP6SPN4Q0IkEIogLYwvz5k,6970
+dsipts/models/LinearTS.py,sha256=vXaGpbbkfdpzpTEWZ1hs6QI6j3vDvevD3SyKQXo6Sdg,9151
+dsipts/models/PatchTST.py,sha256=1O09cPMg8USdkt5q6szTiz5dIY45kizsf6gt6vLKnQo,9119
 dsipts/models/Persistent.py,sha256=URwyaBb0M7zbPXSGMImtHlwC9XCy-OquFCwfWvn3P70,1249
-dsipts/models/RNN.py,sha256=GbH6QyrGhvQg-Hnt_0l3YSnhNHE0Hl0AWsZpdQUAzug,9633
-dsipts/models/Samformer.py,sha256=s61Hi1o9iuw-KgSBPfiE80oJcK1j2fUA6N9f5BJgKJc,5551
-dsipts/models/Simple.py,sha256=K82E88A62NhV_7U9Euu2cn3Q8P287HDR7eIy7VqgwbM,3909
-dsipts/models/TFT.py,sha256=JO2-AKIUag7bfm9Oeo4KmGfdYZJbzQBHPDqGVg0WUZI,13830
-dsipts/models/TIDE.py,sha256=i8qXac2gImEVgE2X6cNxqW5kuQP3rzWMlQNdgJbNmKM,13033
-dsipts/models/TTM.py,sha256=WpCiTN0qX3JFO6xgPLedoqMKXUC2pQpNAe9ee-Rw89Q,10602
-dsipts/models/TimeXER.py,sha256=aCg0003LxYZzqZWyWugpbW_iOybcdHN4OH6_v77qp4o,7056
+dsipts/models/RNN.py,sha256=RnsRDAQ2z5-XNaJVZd6Q7z23WvPR2uLVdi7BNQyF7QE,9685
+dsipts/models/Samformer.py,sha256=Kt7B9ID3INtFDAVKIM1LTly5-UfKCaVZ9uxAJmYv6B4,5606
+dsipts/models/Simple.py,sha256=8wRSO-gh_Z6Sl8fYMV-RIXIL0RrO5u5dDtsaq-OsKg0,3960
+dsipts/models/TFT.py,sha256=JiI90ikfP8aaR_rtczu8CyGMNLTgml13aYQifgIC_yo,13888
+dsipts/models/TIDE.py,sha256=S1KlKqFOR3jJ9DDiTqeaKvya9hYBsNHBVqwJsYX3FLU,13094
+dsipts/models/TTM.py,sha256=lOOo5dR5nOmf37cND6C8ft8TVl0kzNeraIuABw7eI5g,5897
+dsipts/models/TimeXER.py,sha256=EkmlHfT2RegY6Ce6q8EUEV1a_WZ6SkYibnOZXqsyd_8,7111
 dsipts/models/VQVAEA.py,sha256=sNJi8UZh-10qEIKcZK3SzhlOFUUjvqjoglzeZBFaeZM,13789
 dsipts/models/VVA.py,sha256=BnPkJ0Nzue0oShSHZVRNlf5RvT0Iwtf9bx19vLB9Nn0,11939
 dsipts/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsipts/models/base.py,sha256=0r_gGD9CPAVmuqTmySugTpCVUgoHJrwaMAqLx3P-ZBw,19021
-dsipts/models/base_v2.py,sha256=b_RaVTBnA2dU4HpVPI-P0_VkmbsQHtYzxVf5iFVvp1U,19299
+dsipts/models/base.py,sha256=Gqsycy8ZXGaIVx9vvmYRpBCqdUxGE4tvC5ltgxlpEYY,19640
+dsipts/models/base_v2.py,sha256=03cueZExRhkJyBVIHuUPB8sjsCd5Go1HJAR81CADg-c,19896
 dsipts/models/utils.py,sha256=kjTwyktNCFMpPUy6zoleBCSKlvMvK_Jkgyh2T1OXg3E,24497
 dsipts/models/autoformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/autoformer/layers.py,sha256=xHt8V1lKdD1cIvgxXdDbI_EqOz4zgOQ6LP8l7M1pAxM,13276
@@ -47,7 +47,7 @@ dsipts/models/d3vae/neural_operations.py,sha256=C70kUtQ0ox9MeXBdu4rPDqt022_hVtcN
 dsipts/models/d3vae/resnet.py,sha256=3bnlrEBM2DGiAJV8TeSv2tm27Gm-_P6hee41t8QQFL8,5520
 dsipts/models/d3vae/utils.py,sha256=fmUsE_67uwizjeR1_pDdsndyQddbqt27Lv31XBEn-gw,23798
 dsipts/models/duet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsipts/models/duet/layers.py,sha256=ikMAKr4DzhGt9J1KuBBQzVYXMHZUZVsV29P6TVJCa_Y,18141
+dsipts/models/duet/layers.py,sha256=TTrhlfSwIXE_7gO9rsdKJD9Bdy3B_JJPCo8vYZJ8Fvg,18258
 dsipts/models/duet/masked.py,sha256=lkdAB5kwAgV7QfBSVP_QeDr_mB09Rz4302p-KwZpUV4,7111
 dsipts/models/informer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/informer/attn.py,sha256=ghrQGfAqt-Z_7qU5D_aixobmwk6pBKMLAdaNfg-QZbo,6839
@@ -76,7 +76,7 @@ dsipts/models/vva/minigpt.py,sha256=bg0JddqSD322uxSGexen3nPXL_hGTsk3vNLR62d7-w8,
 dsipts/models/vva/vqvae.py,sha256=RzCQ_M9xBprp7_x20dSV3EQqlO0FjPUGWV-qdyKrQsM,19680
 dsipts/models/xlstm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/xlstm/xLSTM.py,sha256=ZKZZmffmIq1Vb71CR4GSyM8viqVx-u0FChxhcNgHub8,10081
-dsipts-1.1.10.dist-info/METADATA,sha256=hwFJB926XiPZjhisLz-Usqpic_ty16lk3ZwvHoZHC0c,24795
-dsipts-1.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dsipts-1.1.10.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
-dsipts-1.1.10.dist-info/RECORD,,
+dsipts-1.1.12.dist-info/METADATA,sha256=nxE2kAg9RvG5Py27sMNbQ-mUIu9mtZrDo2WocLpJdQ4,24795
+dsipts-1.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsipts-1.1.12.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
+dsipts-1.1.12.dist-info/RECORD,,