dsipts 1.1.13__py3-none-any.whl → 1.1.15__py3-none-any.whl

dsipts/__init__.py

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

dsipts/data_structure/data_structure.py

@@ -451,7 +451,8 @@ class TimeSeries():
 
         idx_target = []
         for c in self.target_variables:
-            idx_target.append(self.past_variables.index(c))
+            if c in self.past_variables:
+                idx_target.append(self.past_variables.index(c))
             
         idx_target_future = []
         
@@ -670,7 +671,7 @@ class TimeSeries():
                         if c!=self.group:                               
                             self.scaler_cat[f'{c}_{group}'] =  OrdinalEncoder(dtype=np.int32,handle_unknown= 'use_encoded_value',unknown_value=train[c].nunique())
                             self.scaler_cat[f'{c}_{group}'].fit(tmp[c].values.reshape(-1,1))  
-
+ 
         dl_train = self.create_data_loader(train,past_steps,future_steps,shift,keep_entire_seq_while_shifting,starting_point,skip_step)
         dl_validation = self.create_data_loader(validation,past_steps,future_steps,shift,keep_entire_seq_while_shifting,starting_point,skip_step)
         if test.shape[0]>0:
@@ -772,7 +773,24 @@ class TimeSeries():
         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)
-   
+        debug_prediction = True
+
+        if debug_prediction:
+            dl = DataLoader(test, batch_size = batch_size , shuffle=False,drop_last=True,num_workers=num_workers,persistent_workers=persistent_workers)
+            res = []
+            real = []
+            for batch in dl:
+        
+
+                res.append(self.model.inference(batch).cpu().detach().numpy())
+                real.append(batch['y'].cpu().detach().numpy())
+
+            res = np.vstack(res)
+            real = np.vstack(real)
+            with open('/home/agobbi/Projects/ExpTS/tmp_beginning.pkl','wb') as f:
+                import pickle
+                pickle.dump([res,real],f)
+        
         checkpoint_callback = ModelCheckpoint(dirpath=dirpath,
                                      monitor='val_loss',
                                       save_last = True,
@@ -867,23 +885,24 @@ class TimeSeries():
 
 
       
-
+     
         if auto_lr_find and (weight_exists is False):
-            if OLD_PL:
-                lr_tuner = trainer.tune(self.model,train_dataloaders=train_dl,val_dataloaders = valid_dl)
-                files = os.listdir(dirpath)
-                for f in files:
-                    if '.lr_find' in f:
-                        os.remove(os.path.join(dirpath,f))
-                self.model.optim_config['lr'] = lr_tuner['lr_find'].suggestion()
-            else:
-                from lightning.pytorch.tuner import Tuner
-                tuner = Tuner(trainer)
-                lr_finder = tuner.lr_find(self.model,train_dataloaders=train_dl,val_dataloaders = valid_dl)
-                self.model.optim_config['lr'] = lr_finder.suggestion() ## we are using it as optim key
+            try:
+                if OLD_PL:
+                    lr_tuner = trainer.tune(self.model,train_dataloaders=train_dl,val_dataloaders = valid_dl)
+                    files = os.listdir(dirpath)
+                    for f in files:
+                        if '.lr_find' in f:
+                            os.remove(os.path.join(dirpath,f))
+                    self.model.optim_config['lr'] = lr_tuner['lr_find'].suggestion()
+                else:
+                    from lightning.pytorch.tuner import Tuner
+                    tuner = Tuner(trainer)
+                    lr_finder = tuner.lr_find(self.model,train_dataloaders=train_dl,val_dataloaders = valid_dl)
+                    self.model.optim_config['lr'] = lr_finder.suggestion() ## we are using it as optim key
+            except Exception as e:
+                beauty_string(f'There is a problem with the finding LR routine {e}','section',self.verbose)
         
- 
-
         if OLD_PL:
             if weight_exists:
                 trainer.fit(self.model, train_dl,valid_dl,ckpt_path=os.path.join(dirpath,'last.ckpt'))
@@ -894,17 +913,36 @@ class TimeSeries():
                 trainer.fit(self.model, train_dataloaders = train_dl,val_dataloaders = valid_dl,ckpt_path=os.path.join(dirpath,'last.ckpt'))
             else:
                 trainer.fit(self.model, train_dataloaders = train_dl,val_dataloaders = valid_dl)
+
         self.checkpoint_file_best = checkpoint_callback.best_model_path
         self.checkpoint_file_last = checkpoint_callback.last_model_path 
         if self.checkpoint_file_last=='':
             beauty_string('There is a bug on saving last model I will try to fix it','info',self.verbose)
-            self.checkpoint_file_last = checkpoint_callback.best_model_path.replace('checkpoint','last')
+            self.checkpoint_file_last = os.path.join(dirpath, "last.ckpt")
+            trainer.save_checkpoint(os.path.join(dirpath, "last.ckpt"))
+        if self.checkpoint_file_best=='':
+            beauty_string('There is a bug on saving best model I will try to fix it','info',self.verbose)
+            self.checkpoint_file_best = os.path.join(dirpath, "checkpoint.ckpt")
+            trainer.save_checkpoint(os.path.join(dirpath, "checkpoint.ckpt"))
 
         self.dirpath = dirpath
         
         self.losses = mc.metrics
 
         files = os.listdir(dirpath)
+        if debug_prediction:
+            res = []
+            real = []
+            for batch in dl:
+                res.append(self.model.inference(batch).cpu().detach().numpy())
+                real.append(batch['y'].cpu().detach().numpy())
+
+            res = np.vstack(res)
+            real = np.vstack(real)
+            with open('/home/agobbi/Projects/ExpTS/tmp_after_training.pkl','wb') as f:
+                import pickle
+                pickle.dump([res,real],f)
+        
         ##accrocchio per multi gpu
         for f in files:
             if '__losses__.csv' in f:
@@ -917,7 +955,6 @@ class TimeSeries():
             self.losses = pd.DataFrame()
 
         try:
-
             if OLD_PL:
                 if isinstance(self.model, torch._dynamo.eval_frame.OptimizedModule):
                     self.model = self.model._orig_mod 
@@ -930,7 +967,21 @@ class TimeSeries():
                     self.model = mm.__class__.load_from_checkpoint(self.checkpoint_file_last)
                 else:
                     self.model = self.model.__class__.load_from_checkpoint(self.checkpoint_file_last)
+            if debug_prediction:
+                res = []
+                real = []
+                for batch in dl:
+            
 
+                    res.append(self.model.inference(batch).cpu().detach().numpy())
+                    real.append(batch['y'].cpu().detach().numpy())
+
+                res = np.vstack(res)
+                real = np.vstack(real)
+                with open('/home/agobbi/Projects/ExpTS/tmp_after_loading.pkl','wb') as f:
+                    import pickle
+                    pickle.dump([res,real],f)
+            
         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)
 
@@ -1008,12 +1059,15 @@ class TimeSeries():
         beauty_string(f'Device used: {self.model.device}','info',self.verbose)
 
         for batch in dl:
+    
+
             res.append(self.model.inference(batch).cpu().detach().numpy())
             real.append(batch['y'].cpu().detach().numpy())
-       
+
         res = np.vstack(res)
- 
         real = np.vstack(real)
+
+
         time = dl.dataset.t
         groups = dl.dataset.groups
         #import pdb
@@ -1203,15 +1257,21 @@ class TimeSeries():
                 
                 try:
                     tmp_path = os.path.join(directory,self.checkpoint_file_last.split('/')[-1])
+                    beauty_string(f"Loading {tmp_path}",'section',self.verbose)
+
                 except Exception as _:
                     beauty_string('checkpoint_file_last not defined try to load best','section',self.verbose)
                     tmp_path = os.path.join(directory,self.checkpoint_file_best.split('/')[-1])
+                    beauty_string(f"Loading {tmp_path}",'section',self.verbose)
             else:
                 try:
+                    
                     tmp_path = os.path.join(directory,self.checkpoint_file_best.split('/')[-1])
+                    beauty_string(f"Loading {tmp_path}",'section',self.verbose)
                 except Exception as _:
                     beauty_string('checkpoint_file_best not defined try to load best','section',self.verbose)
                     tmp_path = os.path.join(directory,self.checkpoint_file_last.split('/')[-1])
+                    beauty_string(f"Loading {tmp_path}",'section',self.verbose)
         try:
             #with torch.serialization.add_safe_globals([ListConfig]):
             if OLD_PL:
@@ -1219,5 +1279,6 @@ class TimeSeries():
             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/Persistent.py

@@ -30,6 +30,8 @@ class Persistent(Base):
         self.save_hyperparameters(logger=False)
         self.fake = nn.Linear(1,1)
         self.use_quantiles = False
+    def can_be_compiled(self):
+        return False
     
     def forward(self, batch):
      

dsipts/models/TTM.py

@@ -39,6 +39,7 @@ class TTM(Base):
                 fcm_prepend_past,
                 enable_forecast_channel_mixing,
                 force_return,
+                few_shot = True,
                 **kwargs)->None:
    
         super().__init__(**kwargs)
@@ -86,7 +87,8 @@ 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()
+        if few_shot:
+            self._freeze_backbone()
         self.zero_pad = (force_return=='zeropad') 
     def _freeze_backbone(self):
         """
@@ -113,7 +115,7 @@ class TTM(Base):
 
     def can_be_compiled(self):
         
-        return True#not self.zero_pad  
+        return True#True#not self.zero_pad  
   
     def forward(self, batch):
         x_enc = batch['x_num_past'].to(self.device)
@@ -172,6 +174,7 @@ class TTM(Base):
 
 
         BS = res.shape[0]
+
         return res.reshape(BS,self.future_steps,-1,self.mul)
         
     

dsipts/models/TimeKAN.py

@@ -0,0 +1,123 @@
+## Copyright https://github.com/huangst21/TimeKAN/blob/main/models/TimeKAN.py
+## Modified for notation alignmenet and batch structure
+## extended to what inside itransformer folder
+
+import torch
+import torch.nn as nn
+import numpy as np
+from .timekan.Layers import FrequencyDecomp,FrequencyMixing,series_decomp,Normalize
+from ..data_structure.utils import beauty_string
+from .utils import  get_scope,get_activation,Embedding_cat_variables
+
+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
+
+
+
+class TimeKAN(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, 
+                 # specific params
+                 down_sampling_window:int,
+                 e_layers:int,
+                 moving_avg:int,
+                 down_sampling_layers: int,
+                 d_model: int,
+                 begin_order: int,
+                 use_norm:bool,
+                 **kwargs)->None:
+             
+        
+        
+        
+        super().__init__(**kwargs)
+       
+        self.save_hyperparameters(logger=False)
+        self.e_layers = e_layers
+        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
+        
+        
+        
+        self.res_blocks = nn.ModuleList([FrequencyDecomp( self.past_steps,down_sampling_window,down_sampling_layers) for _ in range(e_layers)])
+        self.add_blocks = nn.ModuleList([FrequencyMixing(d_model,self.past_steps,begin_order,down_sampling_window,down_sampling_layers) for _ in range(e_layers)])
+
+        self.preprocess = series_decomp(moving_avg)
+        self.enc_in = self.past_channels + emb_past_out_channel
+        self.project = nn.Linear(self.enc_in,d_model)
+        self.layer = e_layers
+        self.normalize_layers = torch.nn.ModuleList(
+            [
+                Normalize(self.enc_in, affine=True, non_norm=use_norm)
+                for i in range(down_sampling_layers + 1)
+            ]
+        )
+        self.predict_layer =nn. Linear(
+                        self.past_steps,
+                        self.future_steps,
+                    )
+        self.final_layer = nn.Linear(d_model, self.mul)
+        self.down_sampling_layers = down_sampling_layers
+        self.down_sampling_window = down_sampling_window
+    def can_be_compiled(self):
+        return True#True  
+
+
+    def __multi_level_process_inputs(self, x_enc):
+        down_pool = torch.nn.AvgPool1d(self.down_sampling_window)
+        # B,T,C -> B,C,T
+        x_enc = x_enc.permute(0, 2, 1)
+        x_enc_ori = x_enc
+        x_enc_sampling_list = []
+        x_enc_sampling_list.append(x_enc.permute(0, 2, 1))
+        for i in range(self.down_sampling_layers):
+            x_enc_sampling = down_pool(x_enc_ori)
+            x_enc_sampling_list.append(x_enc_sampling.permute(0, 2, 1))
+            x_enc_ori = x_enc_sampling
+        x_enc = x_enc_sampling_list
+        return x_enc
+
+
+    def forward(self, batch:dict)-> float:
+
+        x_enc = batch['x_num_past'].to(self.device)
+        BS = x_enc.shape[0]
+        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)
+
+        x_past = torch.cat([x_enc,emb_past],2)
+
+        x_enc = self.__multi_level_process_inputs(x_past)
+
+        x_list = []
+        for i, x in zip(range(len(x_enc)), x_enc, ):
+            B, T, N = x.size()
+            x = self.normalize_layers[i](x, 'norm')
+            x = x.permute(0, 2, 1).contiguous().reshape(B * N, T, 1)
+            x_list.append(self.project(x.reshape(B, T, N)))
+
+
+
+        for i in range(self.layer):
+            x_list = self.res_blocks[i](x_list)
+            x_list = self.add_blocks[i](x_list)
+
+        dec_out = x_list[0]
+        dec_out = self.predict_layer(dec_out.permute(0, 2, 1)).permute( 0, 2, 1)  
+        dec_out = self.final_layer(dec_out)
+
+        return dec_out.reshape(BS,self.future_steps,self.out_channels,self.mul)

dsipts/models/TimesNet.py

@@ -0,0 +1,96 @@
+## Copyright https://github.com/thuml/Time-Series-Library/blob/main/models/TimesNet.py
+## Modified for notation alignmenet and batch structure
+## extended to what inside itransformer folder
+
+import torch
+import torch.nn as nn
+import numpy as np
+from .timesnet.Layers import TimesBlock
+from ..data_structure.utils import beauty_string
+from .utils import  get_scope,get_activation,Embedding_cat_variables
+
+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
+
+
+
+class TimesNet(Base):
+    handle_multivariate = True
+    handle_future_covariates = False
+    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, 
+                 # specific params
+                 e_layers:int,
+                 d_model: int,
+                 top_k: int,
+                 d_ff: int,
+                 num_kernels: int,
+                 **kwargs)->None:
+             
+        
+        
+        
+        super().__init__(**kwargs)
+ 
+        self.save_hyperparameters(logger=False)
+        self.e_layers = e_layers
+        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.prepare = nn.Linear(emb_past_out_channel+self.past_channels, d_model)
+
+        self.model = nn.ModuleList([TimesBlock(self.past_steps,self.future_steps,top_k,d_model,d_ff,num_kernels) for _ in range(e_layers)])
+        self.layer_norm = nn.LayerNorm(d_model)
+
+        self.predict_linear = nn.Linear(self.past_steps, self.future_steps + self.past_steps)
+  
+        self.projection = nn.Linear(d_model, self.out_channels*self.mul, bias=True)
+  
+    def can_be_compiled(self):
+        return False#True  
+
+    def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
+        # Normalization from Non-stationary Transformer
+        #means = x_enc.mean(1, keepdim=True).detach()
+        #x_enc = x_enc.sub(means)
+        #stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5)
+        #x_enc = x_enc.div(stdev)
+
+        # embedding
+        enc_out = torch.cat([x_enc, x_mark_enc],axis=2)  # [B,T,C]
+        enc_out = self.predict_linear(enc_out.permute(0, 2, 1)).permute(0, 2, 1)  # align temporal dimension
+        # TimesNet
+        enc_out = self.prepare(enc_out)
+        for i in range(self.e_layers):
+            enc_out = self.layer_norm(self.model[i](enc_out))
+        # project back
+        dec_out = self.projection(enc_out)
+
+        # De-Normalization from Non-stationary Transformer
+        #dec_out = dec_out.mul((stdev[:, 0, :].unsqueeze(1).repeat(1, self.future_steps + self.past_steps, 1)))
+        #dec_out = dec_out.add((means[:, 0, :].unsqueeze(1).repeat(1, self.future_steps + self.past_steps, 1)))
+        return dec_out
+
+    def forward(self, batch:dict)-> float:
+
+        x_enc = batch['x_num_past'].to(self.device)
+        BS = x_enc.shape[0]
+        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)
+
+        dec_out = self.forecast(x_enc, emb_past, None, None)
+
+        return dec_out[:, -self.future_steps:,:].reshape(BS,self.future_steps,self.out_channels,self.mul)

dsipts/models/base.py

@@ -14,6 +14,7 @@ import matplotlib.pyplot as plt
 from typing import List, Union
 from .utils import QuantileLossMO, CPRS
 import torch.nn as nn
+from torch.optim import Adam, AdamW, SGD, RMSprop   
 
 def standardize_momentum(x,order):
     mean = torch.mean(x,1).unsqueeze(1).repeat(1,x.shape[1],1)
@@ -336,7 +337,7 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        if len(self._val_outputs)>0:
+        if (len(self._val_outputs)>0) & (self.trainer.max_epochs>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:
@@ -392,8 +393,15 @@ class Base(pl.LightningModule):
             initial_loss = self.loss(y_hat[:,:,:,0], batch['y'])
         else:
             initial_loss = self.loss(y_hat, batch['y'])
+            
+        if  self.loss_type in ['mse','l1']:
+            return initial_loss
+            
         x =  batch['x_num_past'].to(self.device)
         idx_target = batch['idx_target'][0]
+        if idx_target is None:
+            beauty_string(f'Can not compute non-standard loss for non autoregressive models, if you want to use custom losses please add check=True wile initialize the time series object','info',self.verbose)
+            return initial_loss
         x_start = x[:,-1,idx_target].unsqueeze(1)
         y_persistence = x_start.repeat(1,self.future_steps,1)
         

dsipts/models/base_v2.py

@@ -14,6 +14,7 @@ import matplotlib.pyplot as plt
 from typing import List, Union
 from .utils import QuantileLossMO, CPRS
 import torch.nn as nn
+from torch.optim import Adam, AdamW, SGD, RMSprop   
 
 def standardize_momentum(x,order):
     mean = torch.mean(x,1).unsqueeze(1).repeat(1,x.shape[1],1)
@@ -220,7 +221,7 @@ class Base(pl.LightningModule):
 
         
         if self.optim is None:
-            optimizer = optim.Adam(self.parameters(),  **self.optim_config)
+            optimizer = Adam(self.parameters(),  **self.optim_config)
             self.initialize = True
             
         else:
@@ -237,7 +238,7 @@ class Base(pl.LightningModule):
 
             beauty_string(self.optim,'',self.verbose)
             if self.has_sam_optim:
-                optimizer = SAM(self.parameters(), base_optimizer=torch.optim.Adam, **self.optim_config)
+                optimizer = SAM(self.parameters(), base_optimizer=Adam, **self.optim_config)
             else:
                 optimizer = self.optim(self.parameters(),  **self.optim_config)
             beauty_string(optimizer,'',self.verbose)
@@ -314,7 +315,7 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-
+  
         if self.return_additional_loss:
             y_hat,score = self(batch)
         else:
@@ -335,7 +336,6 @@ class Base(pl.LightningModule):
     def on_validation_start(self):
         # reset buffer each epoch
         self._val_outputs = []
-    
 
     def on_validation_epoch_end(self):
         """
@@ -344,7 +344,7 @@ class Base(pl.LightningModule):
         :meta private:
         """   
 
-        if len(self._val_outputs)>0:
+        if (len(self._val_outputs)>0) & (self.trainer.max_epochs>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:
@@ -353,6 +353,7 @@ class Base(pl.LightningModule):
                 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')
@@ -363,7 +364,7 @@ class Base(pl.LightningModule):
                 #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_()
@@ -407,8 +408,17 @@ class Base(pl.LightningModule):
             initial_loss = self.loss(y_hat[:,:,:,0], batch['y'])
         else:
             initial_loss = self.loss(y_hat, batch['y'])
+            
+        if  self.loss_type in ['mse','l1']:
+            return initial_loss
+        
         x =  batch['x_num_past'].to(self.device)
+        
         idx_target = batch['idx_target'][0]
+        
+        if idx_target is None:
+            beauty_string(f'Can not compute non-standard loss for non autoregressive models, if you want to use custom losses please add check=True wile initialize the time series object','info',self.verbose)
+            return initial_loss
         x_start = x[:,-1,idx_target].unsqueeze(1)
         y_persistence = x_start.repeat(1,self.future_steps,1)
         
@@ -423,7 +433,7 @@ class Base(pl.LightningModule):
             persistence_error = (2.0-10.0*torch.clamp( torch.abs((y_persistence-x)/(0.001+torch.abs(y_persistence))),min=0.0,max=max(0.05,0.1*(1+np.log10(self.persistence_weight)  ))))
             loss = torch.mean(torch.abs(x- batch['y'])*persistence_error)
         
-        if self.loss_type == 'mda':
+        elif self.loss_type == 'mda':
             #import pdb
             #pdb.set_trace()
             mda =  (1-torch.mean( torch.sign(torch.diff(x,axis=1))*torch.sign(torch.diff(batch['y'],axis=1))))

dsipts/models/timekan/Layers.py

@@ -0,0 +1,284 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.fft
+
+
+class Normalize(nn.Module):
+    def __init__(self, num_features: int, eps=1e-5, affine=False, subtract_last=False, non_norm=False):
+        """
+        :param num_features: the number of features or channels
+        :param eps: a value added for numerical stability
+        :param affine: if True, RevIN has learnable affine parameters
+        """
+        super(Normalize, self).__init__()
+        self.num_features = num_features
+        self.eps = eps
+        self.affine = affine
+        self.subtract_last = subtract_last
+        self.non_norm = non_norm
+        if self.affine:
+            self._init_params()
+
+    def forward(self, x, mode: str):
+        if mode == 'norm':
+            self._get_statistics(x)
+            x = self._normalize(x)
+        elif mode == 'denorm':
+            x = self._denormalize(x)
+        else:
+            raise NotImplementedError
+        return x
+
+    def _init_params(self):
+        # initialize RevIN params: (C,)
+        self.affine_weight = nn.Parameter(torch.ones(self.num_features))
+        self.affine_bias = nn.Parameter(torch.zeros(self.num_features))
+
+    def _get_statistics(self, x):
+        dim2reduce = tuple(range(1, x.ndim - 1))
+        if self.subtract_last:
+            self.last = x[:, -1, :].unsqueeze(1)
+        else:
+            self.mean = torch.mean(x, dim=dim2reduce, keepdim=True).detach()
+        self.stdev = torch.sqrt(torch.var(x, dim=dim2reduce, keepdim=True, unbiased=False) + self.eps).detach()
+
+    def _normalize(self, x):
+        if self.non_norm:
+            return x
+        if self.subtract_last:
+            x = x - self.last
+        else:
+            x = x - self.mean
+        x = x / self.stdev
+        if self.affine:
+            x = x * self.affine_weight
+            x = x + self.affine_bias
+        return x
+
+    def _denormalize(self, x):
+        if self.non_norm:
+            return x
+        if self.affine:
+            x = x - self.affine_bias
+            x = x / (self.affine_weight + self.eps * self.eps)
+        x = x * self.stdev
+        if self.subtract_last:
+            x = x + self.last
+        else:
+            x = x + self.mean
+        return x
+
+class ChebyKANLinear(nn.Module):
+    def __init__(self, input_dim, output_dim, degree):
+        super(ChebyKANLinear, self).__init__()
+        self.inputdim = input_dim
+        self.outdim = output_dim
+        self.degree = degree
+
+        self.cheby_coeffs = nn.Parameter(torch.empty(input_dim, output_dim, degree + 1))
+        self.epsilon = 1e-7
+        self.pre_mul = False
+        self.post_mul = False
+        nn.init.normal_(self.cheby_coeffs, mean=0.0, std=1 / (input_dim * (degree + 1)))
+        self.register_buffer("arange", torch.arange(0, degree + 1, 1))
+
+    def forward(self, x):
+        # Since Chebyshev polynomial is defined in [-1, 1]
+        # We need to normalize x to [-1, 1] using tanh
+        # View and repeat input degree + 1 times
+        b,c_in = x.shape
+        if self.pre_mul:
+            mul_1 = x[:,::2]
+            mul_2 = x[:,1::2]
+            mul_res = mul_1 * mul_2
+            x = torch.concat([x[:,:x.shape[1]//2], mul_res])
+        x = x.view((b, c_in, 1)).expand(
+            -1, -1, self.degree + 1
+        )  # shape = (batch_size, inputdim, self.degree + 1)
+        # Apply acos
+        x = torch.tanh(x)
+        x = torch.tanh(x)
+        x = torch.acos(x)
+        # x = torch.acos(torch.clamp(x, -1 + self.epsilon, 1 - self.epsilon))
+        # # Multiply by arange [0 .. degree]
+        x = x* self.arange
+        # Apply cos
+        x = x.cos()
+        # Compute the Chebyshev interpolation
+        y = torch.einsum(
+            "bid,iod->bo", x, self.cheby_coeffs
+        )  # shape = (batch_size, outdim)
+        y = y.view(-1, self.outdim)
+        if self.post_mul:
+            mul_1 = y[:,::2]
+            mul_2 = y[:,1::2]
+            mul_res = mul_1 * mul_2
+            y = torch.concat([y[:,:y.shape[1]//2], mul_res])
+        return y
+
+class ChebyKANLayer(nn.Module):
+    def __init__(self, in_features, out_features,order):
+        super().__init__()
+        self.fc1 = ChebyKANLinear(
+                            in_features,
+                            out_features,
+                            order)
+    def forward(self, x):
+        B, N, C = x.shape
+        x = self.fc1(x.reshape(B*N,C))
+        x = x.reshape(B,N,-1).contiguous()
+        return x
+    
+
+class FrequencyDecomp(nn.Module):
+
+    def __init__(self, seq_len,down_sampling_window,down_sampling_layers):
+        super(FrequencyDecomp, self).__init__()
+        self.seq_len = seq_len
+        self.down_sampling_window = down_sampling_window
+        self.down_sampling_layers = down_sampling_layers
+
+    def forward(self, level_list):
+      
+        level_list_reverse = level_list.copy()
+        level_list_reverse.reverse()
+        out_low = level_list_reverse[0]
+        out_high = level_list_reverse[1]
+        out_level_list = [out_low]
+        for i in range(len(level_list_reverse) - 1):
+            out_high_res = self.frequency_interpolation(out_low.transpose(1,2),
+                                                        self.seq_len // (self.down_sampling_window ** (self.down_sampling_layers-i)),
+                                                        self.seq_len // (self.down_sampling_window ** (self.down_sampling_layers-i-1))
+                                                        ).transpose(1,2)
+            out_high_left = out_high - out_high_res
+            out_low = out_high
+            if i + 2 <= len(level_list_reverse) - 1:
+                out_high = level_list_reverse[i + 2]    
+            out_level_list.append(out_high_left) 
+        out_level_list.reverse()
+        return out_level_list   
+    
+    def frequency_interpolation(self,x,seq_len,target_len):
+        len_ratio = seq_len/target_len
+        x_fft = torch.fft.rfft(x, dim=2)
+        out_fft = torch.zeros([x_fft.size(0),x_fft.size(1),target_len//2+1],dtype=x_fft.dtype).to(x_fft.device)
+        out_fft[:,:,:seq_len//2+1] = x_fft
+        out = torch.fft.irfft(out_fft, dim=2)
+        out = out * len_ratio
+        return out
+    
+
+class FrequencyMixing(nn.Module):
+
+    def __init__(self, d_model,seq_len,begin_order,down_sampling_window,down_sampling_layers):
+        super(FrequencyMixing, self).__init__()
+        self.front_block = M_KAN(d_model,seq_len // (down_sampling_window ** (down_sampling_layers)),order=begin_order)
+        self.d_model = d_model
+        self.seq_len = seq_len
+        self.begin_order = begin_order
+        self.down_sampling_window = down_sampling_window
+        self.down_sampling_layers = down_sampling_layers
+
+        self.front_blocks = torch.nn.ModuleList(
+                [
+                    M_KAN(d_model,
+                          seq_len // (down_sampling_window ** (down_sampling_layers-i-1)),
+                          order=i+begin_order+1)
+                    for i in range(down_sampling_layers)
+                ])
+     
+    def forward(self, level_list):
+        level_list_reverse = level_list.copy()
+        level_list_reverse.reverse()
+        out_low = level_list_reverse[0]
+        out_high = level_list_reverse[1]
+        out_low = self.front_block(out_low)
+        out_level_list = [out_low]
+        for i in range(len(level_list_reverse) - 1):
+            out_high = self.front_blocks[i](out_high)
+            out_high_res = self.frequency_interpolation(out_low.transpose(1,2),
+                                            self.seq_len // (self.down_sampling_window ** (self.down_sampling_layers-i)),
+                                            self.seq_len // (self.down_sampling_window ** (self.down_sampling_layers-i-1))
+                                            ).transpose(1,2)
+            out_high = out_high + out_high_res
+            out_low = out_high
+            if i + 2 <= len(level_list_reverse) - 1:
+                out_high = level_list_reverse[i + 2]    
+            out_level_list.append(out_low) 
+        out_level_list.reverse()
+        return out_level_list
+
+    def frequency_interpolation(self,x,seq_len,target_len):
+        len_ratio = seq_len/target_len
+        x_fft = torch.fft.rfft(x, dim=2)
+        out_fft = torch.zeros([x_fft.size(0),x_fft.size(1),target_len//2+1],dtype=x_fft.dtype).to(x_fft.device)
+        out_fft[:,:,:seq_len//2+1] = x_fft
+        out = torch.fft.irfft(out_fft, dim=2)
+        out = out * len_ratio
+        return out
+    
+class M_KAN(nn.Module):
+    def __init__(self,d_model,seq_len,order):
+        super().__init__()
+        self.channel_mixer = nn.Sequential(
+            ChebyKANLayer(d_model, d_model,order)
+        )
+        self.conv = BasicConv(d_model,d_model,kernel_size=3,degree=order,groups=d_model)
+    def forward(self,x):
+        x1 = self.channel_mixer(x)
+        x2 = self.conv(x)
+        out  = x1 + x2
+        return out 
+
+class BasicConv(nn.Module):
+    def __init__(self,c_in,c_out, kernel_size, degree,stride=1, padding=0, dilation=1, groups=1, act=False, bn=False, bias=False,dropout=0.):
+        super(BasicConv, self).__init__()
+        self.out_channels = c_out
+        self.conv = nn.Conv1d(c_in,c_out, kernel_size=kernel_size, stride=stride, padding=kernel_size//2, dilation=dilation, groups=groups, bias=bias)
+        self.bn = nn.BatchNorm1d(c_out) if bn else None
+        self.act = nn.GELU() if act else None
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, x): 
+        if self.bn is not None:
+            x = self.bn(x)
+        x = self.conv(x.transpose(-1,-2)).transpose(-1,-2)
+        if self.act is not None:
+            x = self.act(x)
+        if self.dropout is not None:
+            x = self.dropout(x)
+        return x
+  
+  
+class moving_avg(nn.Module):
+    """
+    Moving average block to highlight the trend of time series
+    """
+
+    def __init__(self, kernel_size, stride):
+        super(moving_avg, self).__init__()
+        self.kernel_size = kernel_size
+        self.avg = nn.AvgPool1d(kernel_size=kernel_size, stride=stride, padding=0)
+
+    def forward(self, x):
+        # padding on the both ends of time series
+        front = x[:, 0:1, :].repeat(1, (self.kernel_size - 1) // 2, 1)
+        end = x[:, -1:, :].repeat(1, (self.kernel_size - 1) // 2, 1)
+        x = torch.cat([front, x, end], dim=1)
+        x = self.avg(x.permute(0, 2, 1))
+        x = x.permute(0, 2, 1)
+        return x
+      
+class series_decomp(nn.Module):
+    """
+    Series decomposition block
+    """
+
+    def __init__(self, kernel_size):
+        super(series_decomp, self).__init__()
+        self.moving_avg = moving_avg(kernel_size, stride=1)
+
+    def forward(self, x):
+        moving_mean = self.moving_avg(x)
+        res = x - moving_mean
+        return res, moving_mean

dsipts/models/timesnet/Layers.py

@@ -0,0 +1,95 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.fft
+
+
+class Inception_Block_V1(nn.Module):
+    def __init__(self, in_channels, out_channels, num_kernels=6, init_weight=True):
+        super(Inception_Block_V1, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_kernels = num_kernels
+        kernels = []
+        for i in range(self.num_kernels):
+            kernels.append(nn.Conv2d(in_channels, out_channels, kernel_size=2 * i + 1, padding=i))
+        self.kernels = nn.ModuleList(kernels)
+        if init_weight:
+            self._initialize_weights()
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        res_list = []
+        for i in range(self.num_kernels):
+            res_list.append(self.kernels[i](x))
+        res = torch.stack(res_list, dim=-1).mean(-1)
+        return res
+
+def FFT_for_Period(x, k=2):
+    # [B, T, C]
+    xf = torch.fft.rfft(x, dim=1)
+    # find period by amplitudes
+    frequency_list = abs(xf).mean(0).mean(-1)
+    frequency_list[0] = 0
+    _, top_list = torch.topk(frequency_list, k)
+    top_list = top_list.detach().cpu().numpy()
+    period = x.shape[1] // top_list
+    return period, abs(xf).mean(-1)[:, top_list]
+
+
+
+class TimesBlock(nn.Module):
+    def __init__(self, seq_len,pred_len,top_k,d_model,d_ff,num_kernels):
+        super(TimesBlock, self).__init__()
+        self.seq_len = seq_len
+        self.pred_len = pred_len
+        self.k = top_k
+        # parameter-efficient design
+        self.conv = nn.Sequential(
+            Inception_Block_V1(d_model, d_ff,
+                               num_kernels=num_kernels),
+            nn.GELU(),
+            Inception_Block_V1(d_ff, d_model,
+                               num_kernels=num_kernels)
+        )
+
+    def forward(self, x):
+        B, T, N = x.size()
+
+        period_list, period_weight = FFT_for_Period(x, self.k)
+
+        res = []
+        for i in range(self.k):
+            period = period_list[i]
+            # padding
+            if (self.seq_len + self.pred_len) % period != 0:
+                length = (
+                                 ((self.seq_len + self.pred_len) // period) + 1) * period
+                padding = torch.zeros([x.shape[0], (length - (self.seq_len + self.pred_len)), x.shape[2]]).to(x.device)
+                out = torch.cat([x, padding], dim=1)
+            else:
+                length = (self.seq_len + self.pred_len)
+                out = x
+            # reshape
+            out = out.reshape(B, length // period, period,
+                              N).permute(0, 3, 1, 2).contiguous()
+            # 2D conv: from 1d Variation to 2d Variation
+            out = self.conv(out)
+            # reshape back
+            out = out.permute(0, 2, 3, 1).reshape(B, -1, N)
+            res.append(out[:, :(self.seq_len + self.pred_len), :])
+        res = torch.stack(res, dim=-1)
+        # adaptive aggregation
+        period_weight = F.softmax(period_weight, dim=1)
+        period_weight = period_weight.unsqueeze(
+            1).unsqueeze(1).repeat(1, T, N, 1)
+        res = torch.sum(res * period_weight, -1)
+        # residual connection
+        res = res + x
+        return res

dsipts/version.py

@@ -0,0 +1 @@
+__version__ = "1.1.15"

{dsipts-1.1.13.dist-info → dsipts-1.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsipts
-Version: 1.1.13
+Version: 1.1.15
 Summary: Unified library for timeseries modelling
 Author-email: Andrea Gobbi <agobbi@fbk.eu>
 Project-URL: Homepage, https://github.com/DSIP-FBK/DSIPTS
@@ -398,6 +398,8 @@ and then open the url (http://127.0.0.1:43800)[http://127.0.0.1:43800]. It will
 
 
 ## TODO
+[ ] some models can not work in a non-autoregressive way (target past variable is required). Relax some constraints in the forward loop can help this
+
 [ ] reduce test time 
 
 [ ] add pre-commit hook for code checking (`ruff check --ignore E501,E722 .`)
@@ -406,15 +408,12 @@ and then open the url (http://127.0.0.1:43800)[http://127.0.0.1:43800]. It will
 
 [ ] clean code and standardize documentation
 
-[ ] add more sintetic data
-
 [ ] check all the code in the README 
 
 [ ] check architecture description (which model can be used under certain assumption) 
 
 [ ] complete the classification part (loss function + inference step)
 
-
 [ ] check D3VAE, it seems broken in some configurations
 
 [ ] add hybrid models https://www.sciencedirect.com/science/article/pii/S138912862400118X
@@ -425,11 +424,60 @@ and then open the url (http://127.0.0.1:43800)[http://127.0.0.1:43800]. It will
 
 [ ] add https://github.com/decisionintelligence/pathformer
 
-[x] add Duet
+[ ] in 1.1.5 we split the future and past categorical variables. D3VAE &^ Diffusion to be revised 
+
+[ ] all snippet of code and notebook must be review in 1.1.5 (categorical past and future, embedding layer parameters)
 
-[x] add categorical support to Crossformer, Samformer 
 
-[ ] in 1.1.5 we split the future and past categorical variables. D3VAE, Diffusion, TTM need to be revised 
 
-[ ] all snippet of code and notebook must be review in 1.1.5 (categorical past and future, embedding layer parameters)
+## 1.1.14 (2025-12-02)
+- Add CHANGELOG to the pip page
+- Bug fixing for non autoregressive models
+- Added TimesNet, TimeKAN
+- Added 0 shot and full shot TTM
+- added more option parameter to define an experiment (`split_params`, `optim_config` and `train_config`)
+## 1.1.13 (2025-12-02)
+
+- Added weight for the WeightedRandomSampler (only for the training part)
+- Bug fixing when using groups in the categorical variables
+- TTM fixed for working with zeropad for shorter sequences and future covariates
+
+## 1.1.12 (2025-11-07)
+- Bug fixing dynamo stuff for `TTM`
+- Bug fixing loading weights after training process ('dynamo module can not load weights`)
+- Force to not compile some models (there are piece of code that are not aligned with dynamo)
+- Bug fixing test configurations
 
+## 1.1.11 (2025-11-06)
+- Added `torch.compile` for better performance on recent GPU
+- Stable `TTM` model according to version 1.1.5, still under debug, use at your own risk
+- Bux Fixing `cprs` inference (now produces 3 quantiles: `[0.05, 0.5, 0.95]`). The `persistence_weight` is the value of `alpha` in the paper (between 0 and 1)
+
+## 1.1.9 (2025-09-19)
+- Added `cprs` https://arxiv.org/pdf/2412.15832v1 loss function. In this case use the quantile parameter to ask for the ensembles: `quantiles = [1,2,3,4,5,6,7,8,9,10]` will create 10 ensembles. For now the inference part will return just the mean, TODO: estimate a confidence interval with the ensembles 
+- Added `long_lag` the L1 error will be modulated with a linear weight depending on the lag in the future: the penalization goes from `1` to `persistence_weight`
+
+## 1.1.8 (2025-09-12)
+- Added `Simple` model (just two linear layers)
+
+## 1.1.7 (2025-09-08)
+- bug fixing `DilatedConv`
+## 1.1.5 (2025-08-29)
+- rewriting most of the modules for handling different future and past categorical variables
+- extension of categorical and future covariates in almost all the models
+- `uv` full management of the package
+- refactoring almost all the structure and documentation
+
+## 1.1.4 (2025-08-22)
+- added `restart: true` tro model configuration to restart the training procedure: carefurl the max_epochs should be increased if you need to retrain
+
+## 1.1.4 (2025-07-29)
+- bug fixing tuner learning rate
+- added TTM model and TimeXer
+- added compatibility with newer version of lightening and torch
+
+## 1.1.1 
+- added [SAM optimizer](https://arxiv.org/pdf/2402.10198) 
+```bash
+ python train.py  --config-dir=config_test --config-name=config architecture=itransformer dataset.path=/home/agobbi/Projects/ExpTS/data train_config.dirpath=tmp inference=tmp model_configs.optim=SAM +optim_config.rho=0.5
+ ```

{dsipts-1.1.13.dist-info → dsipts-1.1.15.dist-info}/RECORD

@@ -1,9 +1,10 @@
-dsipts/__init__.py,sha256=UWmrBJ2LLoRCKLOyTBSJAw9n31o8ZwNjLoRAax5Wll8,1694
+dsipts/__init__.py,sha256=2KK6XbUewsjmQQ6-zNMKIcFP01jtcXskcwr3qZwQToE,1822
+dsipts/version.py,sha256=-YHzv8tja4CPgI4M3Z_0Bj8CLGmAigr5FWkvYuc_I64,22
 dsipts/data_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=vOiVuTbEprXwpf8l5hk-7HP3v_r5d3YiXuQdGwo4nV0,62295
+dsipts/data_structure/data_structure.py,sha256=QO2z0gtR2lv1t9DuYF3S1LSz1Ecux0CjL1G9lT5lGaY,64928
 dsipts/data_structure/modifiers.py,sha256=qlry9dfw8pEE0GrvgwROZJkJ6oPpUnjEHPIG5qIetss,7948
 dsipts/data_structure/utils.py,sha256=ZL-z_InmFUkge5kQoHSrev1t6nyve9sTYTVeA75Or-I,6689
 dsipts/models/Autoformer.py,sha256=nUQvPC_qtajLT1AHdNJmF_P3ZL01j3spkZ4ubxdGF3g,8497
@@ -17,19 +18,21 @@ dsipts/models/ITransformer.py,sha256=2WXqqEvnWH2DqRQyXfGm4Eg4_q32GFy2XnNeoTl-KmY
 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/Persistent.py,sha256=CPHLgqAIPWbxYqzCNpxB2kh8J2-LJsvrbv9OVC72A8o,1301
 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=PoRDT-KYoMqv6yIOU-73E7Y2pRyd4lga0u6KrJRd5DU,6561
+dsipts/models/TTM.py,sha256=CGKtO992_ty5_AX27llMd1TsvKLP8ZKpR8Xbx1F8Ws4,6625
+dsipts/models/TimeKAN.py,sha256=bJEIJZIksi0jhN9ZttXezATwxJj9DkWjO1WNwDD5Fbw,4686
 dsipts/models/TimeXER.py,sha256=EkmlHfT2RegY6Ce6q8EUEV1a_WZ6SkYibnOZXqsyd_8,7111
+dsipts/models/TimesNet.py,sha256=1OekvmqZidfPqoSMFsG7pK6Xcgen8IMTEu0n9ZQMEPc,3895
 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=Gqsycy8ZXGaIVx9vvmYRpBCqdUxGE4tvC5ltgxlpEYY,19640
-dsipts/models/base_v2.py,sha256=03cueZExRhkJyBVIHuUPB8sjsCd5Go1HJAR81CADg-c,19896
+dsipts/models/base.py,sha256=aWvtDiBnmONsJ96tgaZRewB_yrqI8yvlAlH6PdpWrLA,20099
+dsipts/models/base_v2.py,sha256=BNmBQXMDnGsZABu0nOu8d3f3anNQZbgNBCwlMr-k8lQ,20346
 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
@@ -64,6 +67,10 @@ dsipts/models/samformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 dsipts/models/samformer/utils.py,sha256=62p5fzippKwZpqZBQghrHyA_ANeaFa-TC5EM4L6Q7DE,5583
 dsipts/models/tft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/tft/sub_nn.py,sha256=6UDI0BvxEcF5N1_Wx3-WL0PO99k8QtI7JTsEAaosb5k,8881
+dsipts/models/timekan/Layers.py,sha256=T-saVZFYHkMtbXgD8eIp2q_ZM4fcItNzw4PUo4KC-gM,10771
+dsipts/models/timekan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/timesnet/Layers.py,sha256=Jh42klg2QFSnE1vLH35uZXp8A8xo6cvj3d3gTuvym64,3460
+dsipts/models/timesnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/timexer/Layers.py,sha256=-QG4a70sBQFoRoE6CfisOkKhm4kIdB21DBtQ4V-7fHw,4699
 dsipts/models/timexer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/ttm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -76,7 +83,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.13.dist-info/METADATA,sha256=6UZ0nHk0RoGXxxkPYCyB0w41m8LlOE5BfoiswplloXQ,24795
-dsipts-1.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dsipts-1.1.13.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
-dsipts-1.1.13.dist-info/RECORD,,
+dsipts-1.1.15.dist-info/METADATA,sha256=1i5fPSZJxFoQPkvf-PVwHf6faoD6vFhixMDucbowQdM,27477
+dsipts-1.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsipts-1.1.15.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
+dsipts-1.1.15.dist-info/RECORD,,