dsipts 1.1.11__tar.gz → 1.1.13__tar.gz

{dsipts-1.1.11 → dsipts-1.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsipts
-Version: 1.1.11
+Version: 1.1.13
 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.11 → dsipts-1.1.13}/pyproject.toml

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

{dsipts-1.1.11 → dsipts-1.1.13}/src/dsipts/data_structure/data_structure.py

@@ -6,7 +6,7 @@ from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
 from sklearn.preprocessing import * 
 from torch.utils.data import DataLoader
 from .utils import extend_time_df,MetricsCallback, MyDataset, ActionEnum,beauty_string
-
+from torch.utils.data.sampler import WeightedRandomSampler
 try:
 
     #new version of lightning
@@ -249,7 +249,8 @@ class TimeSeries():
                     check_past:bool=True,
                     group:Union[None,str]=None,
                     check_holes_and_duplicates:bool=True,
-                    silly_model:bool=False)->None:
+                    silly_model:bool=False,
+                    sampler_weights:Union[None,str]=None)->None:
         """ This is a crucial point in the data structure. We expect here to have a dataset with time as timestamp.
             There are some checks:
                 1- the duplicates will tbe removed taking the first instance
@@ -270,6 +271,7 @@ class TimeSeries():
             group (str or None, optional): if not None the time serie dataset is considered composed by omogeneus timeseries coming from different realization (for example point of sales, cities, locations) and the relative series are not splitted during the sample generation. Defaults to None
             check_holes_and_duplicates (bool, optional): if False duplicates or holes will not checked, the dataloader can not correctly work, disable at your own risk. Defaults True
             silly_model (bool, optional): if True, target variables will be added to the pool of the future variables. This can be useful to see if information passes throught the decoder part of your model (if any)
+            sampler_weights  group (str or None, optional): if it is a column name it will be used as weight for the sampler. Careful that the weight of the sample is the weight value of the fist target value (index)
         """
         
         
@@ -322,7 +324,7 @@ class TimeSeries():
         if group is not None:
             if group not in cat_past_var:
                 beauty_string(f'I will add {group} to the categorical past/future variables','info',self.verbose)
-                self.cat_var.append(group)
+                self.cat_past_var.append(group)
             if group not in cat_fut_var:
                 beauty_string(f'I will add {group} to the categorical past/future variables','info',self.verbose)
                 self.cat_fut_var.append(group)   
@@ -350,7 +352,7 @@ class TimeSeries():
         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
-            
+        self.sampler_weights = sampler_weights
     def plot(self):
         """  
         Easy way to control the loaded data
@@ -409,6 +411,7 @@ class TimeSeries():
         y_samples = []
         t_samples = []
         g_samples = []
+        sampler_weights_samples = []
         
         if starting_point is not None:
             kk = list(starting_point.keys())[0]
@@ -475,7 +478,8 @@ class TimeSeries():
             if len(self.cat_fut_var)>0:
                 x_fut_cat = tmp[self.cat_fut_var].values
             y_target = tmp[self.target_variables].values
-
+            if self.sampler_weights is not None:
+                sampler_weights = tmp[self.sampler_weights].values.flatten()
         
             if starting_point is not None:
                 check = tmp[list(starting_point.keys())[0]].values == starting_point[list(starting_point.keys())[0]]
@@ -512,6 +516,8 @@ class TimeSeries():
                                 x_cat_future_samples.append(x_fut_cat[i-shift+skip_stacked:i+future_steps-shift+skip_stacked])
                         
                         y_samples.append(y_target[i+skip_stacked:i+future_steps+skip_stacked])
+                        if self.sampler_weights is not None:
+                            sampler_weights_samples.append(sampler_weights[i+skip_stacked])
                         t_samples.append(t[i+skip_stacked:i+future_steps+skip_stacked])
                         g_samples.append(groups[i])
 
@@ -524,6 +530,8 @@ class TimeSeries():
                 beauty_string('WARNING x_num_future_samples is empty and it should not','info',True)
         
         y_samples = np.stack(y_samples)
+        if self.sampler_weights is not None:
+            sampler_weights_samples = np.stack(sampler_weights_samples)
         t_samples = np.stack(t_samples)   
         g_samples = np.stack(g_samples)
 
@@ -537,7 +545,6 @@ class TimeSeries():
         else:
             mod = 1.0
         dd = {'y':y_samples.astype(np.float32),
-
               'x_num_past':(x_num_past_samples*mod).astype(np.float32)}
         if len(self.cat_past_var)>0:
             dd['x_cat_past'] = x_cat_past_samples
@@ -545,7 +552,10 @@ class TimeSeries():
             dd['x_cat_future'] = x_cat_future_samples
         if len(self.future_variables)>0:
             dd['x_num_future'] = x_num_future_samples.astype(np.float32)
-        
+        if self.sampler_weights is not None:
+            dd['sampler_weights'] = sampler_weights_samples.astype(np.float32)
+        else:
+            dd['sampler_weights'] = np.ones(len(y_samples)).astype(np.float32)
         return MyDataset(dd,t_samples,g_samples,idx_target,idx_target_future)
     
           
@@ -683,10 +693,7 @@ class TimeSeries():
         #self.model.apply(weight_init_zeros)
 
         self.config = config
-        try:
-            self.model = torch.compile(self.model)
-        except:
-            beauty_string('Can not compile the model','block',self.verbose)
+
 
         beauty_string('Setting the model','block',self.verbose)
         beauty_string(model,'',self.verbose)
@@ -756,8 +763,14 @@ class TimeSeries():
         else:
             self.modifier = None
         
+        if self.sampler_weights is not None:
+            beauty_string(f'USING SAMPLER IN TRAIN {min(train.sampler_weights)}-{max(train.sampler_weights)}','section',self.verbose)
 
-        train_dl = DataLoader(train, batch_size = batch_size , shuffle=True,drop_last=True,num_workers=num_workers,persistent_workers=persistent_workers)
+            sampler = WeightedRandomSampler(train.sampler_weights, num_samples= len(train))
+            train_dl = DataLoader(train, batch_size = batch_size , shuffle=False,sampler=sampler,drop_last=True,num_workers=num_workers,persistent_workers=persistent_workers)
+
+        else:
+            train_dl = DataLoader(train, batch_size = batch_size , shuffle=True,drop_last=True,num_workers=num_workers,persistent_workers=persistent_workers)
         valid_dl = DataLoader(validation, batch_size = batch_size , shuffle=False,drop_last=True,num_workers=num_workers,persistent_workers=persistent_workers)
    
         checkpoint_callback = ModelCheckpoint(dirpath=dirpath,
@@ -812,8 +825,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,
@@ -895,10 +917,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)
@@ -1011,7 +1042,7 @@ class TimeSeries():
             
             if self.group is not None:
                 time[self.group] = groups
-                time = time.melt(id_vars=['region'])
+                time = time.melt(id_vars=[self.group])
             else:
                 time = time.melt()
             time.rename(columns={'value':'time','variable':'lag'},inplace=True)
@@ -1033,7 +1064,8 @@ class TimeSeries():
 
             if self.group is not None:
                 time[self.group] = groups
-                time = time.melt(id_vars=['region'])
+
+                time = time.melt(id_vars=[self.group])
             else:
                 time = time.melt()
             time.rename(columns={'value':'time','variable':'lag'},inplace=True)
@@ -1186,6 +1218,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-1.1.11 → dsipts-1.1.13}/src/dsipts/data_structure/utils.py

@@ -142,12 +142,13 @@ class MyDataset(Dataset):
         Returns:
             torch.utils.data.Dataset: a torch Dataset to be used in a Dataloader
         """
+
         self.data = data
         self.t = t
         self.groups = groups
         self.idx_target = np.array(idx_target) if idx_target is not None else None
         self.idx_target_future = np.array(idx_target_future) if idx_target_future is not None else None
-
+        self.sampler_weights = data['sampler_weights']
   
 
     def __len__(self):
@@ -157,7 +158,8 @@ class MyDataset(Dataset):
     def __getitem__(self, idxs):
         sample = {}
         for k in self.data:
-            sample[k] = self.data[k][idxs]
+            if k!='sampler_weights':
+                sample[k] = self.data[k][idxs]
         if self.idx_target is not None:
             sample['idx_target'] = self.idx_target
         if self.idx_target_future is not None:

{dsipts-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/dsipts/models/CrossFormer.py

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

{dsipts-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/dsipts/models/ITransformer.py

@@ -101,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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/dsipts/models/TTM.py

@@ -12,7 +12,7 @@ except:
     from .base import Base
 
 
-from .ttm.utils import get_model, get_frequency_token, count_parameters
+from .ttm.utils import get_model, get_frequency_token, count_parameters, DEFAULT_FREQUENCY_MAPPING
 from ..data_structure.utils import beauty_string
 from .utils import  get_scope
 
@@ -38,20 +38,32 @@ class TTM(Base):
                 fcm_mix_layers,
                 fcm_prepend_past,
                 enable_forecast_channel_mixing,
+                force_return,
                 **kwargs)->None:
    
         super().__init__(**kwargs)
         self.save_hyperparameters(logger=False)
 
+        
 
         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)
+
+            self.index_fut_cat = [self.past_channels+c for c in list(exogenous_channel_indices_cat)]
+
         else:
             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=self.past_steps,
@@ -66,6 +78,7 @@ class TTM(Base):
             fcm_use_mixer=fcm_use_mixer,
             fcm_mix_layers=fcm_mix_layers,
             freq=freq,
+            force_return=force_return,
             freq_prefix_tuning=freq_prefix_tuning,
             fcm_prepend_past=fcm_prepend_past,
             enable_forecast_channel_mixing=enable_forecast_channel_mixing,
@@ -74,7 +87,7 @@ class TTM(Base):
         hidden_size =  self.model.config.hidden_size
         self.model.prediction_head = torch.nn.Linear(hidden_size, self.out_channels*self.mul)
         self._freeze_backbone()
-
+        self.zero_pad = (force_return=='zeropad') 
     def _freeze_backbone(self):
         """
         Freeze the backbone of the model.
@@ -98,34 +111,53 @@ class TTM(Base):
             input[:,:,i] = input[:, :, i] / (e-1)
         return input
 
-
+    def can_be_compiled(self):
+        
+        return True#not self.zero_pad  
+  
     def forward(self, batch):
-        x_enc = batch['x_num_past']
-        original_indexes = batch['idx_target'][0].tolist()
-
+        x_enc = batch['x_num_past'].to(self.device)
 
+        
+        if self.zero_pad:
+            B,L,C = batch['x_num_past'].shape
+            x_enc = torch.zeros((B,512,C)).to(self.device)
+            x_enc[:,-L:,:] = batch['x_num_past'].to(self.device)
+        else:
+            x_enc = batch['x_num_past'].to(self.device)
+        original_indexes = batch['idx_target'][0].tolist()
 
 
         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_past(x_mark_enc)
+            if self.zero_pad:
+                B,L,C = batch['x_cat_past'].shape
+                x_mark_enc = torch.zeros((B,512,C)).to(self.device)
+                x_mark_enc[:,-L:,:] = batch['x_cat_past'].to(torch.float32).to(self.device)
+            else:
+                x_mark_enc = batch['x_cat_past'].to(torch.float32).to(self.device)
+                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
+        B,L,C = past_values.shape
+        future_values = torch.zeros((B,self.future_steps,C)).to(self.device)
         
-        future_values = torch.zeros_like(past_values)
-        future_values = future_values[:,:self.future_steps,:]
 
+   
         if 'x_num_future' in batch.keys(): 
             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_fut(x_mark_dec)
-            future_values[:,:,self.index_cat_fut] = x_mark_dec
+            future_values[:,:,self.index_fut_cat] = x_mark_dec
         
 
-        #investigating!!
-        freq_token = get_frequency_token(self.freq).repeat(past_values.shape[0])
+        #investigating!! problem with dynamo!
+        #freq_token = get_frequency_token(self.freq).repeat(past_values.shape[0])
+
+        batch_size = past_values.shape[0]
+        freq_token = self.token.repeat(batch_size).long().to(self.device)
+
 
         res = self.model(
             past_values= past_values,
@@ -134,7 +166,7 @@ class TTM(Base):
             future_observed_mask = None,
             output_hidden_states =  False,
             return_dict = False,
-            freq_token= freq_token, ##investigating
+            freq_token= freq_token,#[0:past_values.shape[0]], ##investigating
             static_categorical_values = None
         )
 

{dsipts-1.1.11 → dsipts-1.1.13}/src/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-1.1.11 → dsipts-1.1.13}/src/dsipts/models/base_v2.py

@@ -307,7 +307,7 @@ class Base(pl.LightningModule):
         self.train_epoch_count +=1
         return loss
 
-    
+
     def validation_step(self, batch, batch_idx):
         """
         pythotrch lightening stuff
@@ -320,15 +320,14 @@ class Base(pl.LightningModule):
         else:
             y_hat = self(batch)
             score = 0
-        if batch_idx==0:
+        #log_this_batch = (batch_idx == 0) and (self.count_epoch % int(max(self.trainer.max_epochs / 100,1)) == 1)
 
+        #if log_this_batch:
             #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:
-                self._val_outputs.append({
-                    "y": batch['y'].detach().cpu(),
-                    "y_hat": y_hat.detach().cpu()
-                })                
+        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

{dsipts-1.1.11 → dsipts-1.1.13}/src/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.11 → dsipts-1.1.13}/src/dsipts.egg-info/PKG-INFO

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